@stage-labs/metro 0.1.0-beta.26 → 0.1.0-beta.261

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

@@ -1,27 +1,30 @@
-import { ReactionAction, ReactionSchema } from '@xmtp/node-sdk';
+import {
+  GroupMessageKind,
+  ReactionAction,
+  ReactionSchema,
+  type Conversation,
+} from '@xmtp/node-sdk';
 import type { Reply } from '@xmtp/node-bindings';
 import {
   AttachmentCodec,
   type Attachment,
 } from '@xmtp/content-type-remote-attachment';
-import {
-  WalletSendCallsCodec,
-  type WalletSendCallsParams,
-} from '@xmtp/content-type-wallet-send-calls';
-import { toHex } from 'viem';
-import { convOf } from './accounts.js';
-import { resolveMsgId, respond } from './wire.js';
+import type { EncodedContent } from '@xmtp/content-type-primitives';
+import { convOf, type Account } from './accounts.js';
+import { resolveMsgId } from './wire.js';
 import { emitOutbound } from './emit.js';
-import {
-  PollCodec,
-  buildPollContent,
-  SignatureRequestCodec,
-  type SignatureRequestContent,
-} from './codecs.js';
+import { CallSignalCodec, FrameCodec, PollCodec, buildPollContent, encodeDeleteMessage } from './codecs.js';
+import { buildFrameContent } from './frames.js';
+import { buildWalletContent } from './wallet.js';
+import { network } from './network.js';
+import { callLeftovers } from './call-leftovers.js';
 import { convHandlers } from './actions-conv.js';
-import { normalizeXmtp } from '@metro-labs/mcp/stations/messaging-normalize';
-import { TrainError } from '@metro-labs/mcp/train-error';
-import { makeStation, type CallMsg } from '@metro-labs/mcp/stations/station-runtime';
+import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
+import { TrainError } from '@metro-labs/core/train-error';
+import { claimNameAction, nameAction, setProfile } from './profile.js';
+import { profileAction } from './sender.js';
+import { resolveSenderAction } from './resolve.js';
+import { makeStation, respond, type CallMsg } from '@metro-labs/core/stations/station-runtime';
 
 type Args = Record<string, unknown>;
 
@@ -30,78 +33,73 @@ const noConv = (line: string): TrainError =>
 const badArgs = (message: string): TrainError =>
   new TrainError('INVALID_ARGS', message);
 
