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

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

@@ -0,0 +1,66 @@
+import { errMsg } from '@metro-labs/core/log';
+import { ConsentState } from '@xmtp/node-sdk';
+import { network, type NetworkBackoff } from './network.js';
+
+interface StreamOptions<T> {
+  consentStates: ConsentState[];
+  retryOnFail: false;
+  onError: (error: Error) => void;
+  onValue: (message: T) => void;
+}
+
+interface StreamSource<T> {
+  streamAllMessages: (options: StreamOptions<T>) => Promise<AsyncIterable<T>>;
+}
+
+interface StreamRuntime {
+  backoff: NetworkBackoff;
+  now: () => number;
+  wait: (ms: number) => Promise<void>;
+  report: (message: string) => void;
+}
+
+const defaultRuntime: StreamRuntime = {
+  backoff: network,
+  now: Date.now,
+  wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  report: (message) => { process.stderr.write(`xmtp: ${message}\n`); },
+};
+
+export async function streamMessages<T>(
+  source: StreamSource<T>,
+  handle: (message: T) => Promise<void>,
+  runtime: StreamRuntime = defaultRuntime,
+): Promise<never> {
+  let delay = 5000;
+  for (;;) {
+    const started = runtime.now();
+    let delivery = Promise.resolve();
+    try {
+      const stream = await runtime.backoff.run(() => source.streamAllMessages({
+        consentStates: [ConsentState.Allowed, ConsentState.Unknown],
+        retryOnFail: false,
+        onValue: (message) => {
+          delivery = delivery.then(() => handle(message)).catch((error: unknown) => {
+            runtime.report(`message handler failed: ${errMsg(error)}`);
+          });
+        },
+        onError: (error) => {
+          runtime.backoff.note(error);
+          runtime.report(`stream error: ${errMsg(error)}`);
+        },
+      }));
+      const iterator = stream[Symbol.asyncIterator]();
+      while (!(await iterator.next()).done) await delivery;
+    } catch (error) {
+      runtime.backoff.note(error);
+      runtime.report(`stream error: ${errMsg(error)}`);
+    }
+    await delivery;
+    if (runtime.now() - started >= 60_000) delay = 5000;
+    const wait = Math.max(delay, runtime.backoff.remaining());
+    runtime.report(`stream ended; retry in ${Math.ceil(wait / 1000)}s`);
+    await runtime.wait(wait);
+    delay = Math.min(delay * 2, 300_000);
+  }
+}

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

@@ -1,59 +1,29 @@
-import type { CanonicalAttachment, ToolContext } from '@metro-labs/mcp/stations/types';
-import { TrainError } from '@metro-labs/mcp/train-error';
+import type { CanonicalAttachment, ToolContext } from '@metro-labs/core/stations/types';
+import { TrainError } from '@metro-labs/core/train-error';
+import { metadataPatch, mergeAppData } from './labels.js';
 import {
   guessMime,
   isImageMime,
   isImageExt,
   kindOf,
-} from '@metro-labs/mcp/stations/attachments';
+} from '@metro-labs/core/stations/attachments';
 
 export const str = (v: unknown): string => (typeof v === 'string' ? v : '');
 
