@stage-labs/metro 0.1.0-beta.162 → 0.1.0-beta.164

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.162",
+  "version": "0.1.0-beta.164",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/marketplace/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.162",
+  "version": "0.1.0-beta.164",
   "description": "Metro for Claude Code, installed by the metro daemon on this machine: every connector the agent holds as its own MCP server relayed through the daemon, the orchestrator-only guard on the main thread, and the standing rules loaded at each session start. No vendor credential ever sits in a config file.",
   "author": {
     "name": "Bonustrack",

package/runtime/node_modules/@metro-labs/core/src/events.ts

@@ -20,8 +20,6 @@ export interface MetroEvent {
   from: Line;
   fromName?: string;
   fromDisplayName?: string;
-  fromAvatar?: string;
-  fromAbout?: string;
   to: Line;
   text?: string;
   messageId?: string;

package/runtime/node_modules/@metro-labs/core/src/protocol.ts

@@ -33,8 +33,6 @@ export type TrainEvent = {
   from?: string;
   from_name?: string;
   from_display_name?: string;
-  from_avatar?: string;
-  from_about?: string;
   to?: string;
   message_id?: string;
   reply_to?: string;

package/runtime/node_modules/@metro-labs/core/src/stations/sender-profile.ts

@@ -1,29 +1,30 @@
 export interface SenderProfile {
-  from_name?: string;
-  from_display_name?: string;
-  from_avatar?: string;
-  from_about?: string;
+  id: string;
+  name?: string;
+  display_name?: string;
+  about?: string;
+  avatar?: string;
+  address?: string;
 }
 
 export interface ProfileCacheOptions {
   ttlMs?: number;
   max?: number;
-  timeoutMs?: number;
   onError: (key: string, err: unknown) => void;
 }
 
 export interface ProfileCache<T> {
   get(key: string): Promise<T | null>;
-  within(key: string, ms?: number): Promise<T | null>;
+  peek(key: string): T | null;
 }
 
 const TTL_MS = 10 * 60_000;
 const MAX = 2000;
-const TIMEOUT_MS = 3000;
 
 interface Held<T> {
   at: number;
   value: Promise<T | null>;
+  settled: T | null;
 }
 
 export const nonEmpty = (v: unknown): string | undefined => (typeof v === 'string' && v.trim() !== '' ? v.trim() : undefined);
@@ -32,29 +33,32 @@ export function makeProfileCache<T>(lookup: (key: string) => Promise<T | null>,
   const ttl = opts.ttlMs ?? TTL_MS;
   const max = opts.max ?? MAX;
   const cache = new Map<string, Held<T>>();
-  const get = (key: string): Promise<T | null> => {
+  const fresh = (key: string): Held<T> | undefined => {
     const held = cache.get(key);
-    if (held !== undefined && Date.now() - held.at < ttl) return held.value;
-    const value = lookup(key).catch((err: unknown) => {
-      opts.onError(key, err);
-      cache.delete(key);
-      return null;
-    });
-    cache.set(key, { at: Date.now(), value });
+    return held !== undefined && Date.now() - held.at < ttl ? held : undefined;
+  };
+  const start = (key: string): Held<T> => {
+    const held: Held<T> = { at: Date.now(), settled: null, value: Promise.resolve(null) };
+    held.value = lookup(key)
+      .then((value) => {
+        held.settled = value;
+        return value;
+      })
+      .catch((err: unknown) => {
+        opts.onError(key, err);
+        cache.delete(key);
+        return null;
+      });
+    cache.set(key, held);
     while (cache.size > max) {
       const oldest = cache.keys().next();
       if (oldest.done) break;
       cache.delete(oldest.value);
     }
-    return value;
+    return held;
   };
-  const within = (key: string, ms = opts.timeoutMs ?? TIMEOUT_MS): Promise<T | null> => {
-    const wait = new Promise<null>((resolve) => {
-      setTimeout(() => {
-        resolve(null);
-      }, ms).unref();
-    });
-    return Promise.race([get(key), wait]);
+  return {
+    get: (key) => (fresh(key) ?? start(key)).value,
+    peek: (key) => (fresh(key) ?? start(key)).settled,
   };
-  return { get, within };
 }

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

@@ -102,6 +102,7 @@ export interface Station {
   resolvesSenders?: boolean;
   profileFields?: ReadonlySet<ProfileField>;
   claimsName?: boolean;
+  readsProfiles?: boolean;
   attachmentMode: AttachmentMode;
   sendAttachments?(
     line: string,

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

@@ -11,7 +11,7 @@ import { buildWebhookNote } from './webhook-note.js';
 import { replyMeta } from './addressed.js';
 import {
   capSet,
-  profileMeta,
+  displayNameMeta,
   senderMeta,
   tsMeta,
   takeMediaCtx,
@@ -148,7 +148,7 @@ export class InboundRelay {
         message_id: e.messageId,
         line_name: e.lineName,
         from_name: e.fromName,
-        ...profileMeta(e),
+        ...displayNameMeta(e.fromDisplayName),
       },
     });
   }
@@ -206,8 +206,6 @@ export class InboundRelay {
       lineName: str(ev.lineName),
       fromName: str(ev.fromName),
       fromDisplayName: str(ev.fromDisplayName),
-      fromAvatar: str(ev.fromAvatar),
-      fromAbout: str(ev.fromAbout),
       attachments: atts.map((a) => ({ kind: a.kind, name: a.name })),
       saved: new Set<number>(),
       timer: setTimeout(() => {
@@ -248,7 +246,7 @@ export class InboundRelay {
         message_id: str(ev.messageId),
         line_name: str(ev.lineName),
         from_name: str(ev.fromName),
-        ...profileMeta(ev),
+        ...displayNameMeta(ev.fromDisplayName),
         reaction: emoji,
         target_id: target,
       },
@@ -332,7 +330,7 @@ export class InboundRelay {
         message_id: str(ev.messageId),
         line_name: str(ev.lineName),
         from_name: str(ev.fromName),
-        ...profileMeta(ev),
+        ...displayNameMeta(ev.fromDisplayName),
         ...replyMeta(ev, this.sentIds),
       },
     });

package/runtime/node_modules/@metro-labs/daemon/src/channels/pending.ts

@@ -15,8 +15,6 @@ export interface PendingMsg {
   lineName: string;
   fromName: string;
   fromDisplayName: string;
-  fromAvatar: string;
-  fromAbout: string;
   attachments: PendingAtt[];
   saved: Set<number>;
   timer: ReturnType<typeof setTimeout>;
@@ -32,8 +30,6 @@ export interface MediaCtx {
   lineName?: string;
   fromName?: string;
   fromDisplayName?: string;
-  fromAvatar?: string;
-  fromAbout?: string;
 }
 
 export function capSet(set: Set<string>, max: number): void {
@@ -49,23 +45,17 @@ export const tsMeta = (v: unknown): Record<string, string> => {
   return ts ? { ts } : {};
 };
 
-const optional = (key: string, v: unknown): Record<string, string> => {
-  const text = str(v);
-  return text ? { [key]: text } : {};
+export const displayNameMeta = (v: unknown): Record<string, string> => {
+  const name = str(v);
+  return name ? { from_display_name: name } : {};
 };
 
-export const profileMeta = (v: { fromDisplayName?: unknown; fromAvatar?: unknown; fromAbout?: unknown }): Record<string, string> => ({
-  ...optional('from_display_name', v.fromDisplayName),
-  ...optional('from_avatar', v.fromAvatar),
-  ...optional('from_about', v.fromAbout),
-});
-
 export const senderMeta = (c: MediaCtx): Record<string, string> => ({
   ...tsMeta(c.ts),
   ...(c.messageId ? { message_id: c.messageId } : {}),
   ...(c.lineName ? { line_name: c.lineName } : {}),
   ...(c.fromName ? { from_name: c.fromName } : {}),
-  ...profileMeta(c),
+  ...displayNameMeta(c.fromDisplayName),
 });
 
 export function takeMediaCtx(buf: PendingMsg): MediaCtx {
@@ -79,8 +69,6 @@ export function takeMediaCtx(buf: PendingMsg): MediaCtx {
     lineName: buf.lineName,
     fromName: buf.fromName,
     fromDisplayName: buf.fromDisplayName,
-    fromAvatar: buf.fromAvatar,
-    fromAbout: buf.fromAbout,
   };
   buf.text = '';
   return ctx;

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

@@ -17,5 +17,5 @@ export const MCP_INSTRUCTIONS =
   'carries addressed="direct" (a private chat), "mention" (you were named) or "reply" (it ' +
   'answers one of your own messages); one without `addressed` merely happened in a room you ' +
   'watch, so treat it as context and do not answer unless the person plainly wants you. The ' +
-  'sender rides in the same meta: `from_name` (their handle or name), `from_display_name`, and, ' +
-  'when the station knows them, `from_avatar` (a picture url) and `from_about` (their bio).';
+  'meta names the sender (`from_name`, `from_display_name`) when the station knows them; ' +
+  '`get_profile` with the `from` tells you more about a person (name, bio, avatar, address).';

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

@@ -0,0 +1,58 @@
+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 = {
+  name: 'get_profile',
+  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 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 < 0 || 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: at === 0 ? 'default' : 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/tool-dispatch.ts

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { Line } from '@metro-labs/core/lines';
 import type { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import {
   ListToolsRequestSchema,
@@ -22,6 +23,7 @@ import {
 } from './group-tools.js';
 import { dispatchCreateUpload } from './upload-tool.js';
 import { dispatchSetProfile, profileCapabilities, SET_PROFILE_TOOL } from './profile-tool.js';
+import { dispatchGetProfile, GET_PROFILE_TOOL, profileScopeLine } from './profile-lookup.js';
 import { callTargetDenied, lineTargetDenied } from '../agents/scope.js';
 import { SOURCE_KEYS } from '../stations/attach-resolve.js';
 import { decodedLengthOf } from '../stations/attach-inline.js';
@@ -51,6 +53,7 @@ const CORE_DISPATCH: Record<
   export_invite: dispatchInviteLink,
   create_upload: dispatchCreateUpload,
   set_profile: dispatchSetProfile,
+  get_profile: dispatchGetProfile,
 };
 
 const toolList = (): { tools: unknown[] } => ({
@@ -65,6 +68,7 @@ const toolList = (): { tools: unknown[] } => ({
     ),
     LIST_ACCOUNTS_TOOL,
     SET_PROFILE_TOOL,
+    GET_PROFILE_TOOL,
   ],
 });
 
@@ -106,6 +110,10 @@ export function scopeDenied(
   args: Record<string, unknown>,
 ): boolean {
   const allowed = allowedAgents(identity);
+  if (name === 'get_profile') {
+    const line = profileScopeLine(args);
+    return line === undefined || callTargetDenied(allowed, Line.station(line) ?? '', { line });
+  }
   const station = stationForTool(name, args);
   if (station !== undefined) return callTargetDenied(allowed, station, args);
   return lineTargetDenied(allowed, args);

package/runtime/node_modules/@metro-labs/daemon/src/routes/http.ts

@@ -166,8 +166,6 @@ export function trainEventToMetroEvent(
     from: (env.from ?? `metro://${station}`) as MetroEvent['from'],
     fromName: env.from_name,
     fromDisplayName: env.from_display_name,
-    fromAvatar: env.from_avatar,
-    fromAbout: env.from_about,
     to: (env.to ?? (isPrivate ? userSelf() : line)) as MetroEvent['to'],
     text,
     messageId: env.message_id,

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

@@ -27,7 +27,7 @@ import {
 } from '@metro-labs/core/stations/station-runtime';
 import { joinVoice, leaveVoice, voiceDebug, voiceTranscribe } from './voice.js';
 import { speak } from './voice-speak.js';
-import { setProfile } from './profile.js';
+import { readProfile, setProfile } from './profile.js';
 import { discordMembers } from './members.js';
 import {
   groupAddHandler,
@@ -377,6 +377,7 @@ const HANDLERS: Record<string, StationHandler> = {
   listMembers,
   set_presence: presence,
   set_profile: setProfile,
+  profile: readProfile,
   joinVoice,
   leaveVoice,
   speak,

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

@@ -77,7 +77,6 @@ function addressing(accountId: string, m: Message): { mentions_self: boolean; re
 const senderOf = (m: Message): Record<string, string | undefined> => ({
   from_name: m.author.username,
   from_display_name: m.member?.displayName ?? m.author.globalName ?? undefined,
-  from_avatar: (m.member ?? m.author).displayAvatarURL({ size: 256 }),
 });
 
 export function messageEnvelope(
@@ -149,7 +148,6 @@ export function reactionEnvelope(
     from: `metro://discord-bot/${accountId}/user/${u.id}`,
     from_name: u.username,
     from_display_name: u.globalName ?? undefined,
-    from_avatar: u.displayAvatarURL({ size: 256 }),
     message_id: r.message.id,
     emoji: r.emoji.name ?? r.emoji.id ?? '?',
     is_private: r.message.guildId == null,

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

@@ -8,6 +8,7 @@ import {
   type ProfileApplied,
   type ProfileChange,
 } from '@metro-labs/core/stations/profile';
+import type { SenderProfile } from '@metro-labs/core/stations/sender-profile';
 import { accountFor, accounts } from './accounts.js';
 import { respond } from './wire.js';
 
@@ -46,3 +47,22 @@ export async function setProfile(
   const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
   respond(id, { result });
 }
+
+export async function readProfile(id: string, args: Record<string, unknown>): Promise<void> {
+  const accountId = accountFor({ account: args.account as string | undefined });
+  const acct = accounts.get(accountId);
+  if (!acct) {
+    respond(id, { error: `unknown account '${accountId}'` });
+    return;
+  }
+  const user = typeof args.user === 'string' ? args.user.trim() : '';
+  if (!/^\d+$/.test(user)) throw new TrainError('discord_user_required', 'profile needs the Discord id of the person', { retryable: false });
+  const found = await acct.client.users.fetch(user);
+  const result: SenderProfile = {
+    id: user,
+    name: found.username,
+    ...(found.globalName === null ? {} : { display_name: found.globalName }),
+    avatar: found.displayAvatarURL({ size: 256 }),
+  };
+  respond(id, { result });
+}

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

@@ -17,5 +17,6 @@ export const discordBotStation: Station = {
   groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
   attachmentMode: 'canonical',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   tools: [],
 };

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

@@ -14,7 +14,7 @@ import {
   type CanonicalAttachment,
 } from './media-actions.js';
 import { clampLimit, shapeHistory } from './history.js';
-import { makeSetProfile } from './profile.js';
+import { makeReadProfile, makeSetProfile } from './profile.js';
 import { fetchMembers, isRestricted, restrictedMemberList } from './members.js';
 import {
   groupAddMembers,
@@ -250,6 +250,7 @@ export function makeHandleCall(
       groupRemoveMembers: makeGroupRemove(clientFor),
       groupInviteLink: makeGroupInvite(clientFor),
       set_profile: makeSetProfile(clientFor),
+      profile: makeReadProfile(clientFor),
     },
     normalize: normalizeTelegramUser,
   });

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

@@ -1,6 +1,5 @@
 import type { Message } from '@mtcute/bun';
 import { errMsg, log } from '@metro-labs/core/log';
-import { makeProfileCache, nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
 import { emit } from './wire.js';
 import { envelope, isOwnEcho, attachmentSavedEnvelope } from './format.js';
 import { downloadMedia, isDownloadable } from './attachments.js';
@@ -32,42 +31,13 @@ async function saveMediaAndEmit(
   }
 }
 
-const senders = new Map<string, ReturnType<typeof makeProfileCache<SenderProfile>>>();
-
-function sendersOf(client: UserClient): ReturnType<typeof makeProfileCache<SenderProfile>> {
-  const held = senders.get(client.account.id);
-  if (held !== undefined) return held;
-  const made = makeProfileCache<SenderProfile>(
-    async (userId) => {
-      const full = await client.tg.getFullUser(Number(userId));
-      const about = nonEmpty(full.bio);
-      return about === undefined ? null : { from_about: about };
-    },
-    {
-      onError: (userId, err) => {
-        process.stderr.write(`telegram[${client.account.id}] could not read the profile of ${userId}: ${errMsg(err)}\n`);
-      },
-    },
-  );
-  senders.set(client.account.id, made);
-  return made;
-}
-
 function emitMessage(client: UserClient, m: Message): void {
   log.debug(
     { train: 'telegram', account: client.account.id, messageId: m.id },
     'inbound message received',
   );
   if (isOwnEcho(m)) return;
-  const lookup = m.sender.type === 'user' && !m.sender.isBot ? sendersOf(client).within(String(m.sender.id)) : Promise.resolve(null);
-  lookup
-    .then((profile) => {
-      deliver(client, m, { ...envelope(client.account.id, m), ...profile });
-    })
-    .catch((err: unknown) => process.stderr.write(`telegram[${client.account.id}] inbound not emitted: ${errMsg(err)}\n`));
-}
-
-function deliver(client: UserClient, m: Message, env: Record<string, unknown>): void {
+  const env = envelope(client.account.id, m);
   emit(env);
   if (m.media !== null)
     saveMediaAndEmit(client, m, env).catch((err: unknown) => {

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

@@ -8,6 +8,8 @@ import {
 } 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';
 
@@ -34,3 +36,35 @@ export function makeSetProfile(clientFor: (accountId: string) => UserClient): St
     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/station.ts

@@ -22,5 +22,6 @@ export const telegramStation: Station = {
   ]),
   attachmentMode: 'canonical',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   tools: [],
 };

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

@@ -23,7 +23,7 @@ import {
   sendLocation,
   sendMedia,
 } from './media-actions.js';
-import { setProfile } from './profile.js';
+import { readProfile, setProfile } from './profile.js';
 
 
 
@@ -273,6 +273,7 @@ const HANDLERS: Record<string, StationHandler> = {
   delete: remove,
   listMembers,
   set_profile: setProfile,
+  profile: readProfile,
   send_photo: (id, args) =>
     media(id, 'sendPhoto', 'photo', ((args.caption as string) ?? '') + ' [image]', args),
   send_document: (id, args) =>

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

@@ -1,5 +1,4 @@
 import { errMsg } from '@metro-labs/core/log';
-import { makeProfileCache, nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
 import { accounts, loadAccounts, tg, type Account } from './accounts.js';
 import { emit } from './wire.js';
 import {
@@ -24,29 +23,12 @@ interface Update {
   message_reaction_count?: TgReactionCount;
 }
 
-const senders = makeProfileCache<SenderProfile>(
-  async (key) => {
-    const [id, userId] = key.split(':', 2) as [string, string];
-    const chat = await tg<{ bio?: unknown }>(id, 'getChat', { chat_id: Number(userId) }, 5000);
-    const about = nonEmpty(chat.bio);
-    return about === undefined ? null : { from_about: about };
-  },
-  { onError: (key, err) => process.stderr.write(`telegram-bot: could not read the profile of ${key}: ${errMsg(err)}\n`) },
-);
-
-function handleMessage(id: string, m: TgMsg): void {
-  const lookup = m.from === undefined || m.chat.type !== 'private' ? Promise.resolve(null) : senders.within(`${id}:${String(m.from.id)}`);
-  lookup
-    .then((profile) => {
-      const env: Record<string, unknown> = { ...envelope(id, m), ...profile };
-      emitInbound(emit, id, env);
-      saveMediaAndEmit(emit, id, m, env.id as string);
-    })
-    .catch((err: unknown) => process.stderr.write(`telegram-bot[${id}] inbound not emitted: ${errMsg(err)}\n`));
-}
-
 function handleUpdate(id: string, u: Update): void {
-  if (u.message && !u.message.from?.is_bot) handleMessage(id, u.message);
+  if (u.message && !u.message.from?.is_bot) {
+    const env = envelope(id, u.message);
+    emitInbound(emit, id, env);
+    saveMediaAndEmit(emit, id, u.message, env.id as string);
+  }
   if (u.message_reaction) {
     const env = reactionEnvelope(id, u.message_reaction);
     if (env) emitInbound(emit, id, env);

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

@@ -7,6 +7,8 @@ import {
   type ProfileAvatar,
   type ProfileChange,
 } from '@metro-labs/core/stations/profile';
+import { makeProfileCache, nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import { TrainError } from '@metro-labs/core/train-error';
 import { accountFor, tg, tgForm } from './accounts.js';
 import { respond } from './wire.js';
 
@@ -31,3 +33,33 @@ export async function setProfile(id: string, args: Record<string, unknown>): Pro
   const result: ProfileApplied = { account: accountId, applied: fieldsOf(change) };
   respond(id, { result });
 }
+
+interface TgChat {
+  username?: unknown;
+  first_name?: unknown;
+  last_name?: unknown;
+  bio?: unknown;
+}
+
+const senders = makeProfileCache<SenderProfile>(
+  async (key) => {
+    const [accountId, user] = key.split(':', 2) as [string, string];
+    const chat = await tg<TgChat>(accountId, 'getChat', { chat_id: Number(user) }, 10_000);
+    const handle = nonEmpty(chat.username);
+    const display = nonEmpty([chat.first_name, chat.last_name].filter((part) => typeof part === 'string').join(' '));
+    return {
+      id: user,
+      ...(handle === undefined ? {} : { name: `@${handle}` }),
+      ...(display === undefined ? {} : { display_name: display }),
+      ...(nonEmpty(chat.bio) === undefined ? {} : { about: nonEmpty(chat.bio) }),
+    };
+  },
+  { onError: (key, err) => process.stderr.write(`telegram-bot: could not read the profile of ${key}: ${err instanceof Error ? err.message : String(err)}\n`) },
+);
+
+export async function readProfile(id: string, args: Record<string, unknown>): Promise<void> {
+  const accountId = accountFor({ account: args.account as string | undefined });
+  const user = typeof args.user === 'string' ? args.user.trim() : '';
+  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 senders.get(`${accountId}:${user}`)) ?? { id: user } });
+}

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

@@ -15,5 +15,6 @@ export const telegramBotStation: Station = {
   ]),
   attachmentMode: 'canonical',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   tools: [],
 };

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

@@ -185,6 +185,16 @@ function makeSetProfile(clientFor: ClientFor): StationHandler {
   };
 }
 
+function makeProfile(clientFor: ClientFor): StationHandler {
+  return async (id, args) => {
+    const accountId = accountFor({ account: str(args.account) });
+    const user = str(args.user) ?? '';
+    if (user === '') throw new TrainError('whatsapp_user_required', 'profile needs the jid of the person', { retryable: false });
+    const profile = await guard(() => clientFor(accountId).senderProfile(user));
+    respond(id, { result: profile ?? { id: user } });
+  };
+}
+
 export function makeHandleCall(
   clientFor: ClientFor,
 ): (msg: CallMsg) => Promise<void> {
@@ -197,6 +207,7 @@ export function makeHandleCall(
       delete: makeDelete(clientFor),
       resolve_sender: makeResolveSender(clientFor),
       set_profile: makeSetProfile(clientFor),
+      profile: makeProfile(clientFor),
     },
     normalize: normalizeWhatsApp,
   });

package/runtime/node_modules/@metro-labs/whatsapp/src/client.ts

@@ -14,7 +14,7 @@ import type { WhatsAppAccount } from './types.js';
 import type { InboundMessage, ReactionInput } from './format.js';
 import type { SenderFound } from './resolve.js';
 import type { ProfileChange } from '@metro-labs/core/stations/profile';
-import { nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
+import { makeProfileCache, nonEmpty, type SenderProfile } from '@metro-labs/core/stations/sender-profile';
 import { toInbound, toReaction, type ReactionEvent, type SelfRef } from './parse.js';
 import { baileysLogger } from './logger.js';
 import { useAccountAuthState } from './auth-state.js';
@@ -280,6 +280,16 @@ export function createClient(account: WhatsAppAccount): WAClient {
     acks: makeAckWatch(),
   };
   resetGate(st);
+  const senders = makeProfileCache<SenderProfile>(
+    async (jid) => {
+      const sock = await ready(st);
+      const [statuses, avatar] = await Promise.all([sock.fetchStatus(jid).catch(() => undefined), sock.profilePictureUrl(jid, 'image').catch(() => undefined)]);
+      const about = nonEmpty((statuses?.[0]?.status as { status?: unknown } | undefined)?.status);
+      const picture = nonEmpty(avatar);
+      return { id: jid, ...(about === undefined ? {} : { about }), ...(picture === undefined ? {} : { avatar: picture }) };
+    },
+    { onError: (jid, err) => process.stderr.write(`whatsapp[${st.account.id}] could not read the profile of ${jid}: ${errMsg(err)}\n`) },
+  );
   return {
     account,
     self() {
@@ -349,14 +359,7 @@ export function createClient(account: WhatsAppAccount): WAClient {
         await sock.updateProfilePicture(me, { url: change.avatar.path });
       }
     },
-    async senderProfile(jid) {
-      const sock = await ready(st);
-      const [statuses, avatar] = await Promise.all([sock.fetchStatus(jid).catch(() => undefined), sock.profilePictureUrl(jid, 'image').catch(() => undefined)]);
-      const about = nonEmpty((statuses?.[0]?.status as { status?: unknown } | undefined)?.status);
-      const picture = nonEmpty(avatar);
-      if (about === undefined && picture === undefined) return null;
-      return { ...(about === undefined ? {} : { from_about: about }), ...(picture === undefined ? {} : { from_avatar: picture }) };
-    },
+    senderProfile: (jid) => senders.get(jid),
     async disconnect() {
       st.closed = true;
       try {

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

@@ -1,6 +1,5 @@
 import type { WAMessage } from 'baileys';
 import { errMsg } from '@metro-labs/core/log';
-import { makeProfileCache } from '@metro-labs/core/stations/sender-profile';
 import { emit } from './wire.js';
 import {
   attachmentFailedEnvelope,
@@ -40,31 +39,19 @@ async function saveMedia(
 }
 
 export async function startInbound(client: WAClient): Promise<void> {
-  const senders = makeProfileCache((jid) => client.senderProfile(jid), {
-    onError: (jid, err) => process.stderr.write(`whatsapp[${client.account.id}] could not read the profile of ${jid}: ${errMsg(err)}\n`),
-  });
   await client.start({
     onMessage: (m, raw) => {
-      senders
-        .within(m.senderJid)
-        .then((profile) => {
-          const env = { ...envelope(m), ...profile };
-          emit(env);
-          deliverMedia(client, m, raw, env);
-        })
-        .catch((err: unknown) => {
-          process.stderr.write(`whatsapp[${m.accountId}] inbound not emitted: ${errMsg(err)}\n`);
-        });
+      const env = envelope(m);
+      emit(env);
+      if (!m.media) return;
+      saveMedia(client, m, raw, String(env.id)).catch((err: unknown) => {
+        process.stderr.write(
+          `whatsapp[${m.accountId}] media event not emitted: ${errMsg(err)}\n`,
+        );
+      });
     },
     onReaction: (r) => {
       emit(reactionEnvelope(r));
     },
   });
 }
-
-function deliverMedia(client: WAClient, m: InboundMessage, raw: WAMessage, env: Record<string, unknown>): void {
-  if (!m.media) return;
-  saveMedia(client, m, raw, String(env.id)).catch((err: unknown) => {
-    process.stderr.write(`whatsapp[${m.accountId}] media event not emitted: ${errMsg(err)}\n`);
-  });
-}

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

@@ -15,6 +15,7 @@ export const whatsappStation: Station = {
   ]),
   attachmentMode: 'canonical',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   resolvesSenders: true,
   tools: [],
 };

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

@@ -22,6 +22,7 @@ import { convHandlers } from './actions-conv.js';
 import { normalizeXmtp } from '@metro-labs/core/stations/messaging-normalize';
 import { TrainError } from '@metro-labs/core/train-error';
 import { claimNameAction, nameAction, setProfile } from './profile.js';
+import { profileAction } from './sender.js';
 import { makeStation, type CallMsg } from '@metro-labs/core/stations/station-runtime';
 
 type Args = Record<string, unknown>;
@@ -358,6 +359,7 @@ const handlers: Record<string, (id: string, args: Args) => Promise<void>> = {
   set_profile: setProfile,
   claim_name: claimNameAction,
   name: nameAction,
+  profile: profileAction,
   send,
   ask,
   sendPoll: ask,

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

@@ -8,7 +8,7 @@ import {
 } from './accounts.js';
 import { emitInbound, envelope } from './emit.js';
 import { groupNameFor } from './conv-helpers.js';
-import { senderFieldsWithin } from './sender.js';
+import { senderFieldsNow } from './sender.js';
 import { handleControlDm, pushInbound } from './push.js';
 import { readCalls } from '@metro-labs/core/trains/protocol';
 import { handleCall } from './actions.js';
@@ -66,7 +66,7 @@ async function handleStreamMessage(
   );
   if (!conv) return;
   const env = envelope(id, msg, conv);
-  Object.assign(env, await senderFieldsWithin(acct, msg.senderInboxId));
+  Object.assign(env, senderFieldsNow(acct, msg.senderInboxId));
   const name = await groupNameFor(msg.conversationId, conv);
   if (name) {
     env.line_name = name;

package/runtime/node_modules/@metro-labs/xmtp/src/sender.ts

@@ -1,11 +1,13 @@
-import { namehash, type Hex } from 'viem';
+import { createPublicClient, http, namehash, type Hex } from 'viem';
+import { base } from 'viem/chains';
 import { normalize } from 'viem/ens';
-import { makeProfileCache, type SenderProfile as SenderFields } from '@metro-labs/core/stations/sender-profile';
-import { accounts, type Account } from './accounts.js';
+import { makeProfileCache, type SenderProfile as Profile } from '@metro-labs/core/stations/sender-profile';
+import { respond } from './wire.js';
+import { TrainError } from '@metro-labs/core/train-error';
+import { accountForCall, accounts, type Account } from './accounts.js';
 import { resolveAddresses } from './conv-helpers.js';
 import { nameOf } from './names.js';
 import { BASENAME_L2_RESOLVER, BASENAME_REGISTRY, NAME_ABI, REGISTRY_ABI, reverseNodeOf } from './profile.js';
-import { makePublicClient, type BaseClient } from './smart.js';
 
 export interface SenderProfile {
   address: string;
@@ -15,8 +17,7 @@ export interface SenderProfile {
   avatar: string | null;
 }
 
-const BASE_RPC = 'https://mainnet.base.org';
-const LOOKUP_MS = 4000;
+const BASE_RPC = 'https://rpc.brovider.xyz/8453';
 const ZERO = '0x0000000000000000000000000000000000000000';
 const AVATAR_RE = /^(https?:\/\/|ipfs:\/\/|data:image\/)/i;
 
@@ -33,28 +34,32 @@ const TEXT_ABI = [
 
 export const baseRpc = (): string => process.env.METRO_BASE_RPC ?? BASE_RPC;
 
-let reader: BaseClient | null = null;
-const readerFor = (): BaseClient => (reader ??= makePublicClient(baseRpc()));
+const makeReader = (rpc: string) => createPublicClient({ chain: base, transport: http(rpc), batch: { multicall: true } });
+
+export type Reader = ReturnType<typeof makeReader>;
+
+let reader: Reader | null = null;
+const readerFor = (): Reader => (reader ??= makeReader(baseRpc()));
 
 const trimmed = (v: string): string | null => (v.trim() === '' ? null : v.trim());
 
-async function resolverOf(client: BaseClient, node: Hex): Promise<Hex> {
-  const found: Hex = await client.readContract({ address: BASENAME_REGISTRY, abi: REGISTRY_ABI, functionName: 'resolver', args: [node] }).catch(() => ZERO);
+async function resolverOf(client: Reader, node: Hex): Promise<Hex> {
+  const found: Hex = await client.readContract({ address: BASENAME_REGISTRY, abi: REGISTRY_ABI, functionName: 'resolver', args: [node] });
   return found === ZERO ? BASENAME_L2_RESOLVER : found;
 }
 
-async function primaryName(client: BaseClient, address: string): Promise<string | null> {
+async function primaryName(client: Reader, address: string): Promise<string | null> {
   const node = reverseNodeOf(address);
-  const found = await client.readContract({ address: await resolverOf(client, node), abi: NAME_ABI, functionName: 'name', args: [node] }).catch(() => '');
+  const found = await client.readContract({ address: await resolverOf(client, node), abi: NAME_ABI, functionName: 'name', args: [node] });
   return found === '' ? null : found;
 }
 
-async function recordsOf(client: BaseClient, name: string, address: string): Promise<SenderProfile | null> {
+async function recordsOf(client: Reader, name: string, address: string): Promise<SenderProfile | null> {
   const node = namehash(normalize(name));
   const resolver = { address: await resolverOf(client, node), abi: TEXT_ABI } as const;
-  const text = (key: string): Promise<string> => client.readContract({ ...resolver, functionName: 'text', args: [node, key] }).catch(() => '');
+  const text = (key: string): Promise<string> => client.readContract({ ...resolver, functionName: 'text', args: [node, key] });
   const [forward, displayName, about, avatar] = await Promise.all([
-    client.readContract({ ...resolver, functionName: 'addr', args: [node] }).catch(() => ZERO),
+    client.readContract({ ...resolver, functionName: 'addr', args: [node] }),
     text('name'),
     text('description'),
     text('avatar'),
@@ -63,33 +68,45 @@ async function recordsOf(client: BaseClient, name: string, address: string): Pro
   return { address, name, displayName: trimmed(displayName), about: trimmed(about), avatar: AVATAR_RE.test(avatar.trim()) ? avatar.trim() : null };
 }
 
-export async function profileOf(address: string, client: BaseClient = readerFor(), fetchImpl: typeof fetch = fetch): Promise<SenderProfile> {
+export async function profileOf(address: string, client: Reader = readerFor(), fetchImpl: typeof fetch = fetch): Promise<SenderProfile> {
   const bare: SenderProfile = { address, name: null, displayName: null, about: null, avatar: null };
-  const name = (await primaryName(client, address)) ?? (await nameOf(address, fetchImpl).catch(() => null));
+  const name = (await primaryName(client, address)) ?? (await nameOf(address, fetchImpl));
   if (name === null) return bare;
-  return (await recordsOf(client, name, address).catch(() => null)) ?? bare;
+  return (await recordsOf(client, name, address)) ?? bare;
 }
 
+const key = (acct: Account, inboxId: string): string => `${acct.cfg.id}:${inboxId}`;
+
 const senders = makeProfileCache<SenderProfile>(
-  async (key) => {
-    const [accountId, inboxId] = key.split(':', 2) as [string, string];
+  async (k) => {
+    const [accountId, inboxId] = k.split(':', 2) as [string, string];
     const acct = accounts.get(accountId);
     if (acct === undefined) return null;
     const address = (await resolveAddresses(acct, [inboxId]))[inboxId];
     return address === undefined ? null : profileOf(address);
   },
-  { timeoutMs: LOOKUP_MS, onError: (key, err) => process.stderr.write(`xmtp: could not resolve the sender ${key}: ${err instanceof Error ? err.message : String(err)}\n`) },
+  { onError: (k, err) => process.stderr.write(`xmtp: could not resolve the sender ${k}: ${err instanceof Error ? err.message : String(err)}\n`) },
 );
 
-export const senderFields = (p: SenderProfile | null): SenderFields | null =>
-  p === null
-    ? null
-    : {
-        from_name: p.name ?? p.address,
-        ...(p.displayName === null ? {} : { from_display_name: p.displayName }),
-        ...(p.avatar === null ? {} : { from_avatar: p.avatar }),
-        ...(p.about === null ? {} : { from_about: p.about }),
-      };
-
-export const senderFieldsWithin = (acct: Account, inboxId: string): Promise<SenderFields | null> =>
-  senders.within(`${acct.cfg.id}:${inboxId}`).then(senderFields);
+export const senderFields = (p: SenderProfile | null): Record<string, string> =>
+  p === null ? {} : { from_name: p.name ?? p.address, ...(p.displayName === null ? {} : { from_display_name: p.displayName }) };
+
+export const senderFieldsNow = (acct: Account, inboxId: string): Record<string, string> => senderFields(senders.peek(key(acct, inboxId)));
+
+export const senderProfile = (acct: Account, inboxId: string): Promise<SenderProfile | null> => senders.get(key(acct, inboxId));
+
+export const profileView = (inboxId: string, p: SenderProfile | null): Profile => ({
+  id: inboxId,
+  ...(p === null ? {} : { address: p.address }),
+  ...(p?.name == null ? {} : { name: p.name }),
+  ...(p?.displayName == null ? {} : { display_name: p.displayName }),
+  ...(p?.about == null ? {} : { about: p.about }),
+  ...(p?.avatar == null ? {} : { avatar: p.avatar }),
+});
+
+export async function profileAction(id: string, args: Record<string, unknown>): Promise<void> {
+  const user = typeof args.user === 'string' ? args.user.trim() : '';
+  if (user === '') throw new TrainError('xmtp_user_required', 'profile needs the inbox id of the person', { retryable: false });
+  const acct = accountForCall({ account: typeof args.account === 'string' ? args.account : undefined });
+  respond(id, { result: profileView(user, await senderProfile(acct, user)) });
+}

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

@@ -10,6 +10,7 @@ export const xmtpStation: Station = {
   groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
   attachmentMode: 'native',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),
+  readsProfiles: true,
   claimsName: true,
   sendAttachments: xmtpSendAttachments,
   tools: XMTP_TOOLS,

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.162"
+  "version": "0.1.0-beta.164"
 }