+function framePart(raw: unknown): { encoded: EncodedContent; summary: string } {
+  const built = buildFrameContent(raw);
+  return { encoded: new FrameCodec().encode(built.frame), summary: `Frame: ${built.title}` };
+}
+
 async function send(id: string, args: Args): Promise<void> {
   const { line, text } = args as { line: string; text: string };
+  const parts = [
+    ...(args.frame === undefined ? [] : [framePart(args.frame)]),
+    ...(args.wallet === undefined ? [] : [buildWalletContent(args.wallet)]),
+  ];
   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 || parts.length === 0) {
+    messageId = await conv.sendText(text);
+    emitOutbound(acct.cfg.id, line, messageId, text);
+  }
+  for (const part of parts) {
+    messageId = await conv.send(part.encoded);
+    emitOutbound(acct.cfg.id, line, messageId, part.summary);
+  }
   respond(id, { result: { messageId } });
 }
 
 async function ask(id: string, args: Args): Promise<void> {
-  const { line, pollId } = args as { line: string; pollId?: string };
+  const { line } = args as { line: string };
   const { acct, conv } = await convOf(line);
   if (!conv) throw noConv(line);
-  const fallbackId = `poll_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-  const mintedId =
-    pollId ??
-    (typeof crypto?.randomUUID === 'function'
-      ? crypto.randomUUID()
-      : fallbackId);
+  const mintedId = crypto.randomUUID();
   const { poll, title } = buildPollContent(args, mintedId);
   const sentId = await conv.send(new PollCodec().encode(poll));
   emitOutbound(acct.cfg.id, line, sentId, `📊 Poll: ${title}`);
   respond(id, { result: { messageId: sentId, pollId: mintedId } });
 }
 
+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;
+  if (!inbox)
+    throw new TrainError('NOT_FOUND', `could not resolve referenceInboxId for ${xmtpMsgId}`);
+  return inbox;
+}
+
 async function react(id: string, args: Args): Promise<void> {
-  const {
-    line,
-    messageId,
-    emoji,
-    action: reactAction,
-    schema: reactSchema,
-  } = args as {
+  const { line, messageId, emoji, action: reactAction } = args as {
     line: string;
     messageId: string;
     emoji: string;
     action?: 'added' | 'removed';
-    schema?: string;
-    referenceInboxId?: string;
   };
   const { acct, conv } = await convOf(line);
   if (!conv) throw noConv(line);
   const xmtpMsgId = resolveMsgId(messageId);
-  let refInbox = (args as { referenceInboxId?: string }).referenceInboxId;
-  if (!refInbox) {
-    const recent = await conv.messages({ limit: 200, direction: 1 });
-    refInbox = recent.find((m) => m.id === xmtpMsgId)?.senderInboxId;
-    if (!refInbox)
-      throw new TrainError(
-        'NOT_FOUND',
-        `could not resolve referenceInboxId for ${xmtpMsgId}`,
-      );
-  }
-  const schemaEnum =
-    reactSchema === 'custom'
-      ? ReactionSchema.Custom
-      : reactSchema === 'shortcode'
-        ? ReactionSchema.Shortcode
-        : ReactionSchema.Unicode;
+  const removed = reactAction === 'removed';
   const sentId = await conv.sendReaction({
     reference: xmtpMsgId,
-    referenceInboxId: refInbox,
-    action:
-      reactAction === 'removed' ? ReactionAction.Removed : ReactionAction.Added,
+    referenceInboxId: await referenceInboxOf(conv, xmtpMsgId),
+    action: removed ? ReactionAction.Removed : ReactionAction.Added,
     content: emoji,
-    schema: schemaEnum,
+    schema: ReactionSchema.Unicode,
   });
   emitOutbound(
     acct.cfg.id,
     line,
     sentId,
-    `[react ${emoji}${reactAction === 'removed' ? ' (removed)' : ''}]`,
+    `[react ${emoji}${removed ? ' (removed)' : ''}]`,
     { type: 'react', emoji, targetId: xmtpMsgId },
   );
   respond(id, { result: { messageId: sentId } });
@@ -134,6 +132,37 @@ async function reply(id: string, args: Args): Promise<void> {
   respond(id, { result: { messageId: sentId } });
 }
 
+const UNDELETABLE = new Set(['deleteMessage', 'deletedMessage']);
+
+function assertDeletable(acct: Account, conv: Conversation, messageId: string): void {
+  const msg = acct.client.conversations.getMessageById(messageId);
+  if (msg?.conversationId !== conv.id)
+    throw new TrainError('NOT_FOUND', `message ${messageId} is not in this conversation`);
+  if (msg.senderInboxId !== acct.inboxId)
+    throw badArgs(`message ${messageId} was not sent by this account; only your own messages can be deleted`);
+  if (msg.kind !== GroupMessageKind.Application || UNDELETABLE.has(msg.contentType?.typeId ?? ''))
+    throw badArgs(`message ${messageId} cannot be deleted`);
+}
+
+async function remove(id: string, args: Args): Promise<void> {
+  const { line, messageId } = args as { line: string; messageId: string };
+  const { acct, conv } = await convOf(line);
+  if (!conv) throw noConv(line);
+  const target = resolveMsgId(messageId);
+  assertDeletable(acct, conv, target);
+  const sentId = await conv.send(encodeDeleteMessage(target), { shouldPush: false });
+  respond(id, { result: { messageId: sentId } });
+}
+
+async function callSignal(id: string, args: Args): Promise<void> {
+  const { line, signal } = args as { line: string; signal?: unknown };
+  if (typeof signal !== 'object' || signal === null) throw badArgs('callSignal requires a signal object');
+  const { conv } = await convOf(line);
+  if (!conv) throw noConv(line);
+  const messageId = await conv.send(new CallSignalCodec().encode(signal as Record<string, unknown>), { shouldPush: false });
+  respond(id, { result: { messageId } });
+}
+
 async function sendAttachment(id: string, args: Args): Promise<void> {
   const { line, name, mime, dataB64 } = args as {
     line: string;
@@ -159,175 +188,34 @@ const IMG_MIME_BY_EXT: Record<string, string> = {
   webp: 'image/webp',
 };
 
-async function loadImageBytes(
-  path: string | undefined,
-  dataB64: string | undefined,
-): Promise<Uint8Array> {
-  if (path) {
-    const { readFileSync } = await import('node:fs');
-    return new Uint8Array(readFileSync(path));
-  }
-  if (dataB64) return new Uint8Array(Buffer.from(dataB64, 'base64'));
-  throw badArgs('sendImage requires path or dataB64');
-}
-
-function imageMime(
-  mimeType: string | undefined,
-  filename: string | undefined,
-  path: string | undefined,
-): string {
-  if (mimeType) return mimeType;
-  const ext = (filename ?? path ?? '').toLowerCase().split('.').pop() ?? '';
+function imageMime(path: string): string {
+  const ext = path.toLowerCase().split('.').pop() ?? '';
   return IMG_MIME_BY_EXT[ext] ?? 'image/png';
 }
 
-function imageFilename(
-  filename: string | undefined,
-  path: string | undefined,
-): string {
-  if (filename) return filename;
-  const baseName = path ? path.split('/').pop() : undefined;
+function imageFilename(path: string): string {
+  const baseName = path.split('/').pop();
   return baseName != null && baseName !== '' ? baseName : 'image.png';
 }
 
 async function sendImage(id: string, args: Args): Promise<void> {
-  const { line, path, dataB64, filename, mimeType } = args as {
-    line: string;
-    path?: string;
-    dataB64?: string;
-    filename?: string;
-    mimeType?: string;
-  };
+  const { line, path } = args as { line: string; path?: string };
+  if (!path) throw badArgs('sendImage requires path');
   const { acct, conv } = await convOf(line);
   if (!conv) throw noConv(line);
-  const bytes = await loadImageBytes(path, dataB64);
-  const mime = imageMime(mimeType, filename, path);
-  const fname = imageFilename(filename, path);
+  const { readFileSync } = await import('node:fs');
+  const mime = imageMime(path);
+  const fname = imageFilename(path);
   const attachment: Attachment = {
     filename: fname,
     mimeType: mime,
-    data: bytes,
+    data: new Uint8Array(readFileSync(path)),
   };
   const sentId = await conv.send(new AttachmentCodec().encode(attachment));
   emitOutbound(acct.cfg.id, line, sentId, `[${mime.split('/')[0]}: ${fname}]`);
   respond(id, { result: { messageId: sentId } });
 }
 
-interface TxRequestArgs {
-  to: string;
-  amountEth?: number;
-  data?: string;
-  note?: string;
-  chainId?: number;
-}
-
-function validateTxAmount(amountEth: number | undefined, hasData: boolean): void {
-  if (!hasData && (typeof amountEth !== 'number' || !(amountEth > 0))) {
-    throw badArgs(
-      'sendTxRequest requires a positive `amountEth` (or `data` for a contract call)',
-    );
-  }
-  if (amountEth != null && (typeof amountEth !== 'number' || amountEth < 0)) {
-    throw badArgs('sendTxRequest `amountEth` must be a non-negative number');
-  }
-}
-
-function validateTxRequest(a: TxRequestArgs): boolean {
-  const { to, amountEth, data } = a;
-  if (!to || typeof to !== 'string' || !/^0x[0-9a-fA-F]{40}$/.test(to)) {
-    throw badArgs('sendTxRequest requires a valid 0x `to` address');
-  }
-  const hasData = data != null;
-  if (
-    hasData &&
-    (typeof data !== 'string' || !/^0x([0-9a-fA-F]{2})*$/.test(data))
-  ) {
-    throw badArgs('sendTxRequest `data` must be 0x-prefixed hex calldata');
-  }
-  validateTxAmount(amountEth, hasData);
-  return hasData;
-}
-
-function buildTxContent(
-  a: TxRequestArgs,
-  from: string,
-  hasData: boolean,
-): WalletSendCallsParams {
-  const { to, amountEth, data, note, chainId } = a;
-  const weiHex = amountEth
-    ? '0x' + BigInt(Math.round(amountEth * 1e18)).toString(16)
-    : '0x0';
-  return {
-    version: '1.0',
-    chainId: toHex(chainId ?? 1),
-    from: from as `0x${string}`,
-    calls: [
-      {
-        to: to as `0x${string}`,
-        value: weiHex as `0x${string}`,
-        ...(hasData ? { data: data as `0x${string}` } : {}),
-        metadata: {
-          description: note ?? (hasData ? 'Contract call' : 'Payment request'),
-          transactionType: 'transfer',
-        },
-      },
-    ],
-  };
-}
-
-function txRequestLabel(a: TxRequestArgs, hasData: boolean): string {
-  const { amountEth, note } = a;
-  return hasData
-    ? `📝 ${note ?? 'Contract call'}${amountEth ? ` (${amountEth} ETH)` : ''}`
-    : `💸 ${note ?? 'Payment request'} (${amountEth} ETH)`;
-}
-
-async function sendTxRequest(id: string, args: Args): Promise<void> {
-  const { line } = args as { line: string };
-  const txArgs = args as Args & TxRequestArgs;
-  const { acct, conv } = await convOf(line);
-  if (!conv) throw noConv(line);
-  const hasData = validateTxRequest(txArgs);
-  const content = buildTxContent(txArgs, acct.address, hasData);
-  const sentId = await conv.send(new WalletSendCallsCodec().encode(content));
-  emitOutbound(acct.cfg.id, line, sentId, txRequestLabel(txArgs, hasData));
-  respond(id, { result: { messageId: sentId } });
-}
-
-async function sendSignatureRequest(id: string, args: Args): Promise<void> {
-  const { line, kind, eip712, message, description } = args as {
-    line: string;
-    kind?: 'eip712' | 'personal';
-    eip712?: unknown;
-    message?: string;
-    description?: string;
-  };
-  const { acct, conv } = await convOf(line);
-  if (!conv) throw noConv(line);
-  const k: 'eip712' | 'personal' = kind === 'eip712' ? 'eip712' : 'personal';
-  if (k === 'eip712' && !eip712)
-    throw badArgs(
-      'sendSignatureRequest eip712 requires an `eip712` typed-data object',
-    );
-  if (k === 'personal' && (!message || typeof message !== 'string')) {
-    throw badArgs('sendSignatureRequest personal requires a `message` string');
-  }
-  const content: SignatureRequestContent = {
-    id: 'sig_' + Date.now().toString(36),
-    kind: k,
-    ...(k === 'eip712' ? { eip712 } : { message }),
-    description,
-  };
-  const sentId = await conv.send(new SignatureRequestCodec().encode(content));
-  emitOutbound(
-    acct.cfg.id,
-    line,
-    sentId,
-    `✍️ ${description ?? 'Signature request'}`,
-  );
-  respond(id, { result: { messageId: sentId } });
-}
-
 async function accountsAction(id: string): Promise<void> {
   const { accounts } = await import('./accounts.js');
   respond(id, {
@@ -335,41 +223,42 @@ async function accountsAction(id: string): Promise<void> {
       accounts: [...accounts.values()].map((a) => ({
         id: a.cfg.id,
         handle: a.address,
-        url: `https://etherscan.io/address/${a.address}`,
+        url: `https://stage.box/#/${a.address}`,
         address: a.address,
         inboxId: a.inboxId,
-        env: 'production',
-        owner: a.cfg.owner ?? null,
-        keySource: 'privateKey',
+        smart: a.smart !== null,
       })),
     },
   });
 }
 
