@stage-labs/metro 0.1.0-beta.32 → 0.1.0-beta.320

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

@@ -6,14 +6,28 @@ import {
 import {
   saveBufferToCache,
   assertAttachmentSize,
-} from '@metro-labs/mcp/stations/attachments';
-import type { SavedAttachment } from '@metro-labs/mcp/stations/attachments';
-import { errMsg } from '@metro-labs/mcp/log';
+} from '@metro-labs/core/stations/attachments';
+import type { SavedAttachment } from '@metro-labs/core/stations/attachments';
+import { errMsg } from '@metro-labs/core/log';
 
 export type { SavedAttachment };
 
-export const REMOTE_FETCH_ATTEMPTS = 3;
-const REMOTE_FETCH_BACKOFF_MS = 400;
+interface FetchSchedule {
+  delaysMs: readonly number[];
+  requestTimeoutMs: number;
+}
+
+const READ_SCHEDULE: FetchSchedule = { delaysMs: [400, 800], requestTimeoutMs: 18_000 };
+export const INBOUND_FETCH_SCHEDULE: FetchSchedule = {
+  delaysMs: [
+    2_000, 4_000, 8_000, 15_000, 30_000, 30_000,
+    60_000, 60_000, 60_000, 60_000, 60_000, 60_000,
+  ],
+  requestTimeoutMs: 120_000,
+};
+export const REMOTE_FETCH_ATTEMPTS = READ_SCHEDULE.delaysMs.length + 1;
+const SWARM_GATEWAY = 'https://download.gateway.ethswarm.org/bzz/';
+const SWARM_BZZ_URL = /^https:\/\/[^/]+\/bzz\/([0-9a-f]{64}(?:[0-9a-f]{64})?)\/?$/i;
 
 const sleep = (ms: number): Promise<void> =>
   new Promise((resolve) => setTimeout(resolve, ms));
@@ -74,22 +88,50 @@ interface DecodedAttachment {
   data: Uint8Array;
 }
 