-function strList(value: unknown): string[] {
-  return (value as unknown[] | undefined)?.map(String).filter(Boolean) ?? [];
-}
-
-interface CreatedGroup {
-  line?: string;
-  id?: string;
-  account?: string;
-}
-
-async function applyCreateLabels(
-  line: string,
-  labels: string[],
-  ctx: ToolContext,
-): Promise<unknown> {
-  if (!labels.length) return undefined;
-  return ctx.call('updateChannelMeta', { line, appData: { labels } });
-}
-
-export async function createChannel(
-  a: Record<string, unknown>,
-  ctx: ToolContext,
-) {
-  const addresses = strList(a.addresses);
-  const channelName = str(a.name);
-  const labels = strList(a.labels);
-  const account = str(a.account) || undefined;
-  if (!addresses.length)
-    return ctx.err('create_channel requires a non-empty `addresses` array');
-  if (!channelName) return ctx.err('create_channel requires `name`');
-  const groupArgs: Record<string, unknown> = { addresses, name: channelName };
-  if (account) groupArgs.account = account;
-  const { result } = (await ctx.call('newGroup', groupArgs)) as {
-    result: CreatedGroup | null;
-  };
-  const newLine = result?.line ?? '';
-  const labelResult = newLine.length
-    ? await applyCreateLabels(newLine, labels, ctx)
-    : undefined;
-  return ctx.okJson({
-    line: newLine,
-    convId: result?.id,
-    account: result?.account,
-    labels: labelResult,
-  });
+function channelAppData(a: Record<string, unknown>): Record<string, unknown> {
+  const appData = a.metadata === undefined ? {} : { ...metadataPatch(a.metadata) };
+  if (Object.hasOwn(appData, 'description')) {
+    throw new TrainError('INVALID_ARGS', 'Use top-level description for the native XMTP group description, not metadata.description');
+  }
+  for (const key of ['labels', 'github', 'preview']) {
+    if (!Object.hasOwn(a, key)) continue;
+    if (Object.hasOwn(appData, key)) {
+      throw new TrainError('INVALID_ARGS', `Specify ${key} only once, inside metadata or at the top level`);
+    }
+    appData[key] = a[key];
+  }
+  mergeAppData(undefined, appData);
+  return appData;
 }
 
 export async function setChannelMetadata(
@@ -62,21 +32,23 @@ export async function setChannelMetadata(
 ) {
   const line = str(a.line);
   if (!line) return ctx.err('set_channel_metadata requires `line`');
-  const labels = a.labels as unknown[] | undefined;
-  const github = a.github as string | undefined;
-  const preview = a.preview as string | undefined;
-  const metaName = a.name as string | undefined;
-  const appData: Record<string, unknown> = {};
-  if (Array.isArray(labels)) appData.labels = labels.map(String);
-  if (typeof github === 'string') appData.github = github;
-  if (typeof preview === 'string') appData.preview = preview;
+  const invalidField = ['name', 'description'].find(
+    (field) => Object.hasOwn(a, field) && typeof a[field] !== 'string',
+  );
+  if (invalidField) return ctx.err(`set_channel_metadata ${invalidField} must be a string`);
+  const appData = channelAppData(a);
+  const metaName = a.name;
   const hasName = typeof metaName === 'string' && metaName.length > 0;
-  if (!hasName && Object.keys(appData).length === 0)
+  const hasDescription = typeof a.description === 'string';
+  const hasAppData = Object.keys(appData).length > 0;
+  if (!hasName && !hasDescription && !hasAppData)
     return ctx.err(
-      'set_channel_metadata requires at least one of `labels`, `github`, `preview`, `name`',
+      'set_channel_metadata requires at least one of `metadata`, `github`, `preview`, `name`, `description`, `labels`',
     );
-  const callArgs: Record<string, unknown> = { line, appData };
+  const callArgs: Record<string, unknown> = { line };
+  if (hasAppData) callArgs.appData = appData;
   if (hasName) callArgs.name = metaName;
+  if (hasDescription) callArgs.description = a.description;
   return ctx.okJson(await ctx.call('updateChannelMeta', callArgs));
 }
 
@@ -112,7 +84,7 @@ export async function xmtpSendAttachments(
 ): Promise<string[]> {
   const sent: string[] = [];
   for (const a of atts) {
-    const src = a.path ?? a.url ?? '';
+    const src = a.path ?? '';
     if (!src) continue;
     const mime = a.mime ?? guessMime(src);
     if (isImageMime(mime) || isImageExt(src)) {

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

@@ -1,7 +1,7 @@
-import type { StationTool } from '@metro-labs/mcp/stations/types';
+import type { StationTool } from '@metro-labs/core/stations/types';
+import { PRIORITIES } from './labels.js';
 import {
   str,
-  createChannel,
   setChannelMetadata,
   xmtpSendAttachments,
 } from './tools-handlers.js';
@@ -15,43 +15,9 @@ const lineProp = {
 } as const;
 
 export const XMTP_TOOLS: StationTool[] = [
-  {
-    name: 'create_channel',
-    description:
-      'Create a new XMTP group conversation (channel). Args: addresses (required, array of ' +
-      'Ethereum 0x addresses to add as members), name (required, the group name), labels? ' +
-      '(optional string[] status labels applied after creation), account? ' +
-      '(defaults to your only XMTP account). Calls the daemon xmtp `newGroup`, then ' +
-      '`updateChannelMeta` if labels ' +
-      'are given. Returns the new metro:// line and convId. This is an xmtp-only operation. ' +
-      'NOTE: there is no add-members verb on the daemon, so members must be supplied at ' +
-      'creation time.',
-    inputSchema: {
-      type: 'object',
-      properties: {
-        addresses: {
-          type: 'array',
-          description: 'Ethereum 0x addresses to add as group members.',
-          items: { type: 'string' },
-        },
-        name: { type: 'string', description: 'The group/channel name.' },
-        labels: {
-          type: 'array',
-          description: 'Optional status labels to apply after creation.',
-          items: { type: 'string' },
-        },
-        account: {
-          type: 'string',
-          description:
-            'XMTP account to create under. Omit when you have only one.',
-        },
-      },
-      required: ['addresses', 'name'],
-    },
-    handle: (a, ctx) => createChannel(a, ctx),
-  },
   {
     name: 'ask',
+    group: 'write',
     description:
       'Ask a question as a poll in an XMTP conversation (mirrors Claude AskUserQuestion). ' +
       'Single-question form: question (required), options? (string[]), header?, multiSelect?, ' +
@@ -116,11 +82,12 @@ export const XMTP_TOOLS: StationTool[] = [
   },
   {
     name: 'dm',
+    group: 'write',
     description:
       'Open (or reuse) a 1:1 XMTP DM with an Ethereum address. Args: address (required, 0x...), ' +
       'account? (defaults to your only XMTP account). Returns the new metro:// line and ' +
       'convId. xmtp-only ' +
-      '(daemon `newDm`). Use this instead of create_channel when there is a single recipient.',
+      '(daemon `newDm`). For a group, use create_group.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -145,10 +112,13 @@ export const XMTP_TOOLS: StationTool[] = [
   },
   {
     name: 'group_info',
+    group: 'read',
     description:
       "Read an XMTP channel's current metadata + membership. Args: line (required). Returns " +
-      '{line, id, account, version (dm|group), name, memberCount, labels, github, preview, ' +
-      'members:[{inboxId, address}]}. xmtp-only (daemon `groupInfo`). Use before ' +
+      '{line, id, account, version (dm|group), name, description (native XMTP group description, empty for DMs), memberCount, labels, category, status, priority, github, preview, ' +
+      'assigned, appData (stored JSON object), rawAppData (stored JSON string), ' +
+      'members:[{inboxId, address}]}. Syncs first and fails if metadata cannot be read. ' +
+      'xmtp-only (daemon `groupInfo`). Use before ' +
       'set_channel_metadata/add_members to see current state.',
     inputSchema: {
       type: 'object',
@@ -163,35 +133,90 @@ export const XMTP_TOOLS: StationTool[] = [
   },
   {
     name: 'close_channel',
+    group: 'write',
+    destructive: true,
     description:
-      'Archive/close an XMTP group (removes members). Args: line (required). xmtp-only ' +
-      '(daemon `closeGroup`). Irreversible-ish: members are removed from the group.',
+      'Remove members from an XMTP group, and optionally leave it. Args: line (required), ' +
+      'removeInboxIds? (inbox ids to remove; your own is ignored here), removeSelf? (true to ' +
+      'leave the group yourself). With neither, nothing changes. xmtp-only (daemon ' +
+      '`closeGroup`). Returns {removed, leftSelf}.',
     inputSchema: {
       type: 'object',
-      properties: { line: lineProp },
+      properties: {
+        line: lineProp,
+        removeInboxIds: {
+          type: 'array',
+          description: 'Inbox ids of the members to remove.',
+          items: { type: 'string' },
+        },
+        removeSelf: {
+          type: 'boolean',
+          description: 'Leave the group after removing the others.',
+        },
+      },
       required: ['line'],
     },
     async handle(a, ctx) {
       const line = str(a.line);
       if (!line) return ctx.err('close_channel requires `line`');
-      return ctx.okJson(await ctx.call('closeGroup', { line }));
+      const args: Record<string, unknown> = { line };
+      if (Array.isArray(a.removeInboxIds)) args.removeInboxIds = a.removeInboxIds.map(String);
+      if (a.removeSelf === true) args.removeSelf = true;
+      return ctx.okJson(await ctx.call('closeGroup', args));
     },
   },
   {
     name: 'set_channel_metadata',
+    group: 'write',
     description:
       "Update an existing channel's metadata. Args: line (required, the metro:// line), and " +
-      'any of labels? (string[]), github? (url), preview? (url), name? (string). All provided ' +
-      'fields are applied together in one atomic updateChannelMeta daemon call (a single ' +
-      'appData merge plus name update). xmtp-only ' +
-      '(channel metadata lives on xmtp groups). Returns the updated channel info.',
+      'any of metadata? (JSON object), github? (url), preview? (url), name? (string), description? (string). ' +
+      'Top-level description updates the standard XMTP group description shown in Stage; "" clears it. ' +
+      'Use group_info.description for native readback. metadata.description is refused; it is not the visible description. ' +
+      'metadata is a shallow appData patch: omitted keys are preserved, supplied nested ' +
+      'values replace that key, and null deletes custom keys. v is reserved. Put labels, ' +
+      'assigned, category, status and priority inside metadata. assigned replaces the array with normalized lowercase ' +
+      'Ethereum addresses of current members. Read group_info and union existing IDs to ' +
+      'add assignees. category and status are each one free-form string per channel, trimmed, ' +
+      'whitespace collapsed and truncated to 24 characters. priority is trimmed and must be Urgent, High, Medium or Low. ' +
+      '"" or null clears category, status or priority. labels remains a legacy top-level alias. Duplicate top-level/metadata ' +
+      'label/link aliases are refused. All fields use one updateChannelMeta call. xmtp-only. ' +
+      'Returns updated metadata. Reread group_info to verify persistence.',
     inputSchema: {
       type: 'object',
       properties: {
         line: lineProp,
+        metadata: {
+          type: 'object',
+          description: 'Shallow JSON appData patch. Omitted keys stay unchanged. v is reserved.',
+          properties: {
+            labels: { type: 'array', items: { type: 'string' } },
+            assigned: {
+              type: 'array',
+              description: 'Replacement assignee list. Current member Ethereum addresses only. [] clears.',
+              items: { type: 'string', pattern: '^0x[0-9a-fA-F]{40}$' },
+            },
+            category: {
+              type: ['string', 'null'],
+              description: 'One free-form category, trimmed, whitespace collapsed, truncated to 24 characters. "" or null clears it.',
+            },
+            status: {
+              type: ['string', 'null'],
+              description: 'One free-form status, trimmed, whitespace collapsed, truncated to 24 characters. "" or null clears it.',
+            },
+            priority: {
+              type: ['string', 'null'],
+              enum: [...PRIORITIES, '', null],
+              description: 'One priority: Urgent, High, Medium or Low. Surrounding whitespace is trimmed; empty or null clears it.',
+            },
+            github: { type: 'string' },
+            preview: { type: 'string' },
+          },
+          additionalProperties: true,
+        },
         labels: {
           type: 'array',
-          description: 'Status labels to set.',
+          description: 'Legacy alias. Prefer metadata.labels.',
           items: { type: 'string' },
         },
         github: {
@@ -203,6 +228,10 @@ export const XMTP_TOOLS: StationTool[] = [
           description: 'Linked preview URL ("" to clear).',
         },
         name: { type: 'string', description: 'New channel name.' },
+        description: {
+          type: 'string',
+          description: 'Standard XMTP group description shown in Stage. "" clears it. Omit to preserve it; never put it inside metadata.',
+        },
       },
       required: ['line'],
     },

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

@@ -1,7 +1,6 @@
-import { errMsg } from '@metro-labs/mcp/log';
-import { mintId, SELF_URI } from './wire.js';
-
-type EmitInbound = (accountId: string, e: Record<string, unknown>) => void;
+import { errMsg } from '@metro-labs/core/log';
+import { emitInbound, selfUri } from '@metro-labs/core/stations/train-events';
+import { mintId } from '@metro-labs/core/stations/station-runtime';
 
 const WHISPER_BIN = process.env.METRO_WHISPER_BIN ?? 'whisper-cli';
 const WHISPER_MODEL =
@@ -14,7 +13,6 @@ export async function transcribeAndEmit(
   line: string,
   accountId: string,
   sourceMsgId: string,
-  emitInbound: EmitInbound,
 ): Promise<void> {
   const {
     existsSync: ex,
@@ -69,7 +67,7 @@ export async function transcribeAndEmit(
       ts: new Date().toISOString(),
       station: 'xmtp',
       line,
-      from: SELF_URI,
+      from: selfUri(),
       text: `🎙️ ${text}`,
       payload: {
         contentType: 'transcript',

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

@@ -1,7 +1,8 @@
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { Client, type ClientOptions, type Signer } from '@xmtp/node-sdk';
-import { expandHome, signerFor, XMTP_ENV } from './identity.js';
+import { expandHome, identityFor, signerFor, XMTP_ENV } from './identity.js';
+import { ensureDeployed } from './smart.js';
 
 export class XmtpVerifyError extends Error {}
 
@@ -10,6 +11,7 @@ export interface XmtpVerified {
   address: string;
   installationId: string;
   dbPath: string;
+  smart: boolean;
 }
 
 interface RegisteredClient {
@@ -34,15 +36,25 @@ const reason = (err: unknown): string =>
 export async function verifyXmtpKey(
   privateKey: string,
   dbPath: string,
+  smart = false,
   create: CreateXmtpClient = openInbox,
 ): Promise<XmtpVerified> {
-  let signer: Signer;
-  let address: string;
+  let identity: Awaited<ReturnType<typeof identityFor>>;
   try {
-    ({ signer, address } = signerFor(privateKey));
+    signerFor(privateKey);
   } catch {
     throw new XmtpVerifyError('that is not a usable XMTP private key');
   }
+  try {
+    identity = await identityFor(privateKey, smart);
+  } catch (err) {
+    throw new XmtpVerifyError(`could not build the smart account on Base: ${reason(err)}`);
+  }
+  const { signer, address } = identity;
+  if (identity.smart !== null)
+    await ensureDeployed(identity.smart).catch((err: unknown) => {
+      throw new XmtpVerifyError(`could not deploy the smart account on Base (is the ZeroDev sponsorship still on?): ${reason(err)}`);
+    });
   const resolved = expandHome(dbPath);
   mkdirSync(dirname(resolved), { recursive: true });
   const client = await create(signer, resolved).catch((err: unknown) => {
@@ -59,6 +71,7 @@ export async function verifyXmtpKey(
     address,
     installationId: client.installationId,
     dbPath: resolved,
+    smart,
   };
 }
 
@@ -68,10 +81,11 @@ async function runCli(): Promise<void> {
     const input = JSON.parse(readFileSync(0, 'utf8')) as {
       privateKey?: unknown;
       dbPath?: unknown;
+      smart?: unknown;
     };
     if (typeof input.privateKey !== 'string' || typeof input.dbPath !== 'string')
       throw new XmtpVerifyError('xmtp verify needs a privateKey and a dbPath');
-    out = { ok: true, ...(await verifyXmtpKey(input.privateKey, input.dbPath)) };
+    out = { ok: true, ...(await verifyXmtpKey(input.privateKey, input.dbPath, input.smart === true)) };
   } catch (err) {
     out = { ok: false, error: reason(err) };
   }

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

@@ -0,0 +1,28 @@
+import type { EncodedContent } from '@xmtp/content-type-primitives';
+import {
+  SignatureReferenceCodec,
+  SignatureRequestCodec,
+  TransactionReferenceCodec,
+  WalletSendCallsCodec,
+} from './codecs.js';
+import { bad, isNode, parseJson } from './frames.js';
+
+const WALLET_TYPES: Record<string, { codec: { encode(c: Record<string, unknown>): EncodedContent }; needs: string[] }> = {
+  walletSendCalls: { codec: new WalletSendCallsCodec(), needs: ['version', 'chainId', 'from', 'calls'] },
+  transactionReference: { codec: new TransactionReferenceCodec(), needs: ['networkId', 'reference'] },
+  signatureRequest: { codec: new SignatureRequestCodec(), needs: ['id', 'kind'] },
+  signatureReference: { codec: new SignatureReferenceCodec(), needs: ['requestId', 'signature', 'signer'] },
+};
+
+export function buildWalletContent(raw: unknown): { encoded: EncodedContent; summary: string } {
+  const args = parseJson(raw, 'wallet');
+  const type = isNode(args) && typeof args.type === 'string' ? args.type : '';
+  const spec = Object.hasOwn(WALLET_TYPES, type) ? WALLET_TYPES[type] : undefined;
+  if (!isNode(args) || !spec) throw bad(`wallet type must be one of ${Object.keys(WALLET_TYPES).join(', ')}`);
+  const content = parseJson(args.content, 'wallet content');
+  if (!isNode(content)) throw bad(`wallet content must be the ${type} JSON object`);
+  const missing = spec.needs.filter((key) => content[key] === undefined);
+  if (missing.length > 0) throw bad(`${type} content needs ${missing.join(', ')}`);
+  const encoded = spec.codec.encode(content);
+  return { encoded, summary: encoded.fallback ?? type };
+}

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

@@ -1,7 +1,3 @@
-export { emit, respond, mintId } from '@metro-labs/mcp/stations/station-runtime';
-
-export const SELF_URI = process.env.METRO_SELF_URI ?? '';
-
 const UID_MAP_MAX = 5000;
 const uidToXmtp = new Map<string, string>();
 
@@ -37,3 +33,17 @@ export function resolveMsgId(rawId: string): string {
       '(not seen by this train; pass the raw xmtp message_id)',
   );
 }
+
+const SENT_MAX = 5000;
+const sentIds = new Set<string>();
+
+export function rememberSent(xmtpId: string | undefined): void {
+  if (!xmtpId) return;
+  sentIds.add(xmtpId);
+  if (sentIds.size > SENT_MAX) {
+    const oldest = sentIds.values().next().value;
+    if (oldest !== undefined) sentIds.delete(oldest);
+  }
+}
+
+export const sentByMe = (xmtpId: string): boolean => sentIds.has(xmtpId);

package/runtime/patches/5bca2c07d5852d3f58453cff0448dd85da13d3665b61e3d758905b298d432d7c.patch

@@ -0,0 +1,31 @@
+diff --git a/lib/Types/Events.d.ts b/lib/Types/Events.d.ts
+index f55c4c325b08b8c25dc9d17032514ce5c80ad3fd..930cb143e813b9a656533ae765f9db70f6eb7ccd 100644
+--- a/lib/Types/Events.d.ts
++++ b/lib/Types/Events.d.ts
+@@ -46,6 +46,10 @@ export type BaileysEventMap = {
+     'lid-mapping.update': LIDMapping;
+     /** delete chats with given ID */
+     'chats.delete': string[];
++    'chats.clear': {
++        id: string;
++        messageRange?: proto.SyncActionValue.ISyncActionMessageRange | null;
++    };
+     /** presence of contact in a chat updated */
+     'presence.update': {
+         id: string;
+diff --git a/lib/Utils/chat-utils.js b/lib/Utils/chat-utils.js
+index c30265d36671bacd25a8c456cafedcd9fc2fdd9a..2be37df069eda49c546eac1eb3485e649432dbeb 100644
+--- a/lib/Utils/chat-utils.js
++++ b/lib/Utils/chat-utils.js
+@@ -763,7 +763,11 @@ export const processSyncAction = (syncAction, ev, me, initialSyncOpts, logger) =
+             }
+         ]);
+     }
++    else if (action?.clearChatAction || type === 'clearChat') {
++        ev.emit('chats.clear', { id, messageRange: action?.clearChatAction?.messageRange });
++    }
+     else if (action?.deleteChatAction || type === 'deleteChat') {
++        ev.emit('chats.clear', { id, messageRange: action?.deleteChatAction?.messageRange });
+         if (!isInitialSync) {
+             ev.emit('chats.delete', [id]);
+         }

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.32"
+  "version": "0.1.0-beta.321"
 }

package/runtime/sdk-runner/node_modules/@metro-labs/core/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@metro-labs/core",
+  "version": "0.1.0",
+  "private": true,
+  "description": "What every metro process shares: the logger, the event bus and its types, ids, secure file writes, the train protocol, station types and attachment handling. No HTTP, no policy.",
+  "type": "module",
+  "exports": {
+    "./log": "./src/log.ts",
+    "./events": "./src/events.ts",
+    "./is-record": "./src/is-record.ts",
+    "./runner-activity": "./src/runner-activity.ts",
+    "./automation-store": "./src/automation-store.ts",
+    "./automation-types": "./src/automation-types.ts",
+    "./call": "./src/call.ts",
+    "./secure-fs": "./src/secure-fs.ts",
+    "./skill-source": "./src/skill-source.ts",
+    "./version": "./src/version.ts",
+    "./train-error": "./src/train-error.ts",
+    "./trains/protocol": "./src/protocol.ts",
+    "./ids": "./src/ids.ts",
+    "./claude-token": "./src/claude-token.ts",
+    "./effort": "./src/effort.ts",
+    "./tickets": "./src/tickets.ts",
+    "./station-names": "./src/station-names.ts",
+    "./str": "./src/str.ts",
+    "./lines": "./src/lines.ts",
+    "./endpoints": "./src/endpoints.ts",
+    "./stations/types": "./src/stations/types.ts",
+    "./stations/account-status": "./src/stations/account-status.ts",
+    "./stations/channel-directory": "./src/stations/channel-directory.ts",
+    "./stations/channel-pages": "./src/stations/channel-pages.ts",
+    "./stations/account-files": "./src/stations/account-files.ts",
+    "./stations/station-runtime": "./src/stations/station-runtime.ts",
+    "./stations/account-store": "./src/stations/account-store.ts",
+    "./stations/attachments": "./src/stations/attachments.ts",
+    "./stations/mail": "./src/stations/mail.ts",
+    "./stations/mail-text": "./src/stations/mail-text.ts",
+    "./stations/mail-trust": "./src/stations/mail-trust.ts",
+    "./stations/oauth": "./src/stations/oauth.ts",
+    "./stations/messaging-normalize": "./src/stations/messaging-normalize.ts",
+    "./stations/profile": "./src/stations/profile.ts",
+    "./stations/sender-profile": "./src/stations/sender-profile.ts",
+    "./stations/train-events": "./src/stations/train-events.ts",
+    "./stations/train-boot": "./src/stations/train-boot.ts"
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc --noEmit && METRO_STATE_DIR=\"$(mktemp -d /tmp/metro-test.XXXXXX)\" bun test test/"
+  },
+  "dependencies": {
+    "pino": "^9.5.0",
+    "pino-pretty": "^13.1.3"
+  },
+  "devDependencies": {
+    "@stage-labs/config": "0.1.0-beta.3",
+    "eslint": "^10.3.0",
+    "knip": "^6.15.0",
+    "madge": "^8.0.0",
+    "typescript": "^5"
+  }
+}