@stage-labs/metro 0.1.0-beta.67 → 0.1.0-beta.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stage-labs/metro",
-  "version": "0.1.0-beta.67",
+  "version": "0.1.0-beta.69",
   "description": "The metro command line. Sign in once per machine, then hand your MCP connector list to Claude Code without the credentials touching disk, argv or shell history.",
   "license": "MIT",
   "repository": {

package/runtime/node_modules/@metro-labs/discord-bot/src/format.ts

@@ -65,6 +65,15 @@ function tagFor(att: {
   return `[${kind}: ${att.name ?? kind}]`;
 }
 
+function addressing(accountId: string, m: Message): { mentions_self: boolean; reply_to_self: boolean } {
+  const me = accounts.get(accountId)?.client.user ?? null;
+  if (me === null) return { mentions_self: false, reply_to_self: false };
+  return {
+    mentions_self: m.mentions.has(me, { ignoreRepliedUser: true, ignoreEveryone: true }),
+    reply_to_self: m.mentions.repliedUser?.id === me.id,
+  };
+}
+
 export function messageEnvelope(
   accountId: string,
   m: Message,
@@ -112,6 +121,7 @@ export function messageEnvelope(
     text,
     is_private: m.guildId == null,
     reply_to: m.reference?.messageId ?? undefined,
+    ...addressing(accountId, m),
     ...(m.reference?.messageId
       ? { event: { type: 'reply', replyTo: m.reference.messageId } }
       : {}),

package/runtime/node_modules/@metro-labs/mcp/src/channels/addressed.ts

@@ -0,0 +1,25 @@
+import { str } from '../mcp/str.js';
+
+export type Addressed = 'direct' | 'mention' | 'reply';
+
+interface AddressFacts {
+  isPrivate?: unknown;
+  mentionsSelf?: unknown;
+  replyToSelf?: unknown;
+}
+
+export function addressedBy(facts: AddressFacts, replyTo: string, sent: ReadonlySet<string>): Addressed | undefined {
+  if (facts.isPrivate === true) return 'direct';
+  if (facts.mentionsSelf === true) return 'mention';
+  if (facts.replyToSelf === true || (replyTo !== '' && sent.has(replyTo))) return 'reply';
+  return undefined;
+}
+
+export function replyMeta(ev: Record<string, unknown>, sent: ReadonlySet<string>): Record<string, string> {
+  const replyTo = str(ev.replyTo);
+  const addressed = addressedBy(ev, replyTo, sent);
+  return {
+    ...(replyTo ? { reply_to: replyTo } : {}),
+    ...(addressed === undefined ? {} : { addressed }),
+  };
+}

package/runtime/node_modules/@metro-labs/mcp/src/channels/inbound.ts

@@ -8,6 +8,7 @@ import {
   type SavedMedia,
 } from './media-note.js';
 import { buildWebhookNote } from './webhook-note.js';
+import { replyMeta } from './addressed.js';
 import {
   capSet,
   displayNameMeta,
@@ -31,6 +32,7 @@ const DEDUPE_TTL_MS = 30_000;
 const DEDUPE_MAX = 2_000;
 const ALLOWED_LINES_MAX = 2_000;
 const PENDING_PERMISSIONS_MAX = 500;
+const SENT_IDS_MAX = 2_000;
 
 const PERMISSION_REPLY_RE = /^\s*(y|yes|n|no)\s+([a-km-z]{5})\s*$/i;
 
@@ -43,6 +45,7 @@ export class InboundRelay {
   private readonly seenEvents = new Map<string, number>();
   private readonly allowedLines = new Set<string>();
   private readonly pendingPermissions = new Set<string>();
+  private readonly sentIds = new Set<string>();
   private lastLine: string | undefined;
 
   constructor(deps: InboundDeps) {
@@ -58,6 +61,12 @@ export class InboundRelay {
     capSet(this.pendingPermissions, PENDING_PERMISSIONS_MAX);
   }
 
+  noteSent(messageId: string): void {
+    if (!messageId) return;
+    this.sentIds.add(messageId);
+    capSet(this.sentIds, SENT_IDS_MAX);
+  }
+
   private notify(method: string, params: Record<string, unknown>): Promise<void> {
     return this.deps.mcp.notification({ method, params });
   }
@@ -318,6 +327,7 @@ export class InboundRelay {
         line_name: str(ev.lineName),
         from_name: str(ev.fromName),
         ...displayNameMeta(ev.fromDisplayName),
+        ...replyMeta(ev, this.sentIds),
       },
     });
   }

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

@@ -24,6 +24,9 @@ export interface MetroEvent {
   text?: string;
   messageId?: string;
   replyTo?: string;
+  isPrivate?: boolean;
+  mentionsSelf?: boolean;
+  replyToSelf?: boolean;
   payload?: unknown;
   display?: string;
   event?: StructuredEvent;

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

@@ -128,6 +128,17 @@ function eventText(env: TrainEvent): string | undefined {
   return env.emoji ? `[react ${env.emoji}]` : undefined;
 }
 
+function addressingFacts(
+  env: TrainEvent,
+  isPrivate: boolean,
+): Pick<MetroEvent, 'isPrivate' | 'mentionsSelf' | 'replyToSelf'> {
+  return {
+    ...(isPrivate ? { isPrivate: true } : {}),
+    ...(env.mentions_self === true ? { mentionsSelf: true } : {}),
+    ...(env.reply_to_self === true ? { replyToSelf: true } : {}),
+  };
+}
+
 export function trainEventToMetroEvent(
   env: TrainEvent,
   trainName: string,
@@ -155,6 +166,7 @@ export function trainEventToMetroEvent(
     text,
     messageId: env.message_id,
     replyTo: env.reply_to,
+    ...addressingFacts(env, isPrivate),
     payload: env.payload,
   };
 }

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

@@ -37,6 +37,8 @@ export type TrainEvent = {
   message_id?: string;
   reply_to?: string;
   is_private?: boolean;
+  mentions_self?: boolean;
+  reply_to_self?: boolean;
   text?: string;
   emoji?: string;
   payload?: unknown;

package/runtime/node_modules/@metro-labs/mcp/src/daemon/terminal-api.ts

@@ -10,7 +10,7 @@ const TICKETS = `${PREFIX}/tickets`;
 export const TMUX_SESSION = 'metro';
 const SESSION_RE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,31}$/;
 
-export const tmuxCommand = (session: string): string[] => ['tmux', 'new-session', '-A', '-D', '-s', session];
+export const tmuxCommand = (session: string): string[] => ['tmux', 'new-session', '-A', '-D', '-s', session, ';', 'set-option', '-g', 'mouse', 'on'];
 
 export interface TerminalApiDeps {
   authorize: (subject: string) => void;

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

@@ -16,6 +16,7 @@ interface MessageArgs {
   line: string;
   a: Record<string, unknown>;
   ctx: ReturnType<typeof makeCtx>;
+  onSent?: (messageId: string) => void;
   station: Station;
 }
 
@@ -105,6 +106,10 @@ 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`;
 
+function noteSent(m: MessageArgs, messageId: string | undefined): void {
+  if (messageId !== undefined) m.onSent?.(messageId);
+}
+
 async function handleSend(m: MessageArgs): Promise<ToolResult> {
   const text = m.a.text as string | undefined;
   const replyTo = m.a.reply_to as string | undefined;
@@ -125,6 +130,7 @@ async function handleSend(m: MessageArgs): Promise<ToolResult> {
       : await sendForwarded(m, text, replyTo, atts);
     if (!sent.labels.length)
       return errResult('send requires `text` or `attachments`');
+    noteSent(m, sent.messageId);
     return ok(withId(`sent: ${sent.labels.join(', ')}`, sent.messageId));
   } finally {
     await cleanupAttachments(atts);
@@ -158,7 +164,7 @@ const MESSAGE_VERBS: Record<string, VerbSpec> = {
 };
 
 function makeVerbHandler(verb: string, spec: VerbSpec): MessageHandler {
-  return async ({ line, a, ctx }) => {
+  return async ({ line, a, ctx, onSent }) => {
     const payload: Record<string, unknown> = { line };
     for (const [snake, camel] of spec.args) {
       const value = str(a[snake]);
@@ -169,7 +175,9 @@ function makeVerbHandler(verb: string, spec: VerbSpec): MessageHandler {
       payload[camel] = value;
     }
     const response = await ctx.call(verb, payload);
-    return ok(withId(spec.success, messageIdOf(response)));
+    const messageId = messageIdOf(response);
+    if (verb === 'reply' && messageId !== undefined) onSent?.(messageId);
+    return ok(withId(spec.success, messageId));
   };
 }
 
@@ -181,9 +189,14 @@ const MESSAGE_HANDLERS: Record<string, MessageHandler> = {
   ),
 };
 
+export interface ToolHooks {
+  onSent?: (messageId: string) => void;
+}
+
 export async function dispatchMessageTool(
   name: string,
   a: Record<string, unknown>,
+  hooks: ToolHooks = {},
 ): Promise<ToolResult> {
   const line = str(a.line);
   if (!line) return errResult(`${name} requires \`line\``);
@@ -196,7 +209,7 @@ export async function dispatchMessageTool(
   const handler = MESSAGE_HANDLERS[name];
   if (!handler) return errResult(`unknown tool: ${name}`);
   try {
-    return await handler({ line, a, ctx: makeCtx(station.name), station });
+    return await handler({ line, a, ctx: makeCtx(station.name), station, onSent: hooks.onSent });
   } catch (e) {
     return toErr(name, e);
   }

package/runtime/node_modules/@metro-labs/mcp/src/mcp/session.ts

@@ -99,6 +99,10 @@ export class McpSession {
       deliver: (send): void => {
         this.deliverSchemaNotice(send, 'request');
       },
+    }, {
+      onSent: (id): void => {
+        this.relay.noteSent(id);
+      },
     });
     this.relay = new InboundRelay({
       mcp: this.server,

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

@@ -12,7 +12,7 @@ import {
 import type { Station, StationTool, ToolResult } from '../stations/types.js';
 import { COMMON_TOOLS, LIST_ACCOUNTS_TOOL } from './tool-schemas.js';
 import { errResult, makeCtx, okJson, toErr } from './ctx.js';
-import { dispatchMessageTool } from './call-tools.js';
+import { dispatchMessageTool, type ToolHooks } from './call-tools.js';
 import { dispatchListMembers } from './member-tools.js';
 import {
   dispatchAddMembers,
@@ -142,9 +142,10 @@ function logToolFailure(
   );
 }
 
-async function runTool(req: {
-  params: { name: string; arguments?: Record<string, unknown> };
-}): Promise<ToolResult> {
+async function runTool(
+  req: { params: { name: string; arguments?: Record<string, unknown> } },
+  hooks: ToolHooks,
+): Promise<ToolResult> {
   const name = req.params.name;
   const a = req.params.arguments ?? {};
 
@@ -166,13 +167,14 @@ async function runTool(req: {
 
   if (name === 'list_accounts') return handleListAccounts(identity);
 
-  return dispatchMessageTool(name, a);
+  return dispatchMessageTool(name, a, hooks);
 }
 
-export async function callToolHandler(req: {
-  params: { name: string; arguments?: Record<string, unknown> };
-}): Promise<ToolResult> {
-  const result = await runTool(req);
+export async function callToolHandler(
+  req: { params: { name: string; arguments?: Record<string, unknown> } },
+  hooks: ToolHooks = {},
+): Promise<ToolResult> {
+  const result = await runTool(req, hooks);
   if (result.isError === true)
     logToolFailure(req.params.name, req.params.arguments ?? {}, result);
   return result;
@@ -192,6 +194,7 @@ interface NotifyingExtra {
 export function registerToolHandlers(
   server: Server,
   notice?: SchemaNotice,
+  hooks: ToolHooks = {},
 ): void {
   server.setRequestHandler(ListToolsRequestSchema, () => {
     notice?.markCurrent();
@@ -206,7 +209,7 @@ export function registerToolHandlers(
       notice?.deliver(() =>
         extra.sendNotification({ method: TOOL_LIST_CHANGED }),
       );
-      return callToolHandler(req);
+      return callToolHandler(req, hooks);
     }) as Parameters<typeof server.setRequestHandler>[1],
   );
 }

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

@@ -394,4 +394,7 @@ export const MCP_INSTRUCTIONS =
   'straight to metro and never through this conversation), then `send` with ' +
   'attachments:[{upload:"<upload_id>"}]. Inline `data` is for tiny files only, `url` only for ' +
   'an already-public file, and `path` is read on the DAEMON host, not yours. Tool-approval ' +
-  'prompts are relayed to the same chat - answer "yes <id>"/"no <id>".';
+  'prompts are relayed to the same chat - answer "yes <id>"/"no <id>". A message meant for you ' +
+  'carries addressed="direct" (a private chat), "mention" (you were named) or "reply" (it ' +
+  'answers one of your own messages); one without `addressed` merely happened in a room you ' +
+  'watch, so treat it as context and do not answer unless the person plainly wants you.';

package/runtime/node_modules/@metro-labs/telegram/src/format.ts

@@ -45,6 +45,20 @@ export function isOwnEcho(m: Message): boolean {
   return isUser(sender) && sender.isSelf;
 }
 
+function replyMeta(m: Message): Record<string, unknown> {
+  const replied = m.replyToMessage;
+  const target = replied?.id;
+  if (replied === null || typeof target !== 'number') return {};
+  if (m.isTopicMessage && target === replied.threadId) return {};
+  const id = String(target);
+  const sender = replied.sender;
+  return {
+    reply_to: id,
+    event: { type: 'reply', replyTo: id },
+    reply_to_self: sender?.type === 'user' && sender.isSelf,
+  };
+}
+
 export function envelope(
   accountId: string,
   m: Message,
@@ -71,6 +85,7 @@ export function envelope(
     text: projectText(m),
     is_private: isPrivate,
     has_media: media !== null,
+    ...replyMeta(m),
     payload: {
       account: accountId,
       message_id: String(m.id),

package/runtime/node_modules/@metro-labs/telegram-bot/src/accounts.ts

@@ -42,6 +42,7 @@ export interface Account {
   api: string;
   fileApi: string;
   offset: number;
+  username?: string;
 }
 export const accounts = new Map<string, Account>();
 

package/runtime/node_modules/@metro-labs/telegram-bot/src/format.ts

@@ -44,6 +44,34 @@ function projectText(m: TgMsg): string {
   return [m.text ?? m.caption, ...tags].filter(Boolean).join(' ');
 }
 
+const botIdOf = (accountId: string): number | null => {
+  const token = accounts.get(accountId)?.cfg.token ?? '';
+  const id = Number(token.split(':')[0]);
+  return Number.isInteger(id) && id > 0 ? id : null;
+};
+
+function mentionsBot(m: TgMsg, botId: number | null, username: string | undefined): boolean {
+  const text = m.text ?? m.caption ?? '';
+  const handle = username === undefined ? null : `@${username.toLowerCase()}`;
+  return [...(m.entities ?? []), ...(m.caption_entities ?? [])].some((e) => {
+    if (e.type === 'text_mention') return botId !== null && e.user?.id === botId;
+    if (e.type !== 'mention' || handle === null) return false;
+    return text.slice(e.offset, e.offset + e.length).toLowerCase() === handle;
+  });
+}
+
+function addressing(accountId: string, m: TgMsg): Record<string, unknown> {
+  const botId = botIdOf(accountId);
+  const topicRoot = m.is_topic_message === true && m.reply_to_message?.message_id === m.message_thread_id;
+  const replied = topicRoot ? undefined : m.reply_to_message;
+  const replyTo = replied === undefined ? undefined : String(replied.message_id);
+  return {
+    ...(replyTo === undefined ? {} : { reply_to: replyTo, event: { type: 'reply', replyTo } }),
+    mentions_self: mentionsBot(m, botId, accounts.get(accountId)?.username),
+    reply_to_self: botId !== null && replied?.from?.id === botId,
+  };
+}
+
 export function envelope(accountId: string, m: TgMsg): Record<string, unknown> {
   const { line } = lineForMsg(accountId, m);
   return {
@@ -60,6 +88,7 @@ export function envelope(accountId: string, m: TgMsg): Record<string, unknown> {
     text: projectText(m),
     payload: m,
     is_private: m.chat.type === 'private',
+    ...addressing(accountId, m),
   };
 }
 

package/runtime/node_modules/@metro-labs/telegram-bot/src/index.ts

@@ -48,6 +48,12 @@ async function runAccount(acct: Account): Promise<void> {
       `telegram-bot[${id}] deleteWebhook: ${errMsg(err)}\n`,
     );
   }
+  try {
+    const me = await tg<{ username?: string }>(id, 'getMe', {});
+    if (typeof me.username === 'string') acct.username = me.username;
+  } catch (err) {
+    process.stderr.write(`telegram-bot[${id}] getMe: ${errMsg(err)}\n`);
+  }
 
   for (;;) {
     try {

package/runtime/node_modules/@metro-labs/telegram-bot/src/types.ts

@@ -1,4 +1,14 @@
+export interface TgEntity {
+  type: string;
+  offset: number;
+  length: number;
+  user?: { id: number };
+}
+
 export interface TgMsg {
+  entities?: TgEntity[];
+  caption_entities?: TgEntity[];
+  reply_to_message?: { message_id: number; from?: { id: number; username?: string; is_bot?: boolean } };
   message_id: number;
   date: number;
   chat: { id: number; type: string; title?: string; first_name?: string };

package/runtime/node_modules/@metro-labs/whatsapp/src/client.ts

@@ -1,4 +1,5 @@
 import makeWASocket, {
+  jidNormalizedUser,
   Browsers,
   DisconnectReason,
   fetchLatestWaWebVersion,
@@ -11,7 +12,7 @@ import { TrainError } from '@metro-labs/mcp/train-error';
 import { errMsg } from '@metro-labs/mcp/log';
 import type { WhatsAppAccount } from './types.js';
 import type { InboundMessage, ReactionInput } from './format.js';
-import { toInbound, toReaction, type ReactionEvent } from './parse.js';
+import { toInbound, toReaction, type ReactionEvent, type SelfRef } from './parse.js';
 import { baileysLogger } from './logger.js';
 import { useAccountAuthState } from './auth-state.js';
 import { knownKey, makeKeyCache, targetKey, type KeyCache } from './keys.js';
@@ -72,13 +73,21 @@ function resetGate(st: State): void {
   });
 }
 
+function selfRef(st: State, sock: WASocket): SelfRef {
+  const jids = new Set<string>();
+  const me = sock.user;
+  if (me?.id) jids.add(jidNormalizedUser(me.id));
+  if (me?.lid) jids.add(jidNormalizedUser(me.lid));
+  return { jids, sentByMe: (jid, id) => st.keys.lookup(jid, id)?.fromMe === true };
+}
+
 function bindInbound(st: State, sock: WASocket): void {
   sock.ev.on('messages.upsert', ({ messages, type }) => {
     for (const m of messages) st.keys.remember(m.key);
     if (type !== 'notify' || !st.handlers) return;
     for (const m of messages) {
       if (m.key.fromMe) continue;
-      const inbound = toInbound(st.account.id, m);
+      const inbound = toInbound(st.account.id, m, selfRef(st, sock));
       if (inbound) st.handlers.onMessage(inbound, m);
     }
   });

package/runtime/node_modules/@metro-labs/whatsapp/src/format.ts

@@ -13,6 +13,9 @@ export interface InboundMessage {
   isPrivate: boolean;
   pushName?: string;
   media?: WAMediaRef;
+  replyTo?: string;
+  mentionsSelf?: boolean;
+  replyToSelf?: boolean;
 }
 
 export interface ReactionInput {
@@ -48,6 +51,9 @@ export function envelope(m: InboundMessage): Record<string, unknown> {
     message_id: m.messageId,
     text: m.text,
     is_private: m.isPrivate,
+    ...(m.replyTo === undefined ? {} : { reply_to: m.replyTo, event: { type: 'reply', replyTo: m.replyTo } }),
+    ...(m.mentionsSelf === true ? { mentions_self: true } : {}),
+    ...(m.replyToSelf === true ? { reply_to_self: true } : {}),
     payload: {
       account: m.accountId,
       message_id: m.messageId,

package/runtime/node_modules/@metro-labs/whatsapp/src/parse.ts

@@ -80,9 +80,52 @@ function senderJidOf(key: WAMessageKey, chatJid: string): string {
   return chatJid;
 }
 
+export interface SelfRef {
+  jids: ReadonlySet<string>;
+  sentByMe: (chatJid: string, id: string) => boolean;
+}
+
+const QUOTING_NODES = [
+  'extendedTextMessage',
+  'imageMessage',
+  'videoMessage',
+  'documentMessage',
+  'audioMessage',
+  'stickerMessage',
+] as const;
+
+function contextInfoOf(inner: proto.IMessage): proto.IContextInfo | undefined {
+  for (const node of QUOTING_NODES) {
+    const ctx = inner[node]?.contextInfo;
+    if (ctx) return ctx;
+  }
+  return undefined;
+}
+
+function quoteFacts(ctx: proto.IContextInfo, replyTo: string | undefined, chatJid: string, self: SelfRef): Addressing {
+  const quotedBy = typeof ctx.participant === 'string' ? ctx.participant : '';
+  const mentioned = (ctx.mentionedJid ?? []).some((jid) => self.jids.has(jid));
+  const replyToSelf = replyTo !== undefined && (self.jids.has(quotedBy) || self.sentByMe(chatJid, replyTo));
+  return {
+    ...(mentioned ? { mentionsSelf: true } : {}),
+    ...(replyToSelf ? { replyToSelf: true } : {}),
+  };
+}
+
+type Addressing = Pick<InboundMessage, 'replyTo' | 'mentionsSelf' | 'replyToSelf'>;
+
+function addressing(inner: proto.IMessage, chatJid: string, self: SelfRef | undefined): Addressing {
+  const ctx = contextInfoOf(inner);
+  if (ctx === undefined) return {};
+  const replyTo = typeof ctx.stanzaId === 'string' && ctx.stanzaId !== '' ? ctx.stanzaId : undefined;
+  const base: Addressing = replyTo === undefined ? {} : { replyTo };
+  return self === undefined ? base : { ...base, ...quoteFacts(ctx, replyTo, chatJid, self) };
+}
+
 export function toInbound(
   accountId: string,
   m: WAMessage,
+  self?: SelfRef,
 ): InboundMessage | undefined {
   const chatJid = m.key.remoteJid;
   const messageId = m.key.id;
@@ -102,6 +145,7 @@ export function toInbound(
     isPrivate: isPrivateJid(chatJid),
     ...(m.pushName ? { pushName: m.pushName } : {}),
     ...(media ? { media } : {}),
+    ...addressing(inner, chatJid, self),
   };
 }
 

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

@@ -8,6 +8,7 @@ import {
   type RemoteEntry,
 } from './attachments.js';
 import { emitInbound, emitAttachmentSaved } from './emit-core.js';
+import { sentByMe } from './wire.js';
 
 export interface EnvelopeCtx {
   accountId: string;
@@ -150,6 +151,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,

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

@@ -1,6 +1,6 @@
 import type { Conversation, DecodedMessage } from '@xmtp/node-sdk';
 import { lineOf, parseLine } from './accounts.js';
-import { emit, mintId, rememberUid, SELF_URI } from './wire.js';
+import { emit, mintId, rememberSent, rememberUid, SELF_URI } from './wire.js';
 import { fcmPushToAll } from './push.js';
 import { emitInbound, emitAttachmentSaved } from './emit-core.js';
 import { typedEnvelope, type EnvelopeCtx } from './emit-payloads.js';
@@ -23,6 +23,7 @@ export function envelope(
     line,
     from: `metro://xmtp/${accountId}/user/${msg.senderInboxId}`,
     message_id: msg.id,
+    is_private: typeof (conv as unknown as { peerInboxId?: unknown }).peerInboxId === 'function',
   };
   rememberUid(base.id, msg.id);
   if (typeof c === 'string')
@@ -53,6 +54,7 @@ export function emitOutbound(
 ): void {
   const uid = mintId();
   rememberUid(uid, messageId);
+  rememberSent(messageId);
   emit({
     kind: 'outbound',
     id: uid,

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

@@ -37,3 +37,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/runtime.json

@@ -1,3 +1,3 @@
 {
-  "version": "0.1.0-beta.67"
+  "version": "0.1.0-beta.69"
 }