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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.160",
+  "version": "0.1.0-beta.162",
   "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.160",
+  "version": "0.1.0-beta.162",
   "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/package.json

@@ -24,7 +24,8 @@
     "./stations/account-store": "./src/stations/account-store.ts",
     "./stations/attachments": "./src/stations/attachments.ts",
     "./stations/messaging-normalize": "./src/stations/messaging-normalize.ts",
-    "./stations/profile": "./src/stations/profile.ts"
+    "./stations/profile": "./src/stations/profile.ts",
+    "./stations/sender-profile": "./src/stations/sender-profile.ts"
   },
   "scripts": {
     "build": "tsc",

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

@@ -20,6 +20,8 @@ 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,6 +33,8 @@ 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

@@ -0,0 +1,60 @@
+export interface SenderProfile {
+  from_name?: string;
+  from_display_name?: string;
+  from_avatar?: string;
+  from_about?: 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>;
+}
+
+const TTL_MS = 10 * 60_000;
+const MAX = 2000;
+const TIMEOUT_MS = 3000;
+
+interface Held<T> {
+  at: number;
+  value: Promise<T | null>;
+}
+
+export const nonEmpty = (v: unknown): string | undefined => (typeof v === 'string' && v.trim() !== '' ? v.trim() : undefined);
+
+export function makeProfileCache<T>(lookup: (key: string) => Promise<T | null>, opts: ProfileCacheOptions): ProfileCache<T> {
+  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 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 });
+    while (cache.size > max) {
+      const oldest = cache.keys().next();
+      if (oldest.done) break;
+      cache.delete(oldest.value);
+    }
+    return value;
+  };
+  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, within };
+}

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,
-  displayNameMeta,
+  profileMeta,
   senderMeta,
   tsMeta,
   takeMediaCtx,
@@ -148,7 +148,7 @@ export class InboundRelay {
         message_id: e.messageId,
         line_name: e.lineName,
         from_name: e.fromName,
-        ...displayNameMeta(e.fromDisplayName),
+        ...profileMeta(e),
       },
     });
   }
@@ -206,6 +206,8 @@ 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(() => {
@@ -246,7 +248,7 @@ export class InboundRelay {
         message_id: str(ev.messageId),
         line_name: str(ev.lineName),
         from_name: str(ev.fromName),
-        ...displayNameMeta(ev.fromDisplayName),
+        ...profileMeta(ev),
         reaction: emoji,
         target_id: target,
       },
@@ -330,7 +332,7 @@ export class InboundRelay {
         message_id: str(ev.messageId),
         line_name: str(ev.lineName),
         from_name: str(ev.fromName),
-        ...displayNameMeta(ev.fromDisplayName),
+        ...profileMeta(ev),
         ...replyMeta(ev, this.sentIds),
       },
     });

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

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

@@ -1,6 +1,6 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { isRecord } from '@metro-labs/core/is-record';
-import { errMsg } from '@metro-labs/core/log';
+import { errMsg, log } from '@metro-labs/core/log';
 import { refreshTokens, tokensStale, type GeminiTokens } from './gemini-auth.js';
 import { API, clientHeaders, generateBases, machineSessionId, type Bases } from './gemini-client.js';
 import { GeminiStreamTranslator } from './gemini-stream.js';
@@ -109,12 +109,37 @@ async function send(call: Call, tokens: GeminiTokens, stream: boolean): Promise<
       if (base === bases.at(-1) || call.watch.signal.aborted) throw err;
       continue;
     }
-    if (last.status < 500) return last;
+    if (last.status < 500 && last.status !== 429) return last;
   }
   if (last === null) throw new GatewayError(502, 'api_error', 'no Code Assist endpoint to call');
   return last;
 }
 