-function unsupportedVerb(id: string, verb: string): Promise<void> {
-  respond(id, { error: `unsupported verb '${verb}' on xmtp` });
-  return Promise.resolve();
-}
-
 const handlers: Record<string, (id: string, args: Args) => Promise<void>> = {
   accounts: (id) => accountsAction(id),
+  set_profile: setProfile,
+  claim_name: claimNameAction,
+  name: nameAction,
+  profile: profileAction,
+  resolve_sender: resolveSenderAction,
   send,
   ask,
-  sendPoll: ask,
   react,
   reply,
+  delete: remove,
+  callSignal,
+  callLeftovers: (id) => callLeftovers(id),
   sendAttachment,
   sendImage,
-  sendTxRequest,
-  sendSignatureRequest,
-  edit: (id) => unsupportedVerb(id, 'edit'),
-  delete: (id) => unsupportedVerb(id, 'delete'),
   ...convHandlers,
 };
 
 export type { CallMsg };
 
 export const handleCall = makeStation({
-  handlers,
-  normalize: normalizeXmtp,
+  handlers: Object.fromEntries(Object.entries(handlers).map(([action, handler]) => [
+    action,
+    action === 'accounts' || action === 'callLeftovers'
+      ? handler
+      : (id: string, args: Args) => network.run(() => handler(id, args)),
+  ])),
+  normalize: messagingAliases({ action: 'removed' }),
 });

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

@@ -6,9 +6,9 @@ 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 };
 

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/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,116 @@ 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;
+}
+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(),
 ];