-async function loadRemote(r: RemoteEntry): Promise<DecodedAttachment> {
+function remoteUrl(url: string): string {
+  const ref = SWARM_BZZ_URL.exec(url)?.[1];
+  return ref === undefined ? url : `${SWARM_GATEWAY}${ref.toLowerCase()}/`;
+}
+
+function withTimeout<T>(work: Promise<T>, ms: number, url: string): Promise<T> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const expired = new Promise<never>((_resolve, reject) => {
+    timer = setTimeout(() => {
+      reject(new Error(`no answer from ${url} within ${ms / 1000}s`));
+    }, ms);
+  });
+  return Promise.race([work, expired]).finally(() => {
+    clearTimeout(timer);
+  });
+}
+
+function loadFrom(r: RemoteEntry, url: string, timeoutMs: number): Promise<DecodedAttachment> {
+  return withTimeout(
+    RemoteAttachmentCodec.load<DecodedAttachment>(
+      { ...toRemoteDescriptor(r), url },
+      loadRegistry,
+    ),
+    timeoutMs,
+    url,
+  );
+}
+
+async function loadRemote(
+  r: RemoteEntry,
+  schedule: FetchSchedule,
+): Promise<DecodedAttachment> {
+  const url = remoteUrl(r.url);
   let last = '';
-  for (let attempt = 1; attempt <= REMOTE_FETCH_ATTEMPTS; attempt += 1) {
+  for (const delay of [0, ...schedule.delaysMs]) {
+    if (delay > 0) await sleep(delay);
     try {
-      return await RemoteAttachmentCodec.load<DecodedAttachment>(
-        toRemoteDescriptor(r),
-        loadRegistry,
-      );
+      return await loadFrom(r, url, schedule.requestTimeoutMs);
     } catch (err) {
       last = errMsg(err);
-      if (attempt < REMOTE_FETCH_ATTEMPTS)
-        await sleep(REMOTE_FETCH_BACKOFF_MS * attempt);
     }
   }
   throw new Error(
-    `xmtp remote attachment fetch failed after ${REMOTE_FETCH_ATTEMPTS} attempts: ${last}`,
+    `xmtp remote attachment fetch failed after ${schedule.delaysMs.length + 1} attempts: ${last}`,
   );
 }
 
@@ -97,9 +139,10 @@ export async function saveRemoteAttachment(
   r: RemoteEntry,
   messageId: string,
   index = 0,
+  schedule: FetchSchedule = READ_SCHEDULE,
 ): Promise<SavedAttachment> {
   if (r.contentLength) assertAttachmentSize(r.contentLength);
-  const decoded = await loadRemote(r);
+  const decoded = await loadRemote(r, schedule);
   return saveBufferToCache(decoded.data, messageId, index, {
     mime: decoded.mimeType,
     name: decoded.filename ?? r.filename,

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

@@ -0,0 +1,48 @@
+import type { DecodedMessage } from '@xmtp/node-sdk';
+import { isRecord } from '@metro-labs/core/is-record';
+import { TrainError } from '@metro-labs/core/train-error';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { accounts, lineOf, type Account } from './accounts.js';
+import { isCallSignal } from './codecs.js';
+
+const RECENT_MS = 24 * 60 * 60_000;
+const STAGE_HISTORY = 100;
+
+interface Leftover {
+  line: string;
+  callId: string;
+  peer: string;
+}
+
+function ownSignal(acct: Account, m: DecodedMessage): Record<string, unknown> | null {
+  if (m.senderInboxId !== acct.inboxId || !isCallSignal(m)) return null;
+  return isRecord(m.content) ? m.content : null;
+}
+
+function openJoins(acct: Account, line: string, messages: DecodedMessage[]): Leftover[] {
+  const open = new Map<string, string>();
+  for (const m of messages) {
+    const signal = ownSignal(acct, m);
+    if (signal === null || typeof signal.from !== 'string' || typeof signal.callId !== 'string') continue;
+    if (signal.kind === 'join') open.set(signal.from, signal.callId);
+    else if (signal.kind === 'leave') open.delete(signal.from);
+  }
+  return [...open].map(([peer, callId]) => ({ line, callId, peer }));
+}
+
+async function leftoversOf(acct: Account, sinceNs: bigint): Promise<Leftover[]> {
+  const found: Leftover[] = [];
+  for (const conv of await acct.client.conversations.list()) {
+    const newestFirst = await conv.messages({ sentAfterNs: sinceNs, direction: 1, limit: STAGE_HISTORY });
+    found.push(...openJoins(acct, lineOf(acct.cfg.id, conv.id), newestFirst.reverse()));
+  }
+  return found;
+}
+
+export async function callLeftovers(id: string): Promise<void> {
+  if (accounts.size === 0) throw new TrainError('UNAVAILABLE', 'no XMTP account is ready yet');
+  const sinceNs = BigInt(Date.now() - RECENT_MS) * 1_000_000n;
+  const calls: Leftover[] = [];
+  for (const acct of accounts.values()) calls.push(...(await leftoversOf(acct, sinceNs)));
+  respond(id, { result: { calls } });
+}

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

@@ -0,0 +1,56 @@
+import {
+  ChannelDirectory,
+  DIRECTORY_LIMIT,
+  type ChannelSnapshot,
+} from '@metro-labs/core/stations/channel-directory';
+import { respond } from '@metro-labs/core/stations/station-runtime';
+import { TrainError } from '@metro-labs/core/train-error';
+import { ListConversationsOrderBy, type ListConversationsOptions } from '@xmtp/node-sdk';
+import { accountForCall, lineOf, type Account } from './accounts.js';
+import { syncConversations } from './network.js';
+
+interface ConversationMetadata {
+  id: string;
+  name?: string;
+}
+
+interface ConversationSource {
+  sync: () => Promise<unknown>;
+  list: (options: ListConversationsOptions) => Promise<ConversationMetadata[]>;
+}
+
+const directories = new WeakMap<Account, ChannelDirectory>();
+
+export async function loadChannels(account: string, source: ConversationSource): Promise<ChannelSnapshot> {
+  await syncConversations(source);
+  const conversations = await source.list({
+    limit: DIRECTORY_LIMIT + 1,
+    includeDuplicateDms: false,
+    orderBy: ListConversationsOrderBy.CreatedAt,
+  });
+  return {
+    channels: conversations.slice(0, DIRECTORY_LIMIT + 1).map((conversation) => ({
+      id: conversation.id,
+      line: lineOf(account, conversation.id),
+      ...('name' in conversation && conversation.name ? { name: conversation.name } : {}),
+      kind: 'name' in conversation ? 'group' : 'direct',
+    })),
+    capability: {
+      supported: true,
+      complete: false,
+      source: 'mixed',
+      reason: 'Only conversations known to this XMTP installation are listed; other devices may know more. Group names use locally stored metadata.' +
+        (conversations.length > DIRECTORY_LIMIT ? ` Results are limited to ${DIRECTORY_LIMIT} conversations.` : ''),
+    },
+  };
+}
+
+export async function listChannels(id: string, args: Record<string, unknown>): Promise<void> {
+  if (typeof args.account !== 'string' || !args.account.trim())
+    throw new TrainError('INVALID_ARGS', 'listChannels requires an account');
+  const acct = accountForCall({ account: args.account });
+  const directory = directories.get(acct) ?? new ChannelDirectory();
+  directories.set(acct, directory);
+  const result = await directory.list(acct.cfg.id, args, () => loadChannels(acct.cfg.id, acct.client.conversations));
+  respond(id, { result });
+}

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

@@ -11,17 +11,19 @@ const dec = (e: EncodedContent): unknown =>
 
 const makeJsonCodec = <T>(
   contentType: ContentTypeId,
-  fallbackFn: (c: T) => string,
+  fallbackFn: (c: T) => string | undefined,
+  push = true,
 ) =>
   class {
     get contentType() {
       return contentType;
     }
     encode(c: T): EncodedContent {
+      const fallback = fallbackFn(c);
       return {
         type: contentType,
         parameters: {},
-        fallback: fallbackFn(c),
+        ...(fallback === undefined ? {} : { fallback }),
         content: enc(c),
       };
     }
@@ -32,7 +34,7 @@ const makeJsonCodec = <T>(
       return fallbackFn(c);
     }
     shouldPush() {
-      return true;
+      return push;
     }
   };
 
@@ -164,8 +166,117 @@ export const SignatureReferenceCodec =
     c.signature ? `[Signature] ${c.signature}` : '[Signature]',
   );
 
+const xmtpOrg = (typeId: string): ContentTypeId => ({
+  authorityId: 'xmtp.org',
+  typeId,
+  versionMajor: 1,
+  versionMinor: 0,
+});
+export const WalletSendCallsCodec = makeJsonCodec<{ calls?: { metadata?: { description?: string } }[] }>(
+  xmtpOrg('walletSendCalls'),
+  (c) => {
+    const desc = c.calls?.[0]?.metadata?.description;
+    return desc ? `[Transaction request] ${desc}` : '[Transaction request]';
+  },
+);
+export const TransactionReferenceCodec = makeJsonCodec<{ reference?: string }>(
+  xmtpOrg('transactionReference'),
+  (c) => (c.reference ? `[Transaction] ${c.reference}` : '[Transaction]'),
+);
+
+export const ContentTypeFrame: ContentTypeId = {
+  authorityId: 'stage.box',
+  typeId: 'frame',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+export interface FrameContent {
+  title?: string;
+  description?: string;
+  widget?: Record<string, unknown>;
+  screens?: Record<string, unknown>;
+  start?: string;
+  source?: { url: string };
+}
+export const frameFallback = (c: FrameContent): string => {
+  const head = c.title ? `Frame: ${c.title}` : 'Frame';
+  return c.description ? `${head}\n${c.description}` : head;
+};
+export const FrameCodec = makeJsonCodec<FrameContent>(ContentTypeFrame, frameFallback);
+
+export const ContentTypeFrameAction: ContentTypeId = {
+  authorityId: 'stage.box',
+  typeId: 'frameAction',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+export interface FrameActionContent {
+  frameId: string;
+  action: { type: string; payload?: Record<string, unknown> };
+  label?: string;
+}
+export const frameActionText = (c: FrameActionContent): string => {
+  const payload = c.action.payload === undefined ? '' : ` ${JSON.stringify(c.action.payload)}`;
+  return `Frame action: ${c.action.type}${payload}`;
+};
+const FrameActionCodec = makeJsonCodec<FrameActionContent>(ContentTypeFrameAction, frameActionText);
+
+export const ContentTypeDeleteRequest: ContentTypeId = {
+  authorityId: 'stage.box',
+  typeId: 'deleteRequest',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+const DeleteRequestCodec = makeJsonCodec<{ messageId: string }>(ContentTypeDeleteRequest, () => 'Message deleted');
+
+const ContentTypeDeleteMessage: ContentTypeId = {
+  authorityId: 'xmtp.org',
+  typeId: 'deleteMessage',
+  versionMajor: 1,
+  versionMinor: 0,
+};
+
+const varint = (value: number): number[] => {
+  const out: number[] = [];
+  let rest = value;
+  while (rest > 0x7f) {
+    out.push((rest & 0x7f) | 0x80);
+    rest = Math.floor(rest / 0x80);
+  }
+  out.push(rest);
+  return out;
+};
+
+export function encodeDeleteMessage(messageId: string): EncodedContent {
+  const id = new TextEncoder().encode(messageId);
+  return {
+    type: ContentTypeDeleteMessage,
+    parameters: {},
+    content: new Uint8Array([0x0a, ...varint(id.length), ...id]),
+  };
+}
+
+export const CALL_TYPES = new Set(['callInvite', 'callSignal']);
+const callContentType = (typeId: string): ContentTypeId => ({
+  authorityId: 'stage.box',
+  typeId,
+  versionMajor: 1,
+  versionMinor: 0,
+});
+const CallInviteCodec = makeJsonCodec<{ video?: unknown }>(callContentType('callInvite'), (c) =>
+  c.video === true ? '📞 Video call' : '📞 Voice call',
+);
+export const isCallSignal = (m: { contentType?: ContentTypeId }): boolean =>
+  m.contentType?.authorityId === 'stage.box' && m.contentType.typeId === 'callSignal';
+export const CallSignalCodec = makeJsonCodec<Record<string, unknown>>(callContentType('callSignal'), () => undefined, false);
+
 export const CODECS = (): ContentCodec[] => [
   new PollCodec(),
   new SignatureRequestCodec(),
   new SignatureReferenceCodec(),
+  new FrameCodec(),
+  new FrameActionCodec(),
+  new DeleteRequestCodec(),
+  new CallInviteCodec(),
+  new CallSignalCodec(),
 ];

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

@@ -1,9 +1,10 @@
 import { IdentifierKind } from '@xmtp/node-sdk';
 import { convOf, type Account } from './accounts.js';
 import { inboxEthCache, cacheInboxEth } from './wire.js';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import type { MemberList, MetroMember } from '@metro-labs/mcp/stations/types';
-import { readAppData, type GroupLike } from './labels.js';
+import { TrainError } from '@metro-labs/core/train-error';
+import type { MemberList, MetroMember } from '@metro-labs/core/stations/types';
+import { readAppData, readAppDataObject, type GroupLike } from './labels.js';
+import { network, syncConversation } from './network.js';
 
 export { parseMemberArgs, resolveMembers } from './member-args.js';
 
@@ -39,7 +40,7 @@ export async function createGroupWithMembers(
   return created;
 }
 
-async function resolveAddresses(
+export async function resolveAddresses(
   acct: Account,
   inboxIds: string[],
 ): Promise<Record<string, string>> {
@@ -67,7 +68,9 @@ async function resolveAddresses(
         cacheInboxEth(key, eth.identifier);
       }
     }
-  } catch {
+  } catch (error) {
+    network.note(error);
+    if (network.remaining() > 0) throw error;
     return addresses;
   }
   return addresses;
@@ -78,17 +81,19 @@ export async function buildGroupInfo(
   acct: Account,
   conv: Conv,
 ): Promise<Record<string, unknown>> {
-  const inboxIds = (await conv.members()).map((m) => m.inboxId);
-  const addresses = await resolveAddresses(acct, inboxIds);
+  await syncConversation(acct.client, conv);
+  const rawAppData = (conv as unknown as GroupLike).appData ?? '';
+  const appData = readAppDataObject(rawAppData);
+  const members = await conv.members();
+  const inboxIds = members.map((m) => m.inboxId);
+  const addresses = memberAddresses(members);
   const isDm =
     typeof (conv as unknown as { peerInboxId?: unknown }).peerInboxId ===
     'function';
   const gn = (conv as unknown as { name?: string | (() => Promise<string>) })
     .name;
   const resolvedName = typeof gn === 'function' ? await gn() : (gn ?? '');
-  const { labels, github, preview } = readAppData(
-    (conv as unknown as GroupLike).appData,
-  );
+  const { labels, category, status, priority, github, preview } = readAppData(rawAppData);
   return {
     line,
     id: conv.id,
@@ -97,8 +102,14 @@ export async function buildGroupInfo(
     name: resolvedName ?? '',
     memberCount: inboxIds.length,
     labels,
+    category,
+    status,
+    priority,
     github,
     preview,
+    assigned: Object.hasOwn(appData, 'assigned') ? appData.assigned : [],
+    appData,
+    rawAppData,
     members: inboxIds.map((iid) => ({
       inboxId: iid,
       address: addresses[iid] ?? null,
@@ -109,6 +120,16 @@ export async function buildGroupInfo(
 interface RawMember {
   inboxId: string;
   permissionLevel?: number;
+  accountIdentifiers?: EthId[];
+}
+
+function memberAddresses(members: RawMember[]): Record<string, string> {
+  const addresses: Record<string, string> = {};
+  for (const member of members) {
+    const eth = member.accountIdentifiers?.find((id) => id.identifierKind === IdentifierKind.Ethereum);
+    if (eth) addresses[member.inboxId] = eth.identifier;
+  }
+  return addresses;
 }
 
 function toMetroMember(
@@ -123,15 +144,9 @@ function toMetroMember(
   return member;
 }
 
-export async function buildMemberList(
-  acct: Account,
-  conv: Conv,
-): Promise<MemberList> {
-  const raw = (await conv.members()) as RawMember[];
-  const addresses = await resolveAddresses(
-    acct,
-    raw.map((m) => m.inboxId),
-  );
+export async function buildMemberList(conv: Conv): Promise<MemberList> {
+  const raw = await conv.members();
+  const addresses = memberAddresses(raw);
   return {
     members: raw.map((m) => toMetroMember(m, addresses)),
     capability: { supported: true, complete: true, total: raw.length },
@@ -194,7 +209,7 @@ export async function applyMemberOp(
       'INVALID_ARGS',
       `${verb} target is not a group (no ${verb})`,
     );
-  await group.sync?.().catch(() => undefined);
+  await group.sync?.();
   await applyByIdentifiers(group, byIdent, addrs, verb);
   await applyByInboxId(group, byId, inboxes, verb);
 }

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

@@ -0,0 +1,34 @@
+import type { DecodedMessage } from '@xmtp/node-sdk';
+import { ContentTypeDeleteRequest } from './codecs.js';
+
+type Listed = Pick<DecodedMessage, 'id' | 'senderInboxId' | 'contentType' | 'content'>;
+
+export const isDeleteRequest = (m: Pick<Listed, 'contentType'>): boolean =>
+  m.contentType?.authorityId === ContentTypeDeleteRequest.authorityId &&
+  m.contentType.typeId === ContentTypeDeleteRequest.typeId;
+
+function targetOf(m: Listed): string | undefined {
+  if (!isDeleteRequest(m)) return undefined;
+  const id = (m.content as { messageId?: unknown } | undefined)?.messageId;
+  return typeof id === 'string' && id ? id : undefined;
+}
+
+export function superAdminCheck(conv: unknown): (inboxId: string) => boolean {
+  const group = conv as { isSuperAdmin?: (inboxId: string) => boolean };
+  return (inboxId) => typeof group.isSuperAdmin === 'function' && group.isSuperAdmin(inboxId);
+}
+
+export function deletedByRequests(
+  messages: Listed[],
+  isSuperAdmin: (inboxId: string) => boolean,
+): Set<string> {
+  const senders = new Map(messages.map((m) => [m.id, m.senderInboxId]));
+  const deleted = new Set<string>();
+  for (const m of messages) {
+    const target = targetOf(m);
+    const sender = target === undefined ? undefined : senders.get(target);
+    if (target !== undefined && sender !== undefined && (sender === m.senderInboxId || isSuperAdmin(m.senderInboxId)))
+      deleted.add(target);
+  }
+  return deleted;
+}

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

@@ -1,13 +1,17 @@
 import type { Reaction } from '@xmtp/content-type-reaction';
 import type { Reply } from '@xmtp/content-type-reply';
-import { errMsg } from '@metro-labs/mcp/log';
+import { errMsg } from '@metro-labs/core/log';
 import { transcribeAndEmit } from './transcribe.js';
 import {
+  INBOUND_FETCH_SCHEDULE,
   saveInlineAttachment,
   saveRemoteAttachment,
   type RemoteEntry,
 } from './attachments.js';
-import { emitInbound, emitAttachmentSaved } from './emit-core.js';
+import { reportAttachment } from '@metro-labs/core/stations/train-events';
+import { sentByMe } from './wire.js';
+import { CALL_TYPES, frameActionText, frameFallback, type FrameContent } from './codecs.js';
+import { asFrameAction } from './frames.js';
 
 export interface EnvelopeCtx {
   accountId: string;
@@ -150,6 +154,7 @@ function replyPayload(
         ? c.content
         : `[reply with ${c.contentType?.typeId ?? 'unknown'}]`,
     event: { type: 'reply', replyTo: c.reference },
+    ...(sentByMe(c.reference) ? { reply_to_self: true } : {}),
     payload: {
       contentType: typeId,
       replyTo: c.reference,
@@ -187,19 +192,12 @@ function inlineAttachmentPayload(
       ctx.line,
       ctx.accountId,
       ctx.baseId,
-      emitInbound,
     ).catch((err: unknown) => {
       process.stderr.write(
         `xmtp[${ctx.accountId}] voice transcription failed: ${errMsg(err)}\n`,
       );
     });
-  emitAttachmentSaved(
-    ctx.accountId,
-    ctx.line,
-    ctx.baseId,
-    0,
-    saveInlineAttachment(c, ctx.msgId, 0),
-  );
+  reportAttachment(saveInlineAttachment(c, ctx.msgId, 0), { station: 'xmtp', account: ctx.accountId, line: ctx.line, forId: ctx.baseId, index: 0 });
   return out;
 }
 
@@ -210,13 +208,7 @@ function remoteStaticPayload(
   ctx: EnvelopeCtx,
 ): Record<string, unknown> {
   const kind = IMG_RE.test(c.url) ? 'image' : 'file';
-  emitAttachmentSaved(
-    ctx.accountId,
-    ctx.line,
-    ctx.baseId,
-    0,
-    saveRemoteAttachment(c, ctx.msgId, 0),
-  );
+  reportAttachment(saveRemoteAttachment(c, ctx.msgId, 0, INBOUND_FETCH_SCHEDULE), { station: 'xmtp', account: ctx.accountId, line: ctx.line, forId: ctx.baseId, index: 0 });
   return {
     ...base,
     text: `[${kind}: ${c.filename ?? c.url}]`,
@@ -232,13 +224,7 @@ function multiRemoteEnvelope(
 ): Record<string, unknown> {
   const m = c as { attachments?: RemoteEntry[] };
   (Array.isArray(m.attachments) ? m.attachments : []).forEach((r, i) => {
-    emitAttachmentSaved(
-      ctx.accountId,
-      ctx.line,
-      ctx.baseId,
-      i,
-      saveRemoteAttachment(r, ctx.msgId, i),
-    );
+    reportAttachment(saveRemoteAttachment(r, ctx.msgId, i, INBOUND_FETCH_SCHEDULE), { station: 'xmtp', account: ctx.accountId, line: ctx.line, forId: ctx.baseId, index: i });
   });
   return multiRemotePayload(base, typeId, c);
 }
@@ -317,6 +303,31 @@ function refEnvelope(
   return undefined;
 }
 
+function frameEnvelope(
+  base: Record<string, unknown>,
+  typeId: string,
+  c: object,
+): Record<string, unknown> | undefined {
+  if (typeId === 'frame') {
+    const f = c as Partial<FrameContent>;
+    const frame: FrameContent = {
+      ...(typeof f.title === 'string' ? { title: f.title } : {}),
+      ...(typeof f.description === 'string' ? { description: f.description } : {}),
+    };
+    return { ...base, text: frameFallback(frame), payload: { contentType: typeId, frame: c } };
+  }
+  const a = typeId === 'frameAction' ? asFrameAction(c) : undefined;
+  if (!a) return undefined;
+  const label = a.label ? ` (tapped "${a.label}")` : '';
+  return {
+    ...base,
+    text: `${frameActionText(a)}${label}`,
+    event: { type: 'reply', replyTo: a.frameId },
+    ...(sentByMe(a.frameId) ? { reply_to_self: true } : {}),
+    payload: { contentType: typeId, frameAction: a, replyTo: a.frameId },
+  };
+}
+
 export function typedEnvelope(
   base: Record<string, unknown>,
   typeId: string | undefined,
@@ -326,8 +337,10 @@ export function typedEnvelope(
   if (typeId === 'reaction') return reactionPayload(base, c as Reaction);
   if (typeId === 'reply') return replyPayload(base, typeId, c as Reply);
   if (typeId === 'poll') return pollPayload(base, typeId, c);
+  if (typeId !== undefined && CALL_TYPES.has(typeId)) return { ...base, payload: { contentType: typeId, call: c } };
   return (
     attachmentEnvelope(base, typeId ?? '', c, ctx) ??
-    refEnvelope(base, typeId, c)
+    refEnvelope(base, typeId, c) ??
+    frameEnvelope(base, typeId ?? '', c)
   );
 }

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

@@ -1,12 +1,10 @@
 import type { Conversation, DecodedMessage } from '@xmtp/node-sdk';
-import { lineOf, parseLine } from './accounts.js';
-import { emit, mintId, rememberUid, SELF_URI } from './wire.js';
-import { fcmPushToAll } from './push.js';
-import { emitInbound, emitAttachmentSaved } from './emit-core.js';
+import { lineOf } from './accounts.js';
+import { selfUri } from '@metro-labs/core/stations/train-events';
+import { emit, mintId } from '@metro-labs/core/stations/station-runtime';
+import { rememberSent, rememberUid } from './wire.js';
 import { typedEnvelope, type EnvelopeCtx } from './emit-payloads.js';
-import type { StructuredEvent } from '@metro-labs/mcp/events';
-
-export { emitInbound, emitAttachmentSaved };
+import type { StructuredEvent } from '@metro-labs/core/events';
 
 export function envelope(
   accountId: string,
@@ -23,6 +21,7 @@ export function envelope(
     line,
     from: `metro://xmtp/${accountId}/user/${msg.senderInboxId}`,
     message_id: msg.id,
+    is_private: 'peerInboxId' in conv,
   };
   rememberUid(base.id, msg.id);
   if (typeof c === 'string')
@@ -53,26 +52,17 @@ export function emitOutbound(
 ): void {
   const uid = mintId();
   rememberUid(uid, messageId);
+  rememberSent(messageId);
   emit({
-    kind: 'outbound',
     id: uid,
     ts: new Date().toISOString(),
     station: 'xmtp',
     line,
-    from: SELF_URI,
+    from: selfUri(),
     to: line,
     message_id: messageId,
     text,
-    account: accountId,
     ...(event ? { event } : {}),
     payload: { account: accountId },
   });
-  void (async (): Promise<void> => {
-    const data: Record<string, string> = { line, messageId };
-    {
-      const p = parseLine(line);
-      if (p) data.convId = p.convId.toLowerCase();
-    }
-    await fcmPushToAll(accountId, data);
-  })().catch(() => undefined);
 }