+const REFUSAL_LOG_MAX = 2000;
+
+const detailText = (detail: Record<string, unknown>): string[] => {
+  const out: string[] = [];
+  if (typeof detail.reason === 'string') out.push(detail.reason);
+  if (isRecord(detail.metadata)) out.push(...Object.entries(detail.metadata).map(([k, v]) => `${k}=${String(v)}`));
+  if (typeof detail.retryDelay === 'string') out.push(`retry after ${detail.retryDelay}`);
+  if (Array.isArray(detail.violations))
+    out.push(...detail.violations.filter(isRecord).map((v) => [v.subject, v.description].filter((x) => typeof x === 'string').join(': ')));
+  return out.filter((x) => x !== '');
+};
+
+export function refusalMessage(text: string, status: number): string {
+  const message = upstreamMessage(text, `Gemini answered ${String(status)}`);
+  let details: unknown = null;
+  try {
+    const parsed: unknown = JSON.parse(text);
+    details = isRecord(parsed) && isRecord(parsed.error) ? parsed.error.details : null;
+  } catch {
+    return message;
+  }
+  const notes = Array.isArray(details) ? details.filter(isRecord).flatMap(detailText) : [];
+  return notes.length === 0 ? message : `${message} (${notes.join('; ')})`;
+}
+
 async function reach(call: Call, cfg: ModelConfig, state: GeminiState, stream: boolean): Promise<Response> {
   let tokens = await currentGeminiTokens(cfg, call.deps, state);
   let upstream = await send(call, tokens, stream);
@@ -244,7 +269,8 @@ export async function geminiMessages(
   const upstream = await reach(call, cfg, state, stream);
   if (!upstream.ok) {
     const text = await upstream.text();
-    sendError(res, providerStatus(upstream.status), errorKind(upstream.status), upstreamMessage(text, `Gemini answered ${String(upstream.status)}`));
+    log.warn({ provider: 'gemini', model, status: upstream.status, body: text.slice(0, REFUSAL_LOG_MAX) }, 'gateway: the provider refused the request');
+    sendError(res, providerStatus(upstream.status), errorKind(upstream.status), refusalMessage(text, upstream.status));
     return;
   }
   if (stream) await relayStream(upstream, res, call);

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

@@ -0,0 +1,21 @@
+export const MCP_INSTRUCTIONS =
+  'Messages from Metro chat arrive as <channel source="metro" line="..." from="..." ' +
+  'station="..." message_id="...">. To respond, use the messaging tools, always passing the ' +
+  '`line` attribute verbatim (the station is derived from it): `send` (text and/or media via ' +
+  '`attachments`, optional `reply_to`), `reply` (quote a `message_id` with `text`), `react`/' +
+  '`unreact` (emoji on a `message_id`), `edit`/`delete` (a `message_id`), and `read` (recent ' +
+  "history). Station support varies - the tool returns the daemon's reason if a verb is " +
+  'unsupported on that line. An inbound attachment is surfaced as a note carrying the ' +
+  "sender's own text alongside a `Public URL` - fetch that url to read the file; the note's " +
+  '`local_path` resolves on the DAEMON host, not on yours, so the Read tool works on it only ' +
+  'for an agent running there. To send a file OUT, call `create_upload`, ' +
+  'run the one curl line it hands back (that step needs a shell; the bytes go from your disk ' +
+  'straight to metro and never through this conversation), then `send` with ' +
+  'attachments:[{upload:"<upload_id>"}]. Inline `data` is for tiny files only, `url` only for ' +
+  'an already-public file, and `path` is read on the DAEMON host, not yours. Tool-approval ' +
+  'prompts are relayed to the same chat - answer "yes <id>"/"no <id>". A message meant for you ' +
+  '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).';

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

@@ -8,7 +8,7 @@ import {
   senderMatchesAllowlist,
 } from '../agents/map.js';
 import { accountStationNames } from '../stations/registry.js';
-import { MCP_INSTRUCTIONS } from './tool-schemas.js';
+import { MCP_INSTRUCTIONS } from './instructions.js';
 import { ChannelOwner } from './channel-owner.js';
 import { BoundedEventStore } from './event-store.js';
 import { registerPermissionRelay } from './permission-relay.js';

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

@@ -378,23 +378,3 @@ export const LIST_ACCOUNTS_TOOL = {
     'verb need not be discovered by trial and error.',
   inputSchema: { type: 'object', properties: {} },
 };
-
-export const MCP_INSTRUCTIONS =
-  'Messages from Metro chat arrive as <channel source="metro" line="..." from="..." ' +
-  'station="..." message_id="...">. To respond, use the messaging tools, always passing the ' +
-  '`line` attribute verbatim (the station is derived from it): `send` (text and/or media via ' +
-  '`attachments`, optional `reply_to`), `reply` (quote a `message_id` with `text`), `react`/' +
-  '`unreact` (emoji on a `message_id`), `edit`/`delete` (a `message_id`), and `read` (recent ' +
-  "history). Station support varies - the tool returns the daemon's reason if a verb is " +
-  'unsupported on that line. An inbound attachment is surfaced as a note carrying the ' +
-  "sender's own text alongside a `Public URL` - fetch that url to read the file; the note's " +
-  '`local_path` resolves on the DAEMON host, not on yours, so the Read tool works on it only ' +
-  'for an agent running there. To send a file OUT, call `create_upload`, ' +
-  'run the one curl line it hands back (that step needs a shell; the bytes go from your disk ' +
-  'straight to metro and never through this conversation), then `send` with ' +
-  'attachments:[{upload:"<upload_id>"}]. Inline `data` is for tiny files only, `url` only for ' +
-  'an already-public file, and `path` is read on the DAEMON host, not yours. Tool-approval ' +
-  'prompts are relayed to the same chat - answer "yes <id>"/"no <id>". A message meant for you ' +
-  '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.';

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

@@ -166,6 +166,8 @@ 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/format.ts

@@ -74,6 +74,12 @@ 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(
   accountId: string,
   m: Message,
@@ -115,8 +121,7 @@ export function messageEnvelope(
     line,
     line_name: 'name' in m.channel ? m.channel.name : undefined,
     from: `metro://discord-bot/${accountId}/user/${m.author.id}`,
-    from_name: m.author.username,
-    from_display_name: m.author.globalName ?? undefined,
+    ...senderOf(m),
     message_id: m.id,
     text,
     is_private: m.guildId == null,
@@ -144,6 +149,7 @@ 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/telegram/src/format.ts

@@ -13,8 +13,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 {

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

@@ -1,5 +1,6 @@
 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';
@@ -31,13 +32,42 @@ 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 env = envelope(client.account.id, m);
+  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 {
   emit(env);
   if (m.media !== null)
     saveMediaAndEmit(client, m, env).catch((err: unknown) => {

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

@@ -2,7 +2,7 @@ import { errMsg } from '@metro-labs/core/log';
 import { accounts, lineOf } from './accounts.js';
 import { mintId, SELF_URI } from './wire.js';
 import { mediaRefOf, saveTelegramMedia } from './attachments.js';
-import type { TgMsg, TgReaction, TgReactionCount } from './types.js';
+import type { TgMsg, TgReaction, TgReactionCount, TgUser } from './types.js';
 
 export type { TgMsg, TgReaction, TgReactionCount };
 
@@ -72,6 +72,11 @@ function addressing(accountId: string, m: TgMsg): Record<string, unknown> {
   };
 }
 
+export const fullName = (u: TgUser | undefined): string | undefined => {
+  const name = [u?.first_name, u?.last_name].filter((part) => typeof part === 'string' && part !== '').join(' ');
+  return name === '' ? undefined : name;
+};
+
 export function envelope(accountId: string, m: TgMsg): Record<string, unknown> {
   const { line } = lineForMsg(accountId, m);
   return {
@@ -83,7 +88,7 @@ export function envelope(accountId: string, m: TgMsg): Record<string, unknown> {
     line_name: m.chat.title ?? m.chat.first_name ?? undefined,
     from: `metro://telegram-bot/${accountId}/user/${m.from?.id ?? 'unknown'}`,
     from_name: m.from?.username ? `@${m.from.username}` : m.from?.first_name,
-    from_display_name: m.from?.first_name,
+    from_display_name: fullName(m.from),
     message_id: String(m.message_id),
     text: projectText(m),
     payload: m,
@@ -113,7 +118,7 @@ export function reactionEnvelope(
     line: lineOf(accountId, r.chat.id),
     from: `metro://telegram-bot/${accountId}/user/${r.user?.id ?? 'unknown'}`,
     from_name: r.user?.username ? `@${r.user.username}` : r.user?.first_name,
-    from_display_name: r.user?.first_name,
+    from_display_name: fullName(r.user),
     message_id: String(r.message_id),
     emoji: added[0],
     event: { type: 'react', emoji: added[0], targetId: String(r.message_id) },

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

@@ -1,4 +1,5 @@
 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 {
@@ -23,12 +24,29 @@ 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) {
-    const env = envelope(id, u.message);
-    emitInbound(emit, id, env);
-    saveMediaAndEmit(emit, id, u.message, env.id as string);
-  }
+  if (u.message && !u.message.from?.is_bot) handleMessage(id, u.message);
   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/types.ts

@@ -5,6 +5,14 @@ export interface TgEntity {
   user?: { id: number };
 }
 
+export interface TgUser {
+  id: number;
+  username?: string;
+  first_name?: string;
+  last_name?: string;
+  is_bot?: boolean;
+}
+
 export interface TgMsg {
   entities?: TgEntity[];
   caption_entities?: TgEntity[];
@@ -12,12 +20,7 @@ export interface TgMsg {
   message_id: number;
   date: number;
   chat: { id: number; type: string; title?: string; first_name?: string };
-  from?: {
-    id: number;
-    username?: string;
-    first_name?: string;
-    is_bot?: boolean;
-  };
+  from?: TgUser;
   text?: string;
   caption?: string;
   message_thread_id?: number;
@@ -36,12 +39,7 @@ export interface TgMsg {
 export interface TgReaction {
   chat: { id: number; type: string };
   message_id: number;
-  user?: {
-    id: number;
-    username?: string;
-    first_name?: string;
-    is_bot?: boolean;
-  };
+  user?: TgUser;
   date: number;
   old_reaction: { type: string; emoji?: string }[];
   new_reaction: { type: string; emoji?: string }[];

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

@@ -14,6 +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 { toInbound, toReaction, type ReactionEvent, type SelfRef } from './parse.js';
 import { baileysLogger } from './logger.js';
 import { useAccountAuthState } from './auth-state.js';
@@ -53,6 +54,7 @@ export interface WAClient {
   reuploadMedia(m: WAMessage): Promise<WAMessage>;
   lookupSender(number: string): Promise<SenderFound>;
   setProfile(change: ProfileChange): Promise<void>;
+  senderProfile(jid: string): Promise<SenderProfile | null>;
   disconnect(): Promise<void>;
 }
 
@@ -347,6 +349,14 @@ 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 }) };
+    },
     async disconnect() {
       st.closed = true;
       try {

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

@@ -1,5 +1,6 @@
 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,
@@ -39,19 +40,31 @@ 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) => {
-      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`,
-        );
-      });
+      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`);
+        });
     },
     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/xmtp/src/conv-helpers.ts

@@ -39,7 +39,7 @@ export async function createGroupWithMembers(
   return created;
 }
 
-async function resolveAddresses(
+export async function resolveAddresses(
   acct: Account,
   inboxIds: string[],
 ): Promise<Record<string, string>> {

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

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

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

@@ -23,7 +23,7 @@ const STAMP_CLEAR_URL = 'https://stamp.fyi/clear/';
 const ZERO = '0x0000000000000000000000000000000000000000';
 const TEXT_KEYS = { name: 'name', bio: 'description', avatar: 'avatar' } as const;
 
-const REGISTRY_ABI = [
+export const REGISTRY_ABI = [
   { name: 'resolver', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'address' }] },
 ] as const;
 
@@ -42,7 +42,7 @@ const REVERSE_ABI = [
   { name: 'setName', type: 'function', stateMutability: 'nonpayable', inputs: [{ name: 'name', type: 'string' }], outputs: [{ name: '', type: 'bytes32' }] },
 ] as const;
 
-const NAME_ABI = [
+export const NAME_ABI = [
   { name: 'name', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'string' }] },
 ] as const;
 

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

@@ -0,0 +1,95 @@
+import { namehash, type Hex } from 'viem';
+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 { 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;
+  name: string | null;
+  displayName: string | null;
+  about: string | null;
+  avatar: string | null;
+}
+
+const BASE_RPC = 'https://mainnet.base.org';
+const LOOKUP_MS = 4000;
+const ZERO = '0x0000000000000000000000000000000000000000';
+const AVATAR_RE = /^(https?:\/\/|ipfs:\/\/|data:image\/)/i;
+
+const TEXT_ABI = [
+  { name: 'addr', type: 'function', stateMutability: 'view', inputs: [{ name: 'node', type: 'bytes32' }], outputs: [{ name: '', type: 'address' }] },
+  {
+    name: 'text',
+    type: 'function',
+    stateMutability: 'view',
+    inputs: [{ name: 'node', type: 'bytes32' }, { name: 'key', type: 'string' }],
+    outputs: [{ name: '', type: 'string' }],
+  },
+] as const;
+
+export const baseRpc = (): string => process.env.METRO_BASE_RPC ?? BASE_RPC;
+
+let reader: BaseClient | null = null;
+const readerFor = (): BaseClient => (reader ??= makePublicClient(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);
+  return found === ZERO ? BASENAME_L2_RESOLVER : found;
+}
+
+async function primaryName(client: BaseClient, 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(() => '');
+  return found === '' ? null : found;
+}
+
+async function recordsOf(client: BaseClient, 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 [forward, displayName, about, avatar] = await Promise.all([
+    client.readContract({ ...resolver, functionName: 'addr', args: [node] }).catch(() => ZERO),
+    text('name'),
+    text('description'),
+    text('avatar'),
+  ]);
+  if (forward.toLowerCase() !== address.toLowerCase()) return null;
+  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> {
+  const bare: SenderProfile = { address, name: null, displayName: null, about: null, avatar: null };
+  const name = (await primaryName(client, address)) ?? (await nameOf(address, fetchImpl).catch(() => null));
+  if (name === null) return bare;
+  return (await recordsOf(client, name, address).catch(() => null)) ?? bare;
+}
+
+const senders = makeProfileCache<SenderProfile>(
+  async (key) => {
+    const [accountId, inboxId] = key.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`) },
+);
+
+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);

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

@@ -18,7 +18,7 @@ const ENTRY_POINT = getEntryPoint('0.7');
 export const zerodevRpc = (): string =>
   `https://rpc.zerodev.app/api/v3/${process.env.METRO_ZERODEV_PROJECT ?? STAGE_ZERODEV_PROJECT}/chain/${String(SMART_CHAIN_ID)}`;
 
-const makePublicClient = (rpc: string) => createPublicClient({ chain: base, transport: http(rpc) });
+export const makePublicClient = (rpc: string) => createPublicClient({ chain: base, transport: http(rpc) });
 
 export type BaseClient = ReturnType<typeof makePublicClient>;
 

package/runtime/runtime.json

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