@stage-labs/metro 0.1.0-beta.232 → 0.1.0-beta.234

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.232",
+  "version": "0.1.0-beta.234",
   "description": "The metro command line: run your agent on this machine, relaying its chat channels and connectors to Claude Code.",
   "license": "MIT",
   "repository": {

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

@@ -1,6 +1,6 @@
 {
   "name": "metro",
-  "version": "0.1.0-beta.232",
+  "version": "0.1.0-beta.234",
   "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/marketplace/plugin/STAGE.md

@@ -42,11 +42,11 @@ Move it from Backlog or To-do to In progress, then In review, then Done. Use Blo
 - File: `create_upload {"name": "report.pdf"}`, run the `curl` line it returns in a shell, then `send {"line": "…", "attachments": [{"upload": "<upload_id>"}]}`. Files that are not images are refused over about 190 KiB.
 
 **Frames.** A frame is a small interactive view: a report, a choice, a form. Stage shows it in the chat as a card with a title and a description, and opens it full screen on a tap.
-- Send: `send_frame {"line": "…", "title": "Deploy", "description": "Version 2.4 is ready", "widget": {…}}`. `title` and `description` are optional: they come from the first `Title` and text in the widget when missing.
+- Send: `send {"line": "…", "frame": {"title": "Deploy", "description": "Version 2.4 is ready", "widget": {…}}}`. A frame goes with `send`, like a file: there is no separate tool. `title` and `description` are optional: they come from the first `Title` and text in the widget when missing. With `text` as well, the text goes first, and the `message_id` you get back is the frame's.
 - `widget` is OpenAI ChatKit widget JSON, with ChatKit's names and props (https://openai.github.io/chatkit-js/): a `Card`, `ListView` or `Basic` root, with `Row`, `Col`, `Box`, `Text`, `Title`, `Caption`, `Markdown`, `Badge`, `Icon`, `Image`, `Button`, `Divider`, `Spacer`, `Form`, `Input`, `Textarea`, `Select`, `DatePicker`, `Checkbox`, `RadioGroup` and `Table`. Images must be `https://`. Number spacing is in steps of 4px. At most 64K characters, 16 levels deep and 500 nodes. Stage shows a small notice for anything it does not know.
-- Example:
+- Example, the arguments of one `send`:
   ```json
-  {"type": "Card", "children": [
+  {"line": "…", "frame": {"widget": {"type": "Card", "children": [
     {"type": "Title", "value": "Deploy version 2.4?"},
     {"type": "Text", "value": "3 fixes, no migration.", "color": "secondary"},
     {"type": "Input", "name": "note", "placeholder": "Note (optional)"},
@@ -54,6 +54,22 @@ Move it from Backlog or To-do to In progress, then In review, then Done. Use Blo
       {"type": "Button", "label": "Deploy", "onClickAction": {"type": "deploy", "payload": {"version": "2.4"}}},
       {"type": "Button", "label": "Not now", "color": "secondary", "onClickAction": {"type": "deploy.cancel"}}
     ]}
-  ]}
+  ]}}}
   ```
 - A tap comes back to you as a reply to the frame: `Frame action: deploy {"version":"2.4","note":"…"} (tapped "Deploy")`. The values of the fields (`Input`, `Select`, `Checkbox`, …) are added to the payload by their `name`. `Button.onClickAction`, `ListViewItem.onClickAction`, a `Card` `confirm`/`cancel` (`{"label", "action"}`) and a `Form` `onSubmitAction` send one. Answer it like any message.
+- Screens: send `screens` instead of `widget` to put several screens in one frame, e.g. a list and a page per item. Each screen is a widget, or `{"title", "widget"}` for its own title in Stage's top bar. `start` names the first screen and is required. The action `{"type": "frame.open", "payload": {"screen": "<id>"}}` opens a screen and `{"type": "frame.back"}` goes back. They stay in Stage: no message comes to you. Stage's back arrow goes to the previous screen, and to the chat from the first one. Every other action comes to you as usual, with `screen` (the screen it was tapped on) in its payload. At most 50 screens and 64K characters for all of them; `start` and every `frame.open` must name a screen. Example:
+  ```json
+  {"line": "…", "frame": {"title": "Open invoices", "start": "home", "screens": {
+    "home": {"type": "ListView", "children": [
+      {"type": "ListViewItem", "onClickAction": {"type": "frame.open", "payload": {"screen": "inv-1"}},
+        "children": [{"type": "Text", "value": "Acme, CHF 420"}]}
+    ]},
+    "inv-1": {"title": "Acme", "widget": {"type": "Card", "children": [
+      {"type": "Title", "value": "Invoice 1040, CHF 420"},
+      {"type": "Row", "children": [
+        {"type": "Button", "label": "Back", "color": "secondary", "onClickAction": {"type": "frame.back"}},
+        {"type": "Button", "label": "Pay", "onClickAction": {"type": "invoice.pay", "payload": {"id": 1040}}}
+      ]}
+    ]}}
+  }}}
+  ```

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

@@ -112,6 +112,7 @@ export interface Station {
   readsProfiles?: boolean;
   readFilters?: ReadonlySet<ReadFilter>;
   approvals?: boolean;
+  sendsFrames?: boolean;
   attachmentMode: AttachmentMode;
   forget?: (accountId: string) => void;
   forgetExcept?: (keptAccountIds: readonly string[]) => void;

package/runtime/node_modules/@metro-labs/daemon/src/claude/setup.ts

@@ -163,6 +163,8 @@ const PRIOR_METRO: ReadonlySet<string> = new Set([
 const PRIOR_STAGE: ReadonlySet<string> = new Set([
   'dd7d30474765de3865ddc87c1cf3220161ded09502027cdff18597e5df0aab43',
   '47439ecbe661ca70471a6839ab30a963714c296ad8c14ca23c6eebc3929038cc',
+  'e3b8f9bbdb205311bc643aaf91d9d903a91204fd5b55ca949b85cdfa6fd00136',
+  '08a30f5cd5cf8013ab70c1fa9e1109018c0337552296a8efe5c0cf543b284991',
 ]);
 const PRIOR_MEMORY: ReadonlySet<string> = new Set();
 

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

@@ -60,6 +60,21 @@ function assertDelivered(
     );
 }
 
+const frameOf = (m: MessageArgs): Record<string, unknown> =>
+  m.a.frame === undefined ? {} : { frame: m.a.frame };
+
+const sentLabels = (m: MessageArgs, text: string | undefined): string[] => [
+  ...(text ? ['text'] : []),
+  ...(m.a.frame === undefined ? [] : ['frame']),
+];
+
+function nativeBody(m: MessageArgs, text: string | undefined, replyTo: string | undefined): Record<string, unknown> {
+  const body: Record<string, unknown> = { line: m.line, ...frameOf(m) };
+  if (text) body.text = text;
+  if (text && replyTo) body.replyTo = replyTo;
+  return body;
+}
+
 async function sendNative(
   m: MessageArgs,
   text: string | undefined,
@@ -67,16 +82,9 @@ async function sendNative(
   atts: ResolvedAttachment[],
 ): Promise<Sent> {
   const { line, ctx, station } = m;
-  const labels: string[] = [];
+  const labels = sentLabels(m, text);
   let messageId: string | undefined;
-  if (text) {
-    const response = await ctx.call(
-      'send',
-      replyTo ? { line, text, replyTo } : { line, text },
-    );
-    messageId = messageIdOf(response);
-    labels.push('text');
-  }
+  if (labels.length) messageId = messageIdOf(await ctx.call('send', nativeBody(m, text, replyTo)));
   if (!atts.length) return { labels, messageId };
   const delivered = station.sendAttachments
     ? await station.sendAttachments(line, atts, ctx)
@@ -93,7 +101,7 @@ async function sendForwarded(
   atts: ResolvedAttachment[],
 ): Promise<Sent> {
   const { line, ctx, station } = m;
-  const args: Record<string, unknown> = { line };
+  const args: Record<string, unknown> = { line, ...frameOf(m) };
   if (text) args.text = text;
   if (typeof m.a.subject === 'string' && m.a.subject.trim() !== '') args.subject = m.a.subject;
   if (replyTo) args.replyTo = replyTo;
@@ -101,8 +109,7 @@ async function sendForwarded(
   const response = await ctx.call('send', args);
   const messageId = messageIdOf(response);
   const thread = threadOf(response, line);
-  const labels: string[] = [];
-  if (text) labels.push('text');
+  const labels = sentLabels(m, text);
   if (atts.length) {
     const delivered = deliveredLabels(response);
     assertDelivered(station, delivered, atts);
@@ -116,6 +123,16 @@ const unsupported = (station: Station, atts: CanonicalAttachment[]): string =>
     .map((a) => kindOf(a.mime ?? '', a.path ?? a.url ?? a.name ?? ''))
     .join(', ')}); send a link in \`text\` instead`;
 
+const NOTHING_TO_SEND = 'send requires `text`, `attachments` or `frame`';
+
+function refusal(m: MessageArgs, text: string | undefined, requested: CanonicalAttachment[]): string | undefined {
+  if (!text && !requested.length && m.a.frame === undefined) return NOTHING_TO_SEND;
+  if (m.a.frame !== undefined && m.station.sendsFrames !== true)
+    return `${m.station.name} cannot send a frame; frames are Stage (XMTP) only`;
+  if (requested.length && m.station.attachmentMode === 'none') return unsupported(m.station, requested);
+  return undefined;
+}
+
 function noteSent(m: MessageArgs, messageId: string | undefined): void {
   if (messageId !== undefined) m.onSent?.(messageId);
 }
@@ -124,10 +141,8 @@ async function handleSend(m: MessageArgs): Promise<ToolResult> {
   const text = m.a.text as string | undefined;
   const replyTo = m.a.reply_to as string | undefined;
   const requested = (m.a.attachments as CanonicalAttachment[] | undefined) ?? [];
-  if (!text && !requested.length)
-    return errResult('send requires `text` or `attachments`');
-  if (requested.length && m.station.attachmentMode === 'none')
-    return errResult(unsupported(m.station, requested));
+  const refused = refusal(m, text, requested);
+  if (refused !== undefined) return errResult(refused);
   const atts = await resolveAttachments(requested, {
     allowed: allowedAgents(currentIdentity()),
   });
@@ -138,8 +153,7 @@ async function handleSend(m: MessageArgs): Promise<ToolResult> {
     const sent = native
       ? await sendNative(m, text, replyTo, atts)
       : await sendForwarded(m, text, replyTo, atts);
-    if (!sent.labels.length)
-      return errResult('send requires `text` or `attachments`');
+    if (!sent.labels.length) return errResult(NOTHING_TO_SEND);
     noteSent(m, sent.messageId);
     const done = withId(`sent: ${sent.labels.join(', ')}`, sent.messageId);
     return ok(sent.thread === undefined ? done : `${done} — new thread line: ${sent.thread}`);

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

@@ -37,6 +37,17 @@ function channelOf(input: Record<string, unknown>): string | undefined {
   return typeof input.station === 'string' && input.station !== '' ? input.station : undefined;
 }
 
+function argText(value: unknown): string | undefined {
+  const plain = valueText(value);
+  if (plain !== undefined || value === null || typeof value !== 'object') return plain;
+  return JSON.stringify(value);
+}
+
+function fieldText(key: string, value: unknown): string | undefined {
+  if (key === 'attachments' && Array.isArray(value)) return `${String(value.length)} file(s)`;
+  return key === 'frame' ? argText(value) : valueText(value);
+}
+
 function metroLines(tool: string, input: Record<string, unknown>): string[] {
   const lines = [`Approval needed: ${tool}`];
   const channel = channelOf(input);
@@ -44,7 +55,7 @@ function metroLines(tool: string, input: Record<string, unknown>): string[] {
   const keys = [...LEAD, ...Object.keys(input).filter((k) => !LEAD.includes(k))];
   for (const key of keys) {
     if (PLACE.has(key)) continue;
-    const text = key === 'attachments' && Array.isArray(input.attachments) ? `${String(input.attachments.length)} file(s)` : valueText(input[key]);
+    const text = fieldText(key, input[key]);
     if (text !== undefined) lines.push(`${key === 'text' ? 'Text' : key}: ${key === 'text' ? `"${shorten(text)}"` : shorten(text)}`);
   }
   return lines;
@@ -52,12 +63,6 @@ function metroLines(tool: string, input: Record<string, unknown>): string[] {
 
 const ARGS_MAX = 8;
 
-function argText(value: unknown): string | undefined {
-  const plain = valueText(value);
-  if (plain !== undefined || value === null || typeof value !== 'object') return plain;
-  return JSON.stringify(value);
-}
-
 function connectorLines(name: string, tool: string, input: Record<string, unknown> | undefined): string[] {
   const lines = [`Approval needed: ${tool}`, `Connector: ${name}`];
   const args = Object.entries(input ?? {}).flatMap(([key, value]) => {

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

@@ -34,7 +34,7 @@ export const COMMON_TOOLS: ToolDef[] = [
     group: 'write',
     description:
       'Send a message (and/or media) to a Metro conversation. Args: line, text?, reply_to?, ' +
-      'subject?, attachments?. The station is derived from the line. Outlook and Gmail: send to ' +
+      'subject?, attachments?, frame?. The station is derived from the line. Outlook and Gmail: send to ' +
       'metro://<outlook|gmail>/<account>/<email address> to start a new email (subject defaults to the ' +
       'first line of text); the result names the new thread line. Each attachment names EXACTLY ONE ' +
       'source, and the choice matters: `upload` (an `upload_id` from `create_upload`, the ' +
@@ -42,7 +42,8 @@ export const COMMON_TOOLS: ToolDef[] = [
       '`data` (base64 inline -- TINY FILES ONLY, a few KB, because the base64 has to be ' +
       'written out verbatim in the call and longer than that it corrupts); `url` (the daemon ' +
       'fetches it, so the file must already be public); `path` (resolved on the DAEMON host, ' +
-      'which is not your machine). At least one of text/attachments is required. ' +
+      'which is not your machine). Stage (XMTP) only: `frame` posts an interactive view. At least one ' +
+      'of text/attachments/frame is required. ' +
       'The success line names each attachment the station actually delivered; a station that ' +
       'cannot carry a file errors instead of reporting success.',
     inputSchema: {
@@ -66,6 +67,37 @@ export const COMMON_TOOLS: ToolDef[] = [
           description: 'Optional files to attach.',
           items: attachmentItem,
         },
+        frame: {
+          type: 'object',
+          description:
+            'Stage (XMTP) only: a frame, a small interactive view that Stage shows as a card (title and ' +
+            'description) and opens full screen. `widget` is OpenAI ChatKit widget JSON (a Card, ListView ' +
+            'or Basic root, 64K characters at most); a missing `title` or `description` is taken from the ' +
+            'widget. Or give `screens` instead of `widget` for several screens in one frame. A tap comes back ' +
+            'to you as a reply to the frame: "Frame action: <type> <payload ' +
+            "JSON>\". It is sent after the text, and the message_id returned is the frame's. The stage " +
+            'skill lists the widget nodes, with an example.',
+          properties: {
+            widget: {
+              type: 'object',
+              description:
+                'ChatKit widget JSON, e.g. {"type":"Card","children":[{"type":"Title","value":"Deploy?"},' +
+                '{"type":"Button","label":"Ship it","onClickAction":{"type":"deploy","payload":{"env":"prod"}}}]}.',
+              additionalProperties: true,
+            },
+            screens: {
+              type: 'object',
+              description:
+                'Instead of `widget`: up to 50 screens by id, each a widget or {"title", "widget"}, 64K ' +
+                'characters in all. An action {"type":"frame.open","payload":{"screen":"<id>"}} opens a ' +
+                'screen and {"type":"frame.back"} goes back, in Stage, with no message to you.',
+              additionalProperties: true,
+            },
+            start: { type: 'string', description: 'Required with `screens`: the id of the first screen.' },
+            title: { type: 'string', description: 'Card title in the chat (200 characters at most).' },
+            description: { type: 'string', description: 'Card description in the chat (1000 characters at most).' },
+          },
+        },
       },
       required: ['line'],
     },

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

@@ -31,10 +31,18 @@ const badArgs = (message: string): TrainError =>
 
 async function send(id: string, args: Args): Promise<void> {
   const { line, text } = args as { line: string; text: string };
+  const built = args.frame === undefined ? undefined : buildFrameContent(args.frame);
   const { acct, conv } = await convOf(line);
   if (!conv) throw noConv(line);
-  const messageId = await conv.sendText(text);
-  emitOutbound(acct.cfg.id, line, messageId, text);
+  let messageId: string | undefined;
+  if (text || !built) {
+    messageId = await conv.sendText(text);
+    emitOutbound(acct.cfg.id, line, messageId, text);
+  }
+  if (built) {
+    messageId = await conv.send(new FrameCodec().encode(built.frame));
+    emitOutbound(acct.cfg.id, line, messageId, `Frame: ${built.title}`);
+  }
   respond(id, { result: { messageId } });
 }
 
@@ -49,16 +57,6 @@ async function ask(id: string, args: Args): Promise<void> {
   respond(id, { result: { messageId: sentId, pollId: mintedId } });
 }
 
-async function sendFrame(id: string, args: Args): Promise<void> {
-  const { line } = args as { line: string };
-  const { acct, conv } = await convOf(line);
-  if (!conv) throw noConv(line);
-  const { frame, title } = buildFrameContent(args);
-  const sentId = await conv.send(new FrameCodec().encode(frame));
-  emitOutbound(acct.cfg.id, line, sentId, `Frame: ${title}`);
-  respond(id, { result: { messageId: sentId, title } });
-}
-
 async function referenceInboxOf(conv: Conversation, xmtpMsgId: string): Promise<string> {
   const recent = await conv.messages({ limit: 200, direction: 1 });
   const inbox = recent.find((m) => m.id === xmtpMsgId)?.senderInboxId;
@@ -222,7 +220,6 @@ const handlers: Record<string, (id: string, args: Args) => Promise<void>> = {
   resolve_sender: resolveSenderAction,
   send,
   ask,
-  sendFrame,
   react,
   reply,
   delete: remove,

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

@@ -173,7 +173,9 @@ export const ContentTypeFrame: ContentTypeId = {
 export interface FrameContent {
   title?: string;
   description?: string;
-  widget: Record<string, unknown>;
+  widget?: Record<string, unknown>;
+  screens?: Record<string, unknown>;
+  start?: string;
 }
 export const frameFallback = (c: FrameContent): string => {
   const head = c.title ? `Frame: ${c.title}` : 'Frame';

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

@@ -312,7 +312,6 @@ function frameEnvelope(
     const frame: FrameContent = {
       ...(typeof f.title === 'string' ? { title: f.title } : {}),
       ...(typeof f.description === 'string' ? { description: f.description } : {}),
-      widget: typeof f.widget === 'object' && f.widget !== null ? f.widget : {},
     };
     return { ...base, text: frameFallback(frame), payload: { contentType: typeId, frame: c } };
   }

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

@@ -2,6 +2,9 @@ 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 SUMMARY_SCAN = 80;
@@ -48,37 +51,117 @@ export function frameSummary(widget: Node): { title?: string; description?: stri
 
 function clip(value: unknown, max: number, name: string): string | undefined {
   if (value === undefined) return undefined;
-  if (typeof value !== 'string') throw bad(`send_frame ${name} must be a string`);
+  if (typeof value !== 'string') throw bad(`frame ${name} must be a string`);
   const out = value.trim().slice(0, max);
   return out === '' ? undefined : out;
 }
 
-function parseWidget(raw: unknown): Node {
-  let widget = raw;
-  if (typeof raw === 'string') {
-    try {
-      widget = JSON.parse(raw);
-    } catch {
-      throw bad('send_frame widget is not valid JSON');
-    }
+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('send_frame widget must be a ChatKit widget object with a `type` (Card, ListView or Basic)');
-  const chars = JSON.stringify(widget).length;
-  if (chars > FRAME_MAX_CHARS)
-    throw bad(`send_frame widget is ${chars} characters; the limit is ${FRAME_MAX_CHARS}`);
+    throw bad(`${name} must be a ChatKit widget object with a \`type\` (Card, ListView or Basic)`);
+  checkSize(widget, name);
   return widget;
 }
 
-export function buildFrameContent(args: Record<string, unknown>): { frame: FrameContent; title: string } {
-  const widget = parseWidget(args.widget);
-  const derived = frameSummary(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);
+}
+
+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 } : {}),
-    widget,
+    ...body.content,
   };
   return { frame, title: title ?? 'Frame' };
 }

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

@@ -13,6 +13,7 @@ export const xmtpStation: Station = {
   readsProfiles: true,
   resolvesSenders: true,
   claimsName: true,
+  sendsFrames: true,
   sendAttachments: xmtpSendAttachments,
   tools: XMTP_TOOLS,
 };

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

@@ -79,46 +79,6 @@ export const XMTP_TOOLS: StationTool[] = [
       return ctx.okJson(await ctx.call('ask', args));
     },
   },
-  {
-    name: 'send_frame',
-    group: 'write',
-    description:
-      'Post a frame in a Stage conversation: a small interactive view described in OpenAI ChatKit ' +
-      'widget JSON (the same nodes and props as ChatKit: a Card, ListView or Basic root with Row, Col, ' +
-      'Box, Text, Title, Caption, Markdown, Badge, Icon, Image, Button, Divider, Spacer, Form, Input, ' +
-      'Textarea, Select, DatePicker, Checkbox, RadioGroup, Table...). Stage shows it in the chat as a card ' +
-      '(title and description) that opens full screen. A tap on a Button onClickAction, a ListViewItem ' +
-      'onClickAction, a Card confirm/cancel or a Form submit comes back to you as a reply to the frame: ' +
-      '"Frame action: <type> <payload JSON>", with the values of the form fields added to the payload by ' +
-      'name. Images must be https. Args: line (required), widget (required, the ChatKit widget object, at ' +
-      'most 64K characters of JSON), title? and description? (shown on the card; taken from the first ' +
-      'Title and text in the widget when missing). xmtp-only. Returns the frame messageId.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        line: lineProp,
-        widget: {
-          type: 'object',
-          description:
-            'ChatKit widget JSON, e.g. {"type":"Card","children":[{"type":"Title","value":"Deploy?"},' +
-            '{"type":"Button","label":"Ship it","onClickAction":{"type":"deploy","payload":{"env":"prod"}}}]}.',
-          additionalProperties: true,
-        },
-        title: { type: 'string', description: 'Card title in the chat (200 characters at most).' },
-        description: { type: 'string', description: 'Card description in the chat (1000 characters at most).' },
-      },
-      required: ['line', 'widget'],
-    },
-    async handle(a, ctx) {
-      const line = str(a.line);
-      if (!line) return ctx.err('send_frame requires `line`');
-      if (a.widget === undefined) return ctx.err('send_frame requires `widget`');
-      const args: Record<string, unknown> = { line, widget: a.widget };
-      if (a.title !== undefined) args.title = a.title;
-      if (a.description !== undefined) args.description = a.description;
-      return ctx.okJson(await ctx.call('sendFrame', args));
-    },
-  },
   {
     name: 'dm',
     group: 'write',

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.232"
+  "version": "0.1.0-beta.234"
 }