@xmoxmo/bncr 0.4.6 → 0.4.7

package/src/messaging/inbound/group-history.ts

@@ -0,0 +1,189 @@
+import {
+  createChannelHistoryWindow,
+  DEFAULT_GROUP_HISTORY_LIMIT,
+  type HistoryEntry,
+  type HistoryMediaEntry,
+} from 'openclaw/plugin-sdk/reply-history';
+import { formatOpenClawAgentEnvelope } from '../../openclaw/reply-runtime.ts';
+import type { BncrInboundApi } from './contracts.ts';
+import type { ParsedInbound } from './dispatch-prep.ts';
+
+export type BncrGroupHistoryMap = Map<string, HistoryEntry[]>;
+
+type BncrHistoryMediaKind = NonNullable<HistoryMediaEntry['kind']>;
+
+function normalizeTextBody(value: string): string {
+  return String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+export function buildBncrGroupHistoryKey(parsed: ParsedInbound): string | null {
+  if (parsed.peer.kind !== 'group') return null;
+  const platform = String(parsed.platform || '').trim();
+  const groupId = String(parsed.groupId || '').trim();
+  if (!platform || !groupId || groupId === '0') return null;
+  return `${platform}:${groupId}`;
+}
+
+export function recordBncrPendingGroupText(args: {
+  historyMap: BncrGroupHistoryMap;
+  parsed: ParsedInbound;
+  senderDisplayName: string;
+  bodyText: string;
+}) {
+  const historyKey = buildBncrGroupHistoryKey(args.parsed);
+  const body = normalizeTextBody(args.bodyText);
+  if (!historyKey || !body || args.parsed.msgType !== 'text') return;
+  createChannelHistoryWindow({ historyMap: args.historyMap }).record({
+    historyKey,
+    limit: DEFAULT_GROUP_HISTORY_LIMIT,
+    entry: {
+      sender: args.senderDisplayName,
+      body,
+      timestamp: Date.now(),
+      messageId: args.parsed.msgId,
+    },
+  });
+}
+
+function inferBncrHistoryMediaKind(args: {
+  msgType?: string;
+  mediaContentType?: string;
+}): BncrHistoryMediaKind {
+  const msgType = String(args.msgType || '')
+    .trim()
+    .toLowerCase();
+  const contentType = String(args.mediaContentType || '')
+    .trim()
+    .toLowerCase();
+  if (msgType === 'image' || contentType.startsWith('image/')) return 'image';
+  if (msgType === 'video' || contentType.startsWith('video/')) return 'video';
+  if (msgType === 'audio' || msgType === 'voice' || contentType.startsWith('audio/'))
+    return 'audio';
+  if (msgType === 'file' || msgType === 'document') return 'document';
+  if (contentType) return 'document';
+  return 'unknown';
+}
+
+function buildBncrHistoryMediaBody(kind: BncrHistoryMediaKind): string {
+  return `<media:${kind}>`;
+}
+
+export async function recordBncrPendingGroupMedia(args: {
+  historyMap: BncrGroupHistoryMap;
+  parsed: ParsedInbound;
+  senderDisplayName: string;
+  bodyText: string;
+  mediaItems?: Array<{
+    path: string;
+    contentType?: string;
+    kind?: BncrHistoryMediaKind;
+  }>;
+  mediaContentType?: string;
+}) {
+  const historyKey = buildBncrGroupHistoryKey(args.parsed);
+  if (!historyKey || args.parsed.msgType === 'text') return;
+  const normalizedMediaItems = Array.isArray(args.mediaItems) ? args.mediaItems : [];
+  const itemKinds = normalizedMediaItems
+    .map((item) =>
+      String(item?.kind || '')
+        .trim()
+        .toLowerCase(),
+    )
+    .filter(Boolean);
+  const kind = itemKinds[0]
+    ? itemKinds.every((candidate) => candidate === itemKinds[0])
+      ? (itemKinds[0] as BncrHistoryMediaKind)
+      : 'document'
+    : inferBncrHistoryMediaKind({
+        msgType: args.parsed.msgType,
+        mediaContentType: args.mediaContentType,
+      });
+  const body = normalizeTextBody(args.bodyText) || buildBncrHistoryMediaBody(kind);
+  if (normalizedMediaItems.length === 0 || kind !== 'image') {
+    createChannelHistoryWindow({ historyMap: args.historyMap }).record({
+      historyKey,
+      limit: DEFAULT_GROUP_HISTORY_LIMIT,
+      entry: {
+        sender: args.senderDisplayName,
+        body,
+        timestamp: Date.now(),
+        messageId: args.parsed.msgId,
+      },
+    });
+    return;
+  }
+  await createChannelHistoryWindow({ historyMap: args.historyMap }).recordWithMedia({
+    historyKey,
+    limit: DEFAULT_GROUP_HISTORY_LIMIT,
+    entry: {
+      sender: args.senderDisplayName,
+      body,
+      timestamp: Date.now(),
+      messageId: args.parsed.msgId,
+    },
+    messageId: args.parsed.msgId,
+    media: normalizedMediaItems.map(
+      (item) =>
+        ({
+          path: item.path,
+          contentType: item.contentType || args.mediaContentType || 'image/*',
+          kind: 'image',
+          messageId: args.parsed.msgId,
+        }) satisfies HistoryMediaEntry,
+    ),
+  });
+}
+
+export function buildBncrPendingGroupContext(args: {
+  api: BncrInboundApi;
+  historyMap: BncrGroupHistoryMap;
+  parsed: ParsedInbound;
+  channelLabel: string;
+  currentTimestamp: number;
+  previousTimestamp?: unknown;
+  envelope?: unknown;
+  currentMessage: string;
+}) {
+  const historyKey = buildBncrGroupHistoryKey(args.parsed);
+  if (!historyKey) return args.currentMessage;
+  return createChannelHistoryWindow({ historyMap: args.historyMap }).buildPendingContext({
+    historyKey,
+    limit: DEFAULT_GROUP_HISTORY_LIMIT,
+    currentMessage: args.currentMessage,
+    formatEntry: (entry) =>
+      formatOpenClawAgentEnvelope(args.api, {
+        channel: 'Bncr',
+        from: args.channelLabel,
+        timestamp: entry.timestamp || args.currentTimestamp,
+        previousTimestamp: args.previousTimestamp,
+        envelope: args.envelope,
+        body: entry.body,
+      }),
+  });
+}
+
+export function buildBncrInboundHistory(args: {
+  historyMap: BncrGroupHistoryMap;
+  parsed: ParsedInbound;
+}) {
+  const historyKey = buildBncrGroupHistoryKey(args.parsed);
+  if (!historyKey) return undefined;
+  return createChannelHistoryWindow({ historyMap: args.historyMap }).buildInboundHistory({
+    historyKey,
+    limit: DEFAULT_GROUP_HISTORY_LIMIT,
+  });
+}
+
+export function clearBncrPendingGroupHistory(args: {
+  historyMap: BncrGroupHistoryMap;
+  parsed: ParsedInbound;
+}) {
+  const historyKey = buildBncrGroupHistoryKey(args.parsed);
+  if (!historyKey) return;
+  createChannelHistoryWindow({ historyMap: args.historyMap }).clear({
+    historyKey,
+    limit: DEFAULT_GROUP_HISTORY_LIMIT,
+  });
+}

package/src/messaging/inbound/native-command-runtime.ts

@@ -53,12 +53,12 @@ export function buildNativeCommandHandledResult(args: {
 
 export function buildBncrNativeCommandSessionState(args: {
   parsed: ParsedInbound;
-  canonicalAgentId: string;
+  sessionAgentId: string;
   resolvedRoute: { sessionKey: string };
 }) {
-  const { parsed, canonicalAgentId, resolvedRoute } = args;
+  const { parsed, sessionAgentId, resolvedRoute } = args;
   const baseSessionKey =
-    normalizeInboundSessionKey(parsed.sessionKeyfromroute, parsed.route, canonicalAgentId) ||
+    normalizeInboundSessionKey(parsed.sessionKeyfromroute, parsed.route, sessionAgentId) ||
     resolvedRoute.sessionKey;
   const taskSessionKey = withTaskSessionKey(baseSessionKey, parsed.extracted.taskKey);
   const sessionKey = taskSessionKey || baseSessionKey;
@@ -87,71 +87,87 @@ export function createNativeCommandTurnContext(args: {
   senderDisplayName: string;
   body: string;
 }): BncrInboundContextPayload | Promise<BncrInboundContextPayload> {
-  return resolveBncrChannelInboundRuntime(args.api).buildContext({
-    channel: args.channelId,
-    provider: args.channelId,
-    surface: args.channelId,
-    accountId: args.accountId,
-    messageId: args.msgId,
-    timestamp: Date.now(),
-    from: args.senderIdForContext,
-    sender: {
-      id: args.senderIdForContext,
-      name: args.senderDisplayName,
-      username: args.senderDisplayName,
-    },
-    conversation: {
-      kind: args.peer.kind,
-      id: args.peer.id,
-      label: args.displayTo,
-      routePeer: {
+  return Promise.resolve(
+    resolveBncrChannelInboundRuntime(args.api).buildContext({
+      channel: args.channelId,
+      provider: args.channelId,
+      surface: args.channelId,
+      accountId: args.accountId,
+      messageId: args.msgId,
+      timestamp: Date.now(),
+      from: args.senderIdForContext,
+      sender: {
+        id: args.senderIdForContext,
+        name: args.senderDisplayName,
+        username: args.senderDisplayName,
+      },
+      conversation: {
         kind: args.peer.kind,
         id: args.peer.id,
+        label: args.displayTo,
+        routePeer: {
+          kind: args.peer.kind,
+          id: args.peer.id,
+        },
       },
-    },
-    route: {
-      agentId: args.resolvedRoute.agentId,
-      accountId: args.accountId,
-      routeSessionKey: args.resolvedRoute.sessionKey,
-      dispatchSessionKey: args.sessionKey,
-      mainSessionKey: args.resolvedRoute.mainSessionKey,
-    },
-    reply: {
-      to: args.displayTo,
-      originatingTo: args.originatingTo,
-      replyToId: args.msgId,
-    },
-    message: {
-      inboundEventKind: 'user_request',
-      body: args.body,
-      rawBody: args.body,
-      bodyForAgent: args.body,
-      commandBody: args.body,
-      envelopeFrom: args.originatingTo,
-      senderLabel: args.senderDisplayName,
-    },
-    commandTurn: {
+      route: {
+        agentId: args.resolvedRoute.agentId,
+        accountId: args.accountId,
+        routeSessionKey: args.resolvedRoute.sessionKey,
+        dispatchSessionKey: args.sessionKey,
+        mainSessionKey: args.resolvedRoute.mainSessionKey,
+      },
+      reply: {
+        to: args.displayTo,
+        originatingTo: args.originatingTo,
+        replyToId: args.msgId,
+      },
+      message: {
+        inboundEventKind: 'user_request',
+        body: args.body,
+        rawBody: args.body,
+        bodyForAgent: args.body,
+        commandBody: args.body,
+        envelopeFrom: args.originatingTo,
+        senderLabel: args.senderDisplayName,
+      },
+      commandTurn: {
+        kind: 'native',
+        source: 'native',
+        authorized: true,
+        body: args.body,
+      },
+      access: {
+        mentions: {
+          canDetectMention: true,
+          wasMentioned: true,
+          effectiveWasMentioned: true,
+        },
+        commands: {
+          authorized: true,
+          allowTextCommands: true,
+          useAccessGroups: false,
+          authorizers: [],
+        },
+      },
+      extra: {
+        OriginatingChannel: args.channelId,
+      },
+    }),
+  ).then((ctx) => {
+    ctx.From = args.senderIdForContext;
+    ctx.To = args.displayTo;
+    ctx.SenderId = args.senderIdForContext;
+    ctx.OriginatingChannel = args.channelId;
+    ctx.CommandAuthorized = true;
+    ctx.CommandSource = 'native';
+    ctx.CommandTurn = {
       kind: 'native',
       source: 'native',
       authorized: true,
       body: args.body,
-    },
-    access: {
-      mentions: {
-        canDetectMention: true,
-        wasMentioned: true,
-        effectiveWasMentioned: true,
-      },
-      commands: {
-        authorized: true,
-        allowTextCommands: true,
-        useAccessGroups: false,
-        authorizers: [],
-      },
-    },
-    extra: {
-      OriginatingChannel: args.channelId,
-    },
+    };
+    return ctx;
   });
 }
 

package/src/messaging/inbound/native-command.ts

@@ -2,6 +2,11 @@ export type NativeCommand = {
   command: string;
   raw: string;
   body: string;
+  argsText: string;
+};
+
+export type ParseBncrNativeCommandOptions = {
+  allowBareWhoami?: boolean;
 };
 
 export type NativeVerboseCommand = {
@@ -10,27 +15,106 @@ export type NativeVerboseCommand = {
   text: string;
 };
 
-export function parseBncrNativeCommand(text: string): NativeCommand | null {
+export type NativeHelpCommand = {
+  handled: true;
+  text: string;
+};
+
+export type NativeWhoamiCommand = {
+  handled: true;
+  text: string;
+};
+
+const BNCR_HELP_TEXT = [
+  '🦞 Bncr command usage',
+  '',
+  '📌 Bncr builtins',
+  '  • /bncr whoami',
+  '  • /bncr verbose on|off|full',
+  '',
+  '🛡 Scene approval',
+  '  • /bncr allow [<platform>:<groupId>]',
+  '  • /bncr deny [<platform>:<groupId>]',
+  '  • /bncr bind <agentId> [<platform>:<groupId>]',
+  '  • /bncr mode',
+  '  • /bncr mode help',
+  '  • /bncr mode <admin|mention|hybrid|all> [<platform>:<groupId>]',
+  '  • /bncr revoke [<platform>:<groupId>]',
+  '  • /bncr list pending',
+  '  • /bncr list scenes',
+].join('\n');
+
+const BNCR_NATIVE_COMMANDS = new Set([
+  'help',
+  'whoami',
+  'verbose',
+  'allow',
+  'deny',
+  'bind',
+  'mode',
+  'revoke',
+  'list',
+]);
+
+export function parseBncrNativeCommand(
+  text: string,
+  options?: ParseBncrNativeCommandOptions,
+): NativeCommand | null {
   const raw = String(text || '').trim();
-  if (!raw.startsWith('/')) return null;
-  const match = raw.match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/i);
+  const allowBareWhoami = options?.allowBareWhoami !== false;
+  if (allowBareWhoami && raw.toLowerCase() === '/whoami') {
+    return { command: 'whoami', raw, body: '/whoami', argsText: '' };
+  }
+  if (!raw.startsWith('/bncr')) return null;
+  const match = raw.match(/^\/bncr(?:@[A-Za-z0-9_]+)?(?:\s+([^\s]+)(?:\s+([\s\S]*))?)?$/i);
   if (!match) return null;
 
-  const command = String(match[1] || '')
+  const command = String(match[1] || 'help')
     .trim()
     .toLowerCase();
   if (!command) return null;
+  if (!BNCR_NATIVE_COMMANDS.has(command)) return null;
 
-  const rest = String(match[2] || '').trim();
-  const body = command === 'help' ? ['/commands', rest].filter(Boolean).join(' ') : raw;
-  return { command, raw, body };
+  const argsText = String(match[2] || '').trim();
+  const body =
+    command === 'help' ? '/commands' : [`/${command}`, argsText].filter(Boolean).join(' ');
+  return { command, raw, body, argsText };
+}
+
+export function resolveBncrNativeHelpCommand(command: NativeCommand): NativeHelpCommand | null {
+  if (command.command !== 'help') return null;
+  return { handled: true, text: BNCR_HELP_TEXT };
+}
+
+export function resolveBncrNativeWhoamiCommand(args: {
+  command: NativeCommand;
+  platform: string;
+  groupId: string;
+  groupName?: string;
+  userId: string;
+  userName?: string;
+  isGroup: boolean;
+  isAdmin: boolean;
+}): NativeWhoamiCommand | null {
+  if (args.command.command !== 'whoami') return null;
+  const lines = ['🧭 Bncr Identity', ''];
+  lines.push(`Platform: ${args.platform || '(unknown)'}`);
+  lines.push(`User: ${args.userName || '(unknown)'} (${args.userId || '0'})`);
+  if (args.isGroup) {
+    lines.push(`Group: ${args.groupName || '(unknown)'} (${args.groupId || '0'})`);
+    lines.push(`Scene: ${args.platform || '(unknown)'}:${args.groupId || '0'}`);
+  } else {
+    lines.push(`Scene: ${args.platform || '(unknown)'}:${args.userId || '0'}`);
+  }
+  lines.push(`Admin: ${args.isAdmin ? 'true' : 'false'}`);
+  return { handled: true, text: lines.join('\n') };
 }
 
 export function resolveBncrNativeVerboseCommand(
   command: NativeCommand,
 ): NativeVerboseCommand | null {
   if (command.command !== 'verbose') return null;
-  const rawLevel = String(command.raw.slice('/verbose'.length) || '')
+  const rawLevel = String(command.argsText || '')
     .trim()
     .toLowerCase();
   if (!rawLevel || rawLevel === 'status') {

package/src/messaging/inbound/parse.ts

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { normalizeAccountId } from '../../core/accounts.ts';
 import { extractInlineTaskKey } from '../../core/targets.ts';
 import type { BncrRoute } from '../../core/types.ts';
-import type { BncrInboundParamsInput } from './contracts.ts';
+import type { BncrInboundMediaItem, BncrInboundParamsInput } from './contracts.ts';
 
 function asString(v: unknown, fallback = ''): string {
   if (typeof v === 'string') return v;
@@ -10,6 +10,84 @@ function asString(v: unknown, fallback = ''): string {
   return String(v);
 }
 
+function asBoolean(v: unknown, fallback = false): boolean {
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'number') return v !== 0;
+  if (typeof v === 'string') {
+    const raw = v.trim().toLowerCase();
+    if (!raw) return fallback;
+    if (['true', '1', 'yes', 'y', 'on'].includes(raw)) return true;
+    if (['false', '0', 'no', 'n', 'off'].includes(raw)) return false;
+  }
+  return fallback;
+}
+
+function asStringArray(v: unknown): string[] {
+  if (Array.isArray(v)) {
+    return v.map((item) => asString(item).trim()).filter(Boolean);
+  }
+  if (typeof v === 'string') {
+    return v
+      .split(',')
+      .map((item) => item.trim())
+      .filter(Boolean);
+  }
+  return [];
+}
+
+function asInboundMediaItems(params: BncrInboundParamsInput): BncrInboundMediaItem[] {
+  const normalized: BncrInboundMediaItem[] = [];
+  const rawList = Array.isArray(params?.mediaList) ? params.mediaList : [];
+  for (const item of rawList) {
+    if (!item || typeof item !== 'object') continue;
+    const path = asString((item as { path?: unknown }).path || '').trim();
+    const base64 = asString((item as { base64?: unknown }).base64 || '').trim();
+    const mimeType = asString((item as { mimeType?: unknown }).mimeType || '').trim();
+    const fileName = asString((item as { fileName?: unknown }).fileName || '').trim();
+    const type = asString((item as { type?: unknown }).type || '').trim();
+    const transferId = asString((item as { transferId?: unknown }).transferId || '').trim();
+    if (!path && !base64) continue;
+    normalized.push({
+      ...(path ? { path } : {}),
+      ...(base64 ? { base64 } : {}),
+      ...(mimeType ? { mimeType } : {}),
+      ...(fileName ? { fileName } : {}),
+      ...(type ? { type } : {}),
+      ...(transferId ? { transferId } : {}),
+    });
+  }
+
+  if (normalized.length > 0) return normalized;
+
+  const legacyPath = asString(params?.path || '').trim();
+  const legacyBase64 = asString(params?.base64 || '').trim();
+  const legacyMimeType = asString(params?.mimeType || '').trim();
+  const legacyFileName = asString(params?.fileName || '').trim();
+  const legacyType = asString(params?.type || '').trim();
+  const legacyTransferId = asString((params as { transferId?: unknown })?.transferId || '').trim();
+  if (legacyPath || legacyBase64) {
+    return [
+      {
+        ...(legacyPath ? { path: legacyPath } : {}),
+        ...(legacyBase64 ? { base64: legacyBase64 } : {}),
+        ...(legacyMimeType ? { mimeType: legacyMimeType } : {}),
+        ...(legacyFileName ? { fileName: legacyFileName } : {}),
+        ...(legacyType ? { type: legacyType } : {}),
+        ...(legacyTransferId ? { transferId: legacyTransferId } : {}),
+      },
+    ];
+  }
+
+  const legacyPaths = asStringArray(params?.paths);
+  return legacyPaths.map((item) => ({
+    path: item,
+    ...(legacyMimeType ? { mimeType: legacyMimeType } : {}),
+    ...(legacyFileName ? { fileName: legacyFileName } : {}),
+    ...(legacyType ? { type: legacyType } : {}),
+    ...(legacyTransferId ? { transferId: legacyTransferId } : {}),
+  }));
+}
+
 export function inboundDedupKey(params: {
   accountId: string;
   platform: string;
@@ -36,24 +114,30 @@ export function inboundDedupKey(params: {
   return `${accountId}|${platform}|${groupId}|${userId}|hash:${digest}`;
 }
 
-export function resolveChatType(_route: BncrRoute): 'direct' | 'group' {
-  // Compatibility boundary: bncr currently records and dispatches all conversations as direct
-  // sessions even when the display scope contains a group id. Do not change this to true
-  // group semantics without updating session routing, reply target policy, and requireMention
-  // behavior together.
+export function resolveChatType(route: BncrRoute, isGroup: boolean): 'direct' | 'group' {
+  if (isGroup) return 'group';
+  if (route.groupId !== '0') return 'group';
   return 'direct';
 }
 
 export function parseBncrInboundParams(params: BncrInboundParamsInput) {
   const accountId = normalizeAccountId(asString(params?.accountId || ''));
+  const protocolVersion = asString(params?.protocolVersion || '').trim() || undefined;
+  const capabilities = asStringArray(params?.capabilities);
   const platform = asString(params?.platform || '').trim();
   const groupId = asString(params?.groupId || '0').trim() || '0';
+  const groupName = asString(params?.groupName || '').trim();
   const userId = asString(params?.userId || '').trim();
+  const userName = asString(params?.userName || '').trim();
   const sessionKeyfromroute = asString(params?.sessionKey || '').trim();
   const providedOriginatingTo =
     asString(params?.originatingTo || params?.providedOriginatingTo || params?.to || '').trim() ||
     undefined;
   const clientId = asString(params?.clientId || '').trim() || undefined;
+  const bridgeId = asString(params?.bridgeId || params?.clientId || '').trim() || undefined;
+  const bridgeName = asString(params?.bridgeName || 'Bncr').trim() || 'Bncr';
+  const isGroup = asBoolean(params?.isGroup, groupId !== '0');
+  const isAdmin = asBoolean(params?.isAdmin, false);
 
   const route: BncrRoute = {
     platform,
@@ -63,11 +147,17 @@ export function parseBncrInboundParams(params: BncrInboundParamsInput) {
 
   const text = asString(params?.msg || '');
   const msgType = asString(params?.type || 'text') || 'text';
+  const mediaItems = asInboundMediaItems(params);
   const mediaBase64 = asString(params?.base64 || '');
   const mediaPathFromTransfer = asString(params?.path || '').trim();
   const mimeType = asString(params?.mimeType || '').trim() || undefined;
   const fileName = asString(params?.fileName || '').trim() || undefined;
   const msgId = asString(params?.msgId || '').trim() || undefined;
+  const shouldRespond = asBoolean(params?.shouldRespond, false);
+  const triggerKind = asString(params?.triggerKind || 'none').trim() || 'none';
+  const botName = asString(params?.botName || '').trim();
+  const isBotMentioned = asBoolean(params?.isBotMentioned, false);
+  const isReplyToBot = asBoolean(params?.isReplyToBot, false);
 
   const dedupKey = inboundDedupKey({
     accountId,
@@ -79,29 +169,44 @@ export function parseBncrInboundParams(params: BncrInboundParamsInput) {
     mediaBase64,
   });
 
+  const peerKind = resolveChatType(route, isGroup);
   const peer = {
-    kind: resolveChatType(route),
-    id: route.groupId === '0' ? route.userId : route.groupId,
+    kind: peerKind,
+    id: peerKind === 'group' ? route.groupId : route.userId,
   } as const;
 
   const extracted = extractInlineTaskKey(text);
 
   return {
     accountId,
+    protocolVersion,
+    capabilities,
     platform,
     groupId,
+    groupName,
     userId,
+    userName,
     sessionKeyfromroute,
     providedOriginatingTo,
     clientId,
+    bridgeId,
+    bridgeName,
+    isGroup,
+    isAdmin,
     route,
     text,
     msgType,
+    mediaItems,
     mediaBase64,
     mediaPathFromTransfer,
     mimeType,
     fileName,
     msgId,
+    shouldRespond,
+    triggerKind,
+    botName,
+    isBotMentioned,
+    isReplyToBot,
     dedupKey,
     peer,
     extracted,