@stage-labs/metro 0.1.0-beta.31 → 0.1.0-beta.310

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);
 }

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

@@ -0,0 +1,190 @@
+import { TrainError } from '@metro-labs/core/train-error';
+import type { FrameActionContent, FrameContent } from './codecs.js';
+
+export const FRAME_MAX_CHARS = 64 * 1024;
+export const FRAME_MAX_SCREENS = 50;
+const MAX_SCREEN_ID = 120;
+const FRAME_OPEN = 'frame.open';
+const MAX_TITLE = 200;
+const MAX_DESCRIPTION = 1000;
+const MAX_SOURCE_URL = 2048;
+const SUMMARY_SCAN = 80;
+const TEXT_TYPES = new Set(['Text', 'Caption', 'Markdown']);
+
+type Node = Record<string, unknown>;
+
+export const isNode = (v: unknown): v is Node =>
+  typeof v === 'object' && v !== null && !Array.isArray(v);
+
+export const bad = (message: string): TrainError => new TrainError('INVALID_ARGS', message);
+
+function plain(value: unknown): string {
+  if (typeof value !== 'string') return '';
+  return value
+    .replace(/!?\[([^\]]*)\]\([^)]*\)/g, '$1')
+    .replace(/^\s*(?:#{1,6}|>)\s*/gm, '')
+    .replace(/[*_`~]/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function childrenOf(node: Node): Node[] {
+  const c = node.children;
+  if (Array.isArray(c)) return c.filter(isNode);
+  return isNode(c) ? [c] : [];
+}
+
+export function frameSummary(widget: Node): { title?: string; description?: string } {
+  const titles: string[] = [];
+  const texts: string[] = [];
+  const stack: Node[] = [widget];
+  for (let seen = 0; stack.length > 0 && seen < SUMMARY_SCAN; seen += 1) {
+    const node = stack.pop();
+    if (!node) break;
+    const value = plain(node.value);
+    if (node.type === 'Title' && value) titles.push(value);
+    if (typeof node.type === 'string' && TEXT_TYPES.has(node.type) && value) texts.push(value);
+    stack.push(...childrenOf(node).reverse());
+  }
+  const title = titles[0] ?? texts[0];
+  return { title, description: texts.find((t) => t !== title) };
+}
+
+function clip(value: unknown, max: number, name: string): string | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== 'string') throw bad(`frame ${name} must be a string`);
+  const out = value.trim().slice(0, max);
+  return out === '' ? undefined : out;
+}
+
+export function parseJson(raw: unknown, name: string): unknown {
+  if (typeof raw !== 'string') return raw;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw bad(`${name} is not valid JSON`);
+  }
+}
+
+function checkSize(value: unknown, name: string): void {
+  const chars = JSON.stringify(value).length;
+  if (chars > FRAME_MAX_CHARS) throw bad(`${name} is ${chars} characters; the limit is ${FRAME_MAX_CHARS}`);
+}
+
+function parseWidget(raw: unknown, name = 'frame widget'): Node {
+  const widget = parseJson(raw, name);
+  if (!isNode(widget) || typeof widget.type !== 'string' || widget.type === '')
+    throw bad(`${name} must be a ChatKit widget object with a \`type\` (Card, ListView or Basic)`);
+  checkSize(widget, name);
+  return widget;
+}
+
+function parseScreen(id: string, raw: unknown): { screen: Node; widget: Node } {
+  const name = `frame screen "${id}"`;
+  const given = parseJson(raw, name);
+  if (!isNode(given) || given.type !== undefined || given.widget === undefined) {
+    const widget = parseWidget(given, name);
+    return { screen: widget, widget };
+  }
+  const widget = parseWidget(given.widget, `${name} widget`);
+  const title = clip(given.title, MAX_TITLE, `screen "${id}" title`);
+  return { screen: title ? { title, widget } : { widget }, widget };
+}
+
+function openTargets(root: unknown): string[] {
+  const targets: string[] = [];
+  const stack: unknown[] = [root];
+  while (stack.length > 0) {
+    const value = stack.pop();
+    if (Array.isArray(value)) stack.push(...(value as unknown[]));
+    else if (isNode(value)) {
+      if (value.type === FRAME_OPEN)
+        targets.push(isNode(value.payload) && typeof value.payload.screen === 'string' ? value.payload.screen : '');
+      stack.push(...Object.values(value));
+    }
+  }
+  return targets;
+}
+
+function screenIds(screens: Node): string[] {
+  const ids = Object.keys(screens);
+  if (ids.length === 0 || ids.length > FRAME_MAX_SCREENS)
+    throw bad(`frame screens must hold 1 to ${FRAME_MAX_SCREENS} screens, not ${ids.length}`);
+  const badId = ids.find((id) => id === '' || id.length > MAX_SCREEN_ID);
+  if (badId !== undefined) throw bad(`frame screen ids must be 1 to ${MAX_SCREEN_ID} characters`);
+  return ids;
+}
+
+function checkLinks(screens: Node, ids: string[], start: unknown): void {
+  if (typeof start !== 'string' || !ids.includes(start))
+    throw bad(`frame start is required with screens and must be one of their ids: ${ids.slice(0, 10).join(', ')}`);
+  const lost = openTargets(screens).find((target) => !ids.includes(target));
+  if (lost !== undefined)
+    throw bad(`frame.open goes to screen "${lost}", which is not in screens (${ids.slice(0, 10).join(', ')})`);
+}
+
+interface FrameBody {
+  content: Pick<FrameContent, 'widget' | 'screens' | 'start'>;
+  first: Node;
+}
+
+function parseScreens(raw: unknown, start: unknown): FrameBody {
+  const given = parseJson(raw, 'frame screens');
+  if (!isNode(given))
+    throw bad('frame screens must be an object of screen id to widget: {"home": {…}, "story": {"title": "…", "widget": {…}}}');
+  const ids = screenIds(given);
+  const parsed = ids.map((id) => [id, parseScreen(id, given[id])] as const);
+  const screens: Node = Object.fromEntries(parsed.map(([id, p]) => [id, p.screen]));
+  checkSize(screens, 'frame screens');
+  checkLinks(screens, ids, start);
+  const first = parsed.find(([id]) => id === start)?.[1];
+  if (!first || typeof start !== 'string') throw bad('frame start must name a screen');
+  return { content: { screens, start }, first: first.widget };
+}
+
+function frameBody(args: Node): FrameBody {
+  if (args.screens === undefined) {
+    const widget = parseWidget(args.widget);
+    return { content: { widget }, first: widget };
+  }
+  if (args.widget !== undefined) throw bad('frame takes `widget` or `screens`, not both');
+  return parseScreens(args.screens, args.start);
+}
+
+function sourcePart(raw: unknown): Pick<FrameContent, 'source'> {
+  if (raw === undefined) return {};
+  const url = isNode(raw) && typeof raw.url === 'string' ? raw.url.trim() : '';
+  if (url.length > MAX_SOURCE_URL)
+    throw bad(`frame source url is ${url.length} characters; the limit is ${MAX_SOURCE_URL}`);
+  if (!URL.canParse(url) || new URL(url).protocol !== 'https:')
+    throw bad('frame source must be {"url": "https://…"}, the node that serves this widget');
+  return { source: { url } };
+}
+
+export function buildFrameContent(raw: unknown): { frame: FrameContent; title: string } {
+  const args = parseJson(raw, 'frame');
+  if (!isNode(args))
+    throw bad('frame must be an object: {widget, title?, description?} or {screens, start, title?, description?}');
+  const body = frameBody(args);
+  const derived = frameSummary(body.first);
+  const title = clip(args.title, MAX_TITLE, 'title') ?? derived.title?.slice(0, MAX_TITLE);
+  const description = clip(args.description, MAX_DESCRIPTION, 'description') ?? derived.description?.slice(0, MAX_DESCRIPTION);
+  const frame: FrameContent = {
+    ...(title ? { title } : {}),
+    ...(description && description !== title ? { description } : {}),
+    ...body.content,
+    ...sourcePart(args.source),
+  };
+  return { frame, title: title ?? 'Frame' };
+}
+
+export function asFrameAction(c: object): FrameActionContent | undefined {
+  const v = c as Partial<FrameActionContent>;
+  if (typeof v.frameId !== 'string' || !isNode(v.action) || typeof v.action.type !== 'string') return undefined;
+  const payload = isNode(v.action.payload) ? v.action.payload : undefined;
+  return {
+    frameId: v.frameId,
+    action: payload ? { type: v.action.type, payload } : { type: v.action.type },
+    ...(typeof v.label === 'string' && v.label ? { label: v.label } : {}),
+  };
+}

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

@@ -1,7 +1,7 @@
 import type {
   MemberOutcome,
   MemberOutcomeStatus,
-} from '@metro-labs/mcp/stations/types';
+} from '@metro-labs/core/stations/types';
 
 type Args = Record<string, unknown>;
 

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

@@ -1,5 +1,5 @@
-import { TrainError } from '@metro-labs/mcp/train-error';
-import type { GroupResult } from '@metro-labs/mcp/stations/types';
+import { TrainError } from '@metro-labs/core/train-error';
+import type { GroupResult } from '@metro-labs/core/stations/types';
 import { accountForCall, convOf, lineOf } from './accounts.js';
 import {
   applyMemberOp,