@stage-labs/metro 0.1.0-beta.226 → 0.1.0-beta.228

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.226",
+  "version": "0.1.0-beta.228",
   "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.226",
+  "version": "0.1.0-beta.228",
   "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/node_modules/@metro-labs/daemon/src/gateway/codex-translate.ts

@@ -1,6 +1,6 @@
 import { createHash } from 'node:crypto';
 import { isRecord } from '@metro-labs/core/is-record';
-import { resultText } from './text.js';
+import { inlineImage, partText, resultImages, resultParts, resultText, TOOL_ERROR, type InlineImage } from './text.js';
 import { stringOf } from '@metro-labs/http/api-http';
 
 const SIGNATURE_PREFIX = 'metro-codex:';
@@ -82,11 +82,25 @@ export function decodeSignature(signature: unknown): Item | null {
   }
 }
 
+const imagePart = (image: InlineImage): Item => ({ type: 'input_image', image_url: `data:${image.mediaType};base64,${image.data}` });
+
 function userPart(block: Item): Item | null {
   if (block.type === 'text') return { type: 'input_text', text: stringOf(block.text) };
-  if (block.type === 'image' && isRecord(block.source) && block.source.type === 'base64')
-    return { type: 'input_image', image_url: `data:${stringOf(block.source.media_type)};base64,${stringOf(block.source.data)}` };
-  return null;
+  const image = inlineImage(block);
+  return image === null ? null : imagePart(image);
+}
+
+function outputPart(part: Item): Item | null {
+  const image = inlineImage(part);
+  if (image !== null) return imagePart(image);
+  const text = partText(part);
+  return text === '' ? null : { type: 'input_text', text };
+}
+
+function toolOutput(block: Item): string | Item[] {
+  if (resultImages(block).length === 0) return resultText(block);
+  const parts = resultParts(block).map(outputPart).filter((part): part is Item => part !== null);
+  return block.is_error === true ? [{ type: 'input_text', text: TOOL_ERROR }, ...parts] : parts;
 }
 
 function userItems(content: unknown): Item[] {
@@ -101,7 +115,7 @@ function userItems(content: unknown): Item[] {
   for (const block of content.filter(isRecord)) {
     if (block.type === 'tool_result') {
       flush();
-      out.push({ type: 'function_call_output', call_id: stringOf(block.tool_use_id), output: resultText(block) });
+      out.push({ type: 'function_call_output', call_id: stringOf(block.tool_use_id), output: toolOutput(block) });
       continue;
     }
     const part = userPart(block);

package/runtime/node_modules/@metro-labs/daemon/src/gateway/gemini-translate.ts

@@ -3,7 +3,7 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { ToolNames } from './codex-translate.js';
 import { CLIENT_NAME, requestId, SYSTEM_PREFIX } from './gemini-client.js';
 import { cappedEffort, effortToApply } from './effort.js';
-import { resultText } from './text.js';
+import { inlineImage, resultImages, resultText, type InlineImage } from './text.js';
 import { stringOf } from '@metro-labs/http/api-http';
 
 type Item = Record<string, unknown>;
@@ -63,11 +63,22 @@ export function systemText(system: unknown): string {
     .trim();
 }
 
+const imagePart = (image: InlineImage): Item => ({ inlineData: { mimeType: image.mediaType, data: image.data } });
+
+const GEMINI_IMAGES = new Set(['image/png', 'image/jpeg', 'image/webp', 'image/heic', 'image/heif']);
+const geminiSees = (mediaType: string): boolean => GEMINI_IMAGES.has(mediaType);
+
+function toolParts(block: Item, id: string, name: string): Item[] {
+  const images = resultImages(block, geminiSees);
+  const text = resultText(block, geminiSees);
+  const result = text === '' && images.length > 0 ? `Binary content provided (${String(images.length)} item(s)).` : text;
+  return [{ functionResponse: { id, name, response: { result } } }, ...images.map(imagePart)];
+}
+
 function userPart(block: Item): Item | null {
   if (block.type === 'text') return { text: stringOf(block.text) };
-  if (block.type === 'image' && isRecord(block.source) && block.source.type === 'base64')
-    return { inlineData: { mimeType: stringOf(block.source.media_type), data: stringOf(block.source.data) } };
-  return null;
+  const image = inlineImage(block);
+  return image === null ? null : imagePart(image);
 }
 
 function userParts(content: unknown, calls: Map<string, string>): Item[] {
@@ -77,7 +88,7 @@ function userParts(content: unknown, calls: Map<string, string>): Item[] {
   for (const block of content.filter(isRecord)) {
     if (block.type === 'tool_result') {
       const id = stringOf(block.tool_use_id);
-      out.push({ functionResponse: { id, name: calls.get(id) ?? 'tool', response: { result: resultText(block) } } });
+      out.push(...toolParts(block, id, calls.get(id) ?? 'tool'));
       continue;
     }
     const part = userPart(block);

package/runtime/node_modules/@metro-labs/daemon/src/gateway/text.ts

@@ -2,13 +2,34 @@ import { isRecord } from '@metro-labs/core/is-record';
 import { stringOf } from '@metro-labs/http/api-http';
 
 const IMAGE_NOTE = '[an image was attached here; this model cannot see it]';
+export const TOOL_ERROR = '[tool error]';
 
 export const nonEmpty = (value: unknown): string | null => (typeof value === 'string' && value !== '' ? value : null);
 
-const partText = (part: Record<string, unknown>): string => (part.type === 'text' ? stringOf(part.text) : part.type === 'image' ? IMAGE_NOTE : '');
+export interface InlineImage {
+  mediaType: string;
+  data: string;
+}
+
+type Part = Record<string, unknown>;
+type Accepts = (mediaType: string) => boolean;
+const anyImage: Accepts = () => true;
+
+export function inlineImage(block: Part, accepts = anyImage): InlineImage | null {
+  if (block.type !== 'image' || !isRecord(block.source) || block.source.type !== 'base64') return null;
+  const image = { mediaType: stringOf(block.source.media_type), data: stringOf(block.source.data) };
+  return image.mediaType !== '' && image.data !== '' && accepts(image.mediaType) ? image : null;
+}
 
-export function resultText(block: Record<string, unknown>): string {
+export const resultParts = (block: Part): Part[] => (Array.isArray(block.content) ? block.content.filter(isRecord) : []);
+
+export const partText = (part: Part, accepts = anyImage): string =>
+  part.type === 'text' ? stringOf(part.text) : part.type === 'image' && inlineImage(part, accepts) === null ? IMAGE_NOTE : '';
+
+export function resultText(block: Part, accepts = anyImage): string {
   const content = block.content;
-  const text = typeof content === 'string' ? content : Array.isArray(content) ? content.filter(isRecord).map(partText).filter((t) => t !== '').join('\n') : '';
-  return block.is_error === true ? `[tool error] ${text}` : text;
+  const text = typeof content === 'string' ? content : resultParts(block).map((part) => partText(part, accepts)).filter((t) => t !== '').join('\n');
+  return block.is_error === true ? `${TOOL_ERROR} ${text}` : text;
 }
+
+export const resultImages = (block: Part, accepts = anyImage): InlineImage[] => resultParts(block).flatMap((part) => inlineImage(part, accepts) ?? []);

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

@@ -1,13 +1,18 @@
-import { ReactionAction, ReactionSchema, type Conversation } 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 { convOf } from './accounts.js';
+import { convOf, type Account } from './accounts.js';
 import { resolveMsgId } from './wire.js';
 import { emitOutbound } from './emit.js';
-import { PollCodec, buildPollContent } from './codecs.js';
+import { PollCodec, buildPollContent, encodeDeleteMessage } from './codecs.js';
 import { convHandlers } from './actions-conv.js';
 import { messagingAliases } from '@metro-labs/core/stations/messaging-normalize';
 import { TrainError } from '@metro-labs/core/train-error';
@@ -106,6 +111,28 @@ 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 sendAttachment(id: string, args: Args): Promise<void> {
   const { line, name, mime, dataB64 } = args as {
     line: string;
@@ -186,6 +213,7 @@ const handlers: Record<string, (id: string, args: Args) => Promise<void>> = {
   ask,
   react,
   reply,
+  delete: remove,
   sendAttachment,
   sendImage,
   ...convHandlers,

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

@@ -164,6 +164,33 @@ export const SignatureReferenceCodec =
     c.signature ? `[Signature] ${c.signature}` : '[Signature]',
   );
 
+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 CODECS = (): ContentCodec[] => [
   new PollCodec(),
   new SignatureRequestCodec(),

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

@@ -6,7 +6,7 @@ export const xmtpStation: Station = {
   name: 'xmtp',
   hasAccounts: true,
   hasTrain: true,
-  messageVerbs: new Set<Verb>(['send', 'reply', 'react', 'unreact', 'read']),
+  messageVerbs: new Set<Verb>(['send', 'reply', 'react', 'unreact', 'delete', 'read']),
   groupOps: new Set<GroupOp>(['create_group', 'add_members', 'remove_members']),
   attachmentMode: 'native',
   profileFields: new Set<ProfileField>(PROFILE_FIELDS),

package/runtime/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.226"
+  "version": "0.1.0-beta.228"
 }