@xmoxmo/bncr 0.4.6 → 0.4.8

package/src/messaging/inbound/context-facts.ts

@@ -19,6 +19,27 @@ export type BncrStructuredContextFactsInput = {
   sender: {
     id: string;
     displayName?: string;
+    userId?: string;
+    userName?: string;
+    bridgeId?: string;
+    bridgeName?: string;
+    isAdmin?: boolean;
+    isOwner?: boolean;
+    isAuthorizedSender?: boolean;
+    role?: 'owner' | 'admin' | 'user';
+  };
+  platform?: string;
+  group?: {
+    id?: string;
+    name?: string;
+    isGroup?: boolean;
+  };
+  trigger?: {
+    shouldRespond?: boolean;
+    triggerKind?: string;
+    botName?: string;
+    isBotMentioned?: boolean;
+    isReplyToBot?: boolean;
   };
   message: {
     id?: string | null;
@@ -60,6 +81,27 @@ export function buildBncrStructuredContextFacts(input: BncrStructuredContextFact
     sender: {
       id: input.sender.id,
       displayName: input.sender.displayName || input.sender.id,
+      userId: input.sender.userId,
+      userName: input.sender.userName,
+      bridgeId: input.sender.bridgeId,
+      bridgeName: input.sender.bridgeName,
+      isAdmin: input.sender.isAdmin,
+      ...(input.sender.isOwner === true ? { isOwner: true } : {}),
+      ...(input.sender.isAuthorizedSender === true ? { isAuthorizedSender: true } : {}),
+      ...(input.sender.role !== undefined ? { role: input.sender.role } : {}),
+    },
+    platform: input.platform,
+    group: {
+      id: input.group?.id,
+      name: input.group?.name,
+      isGroup: input.group?.isGroup,
+    },
+    trigger: {
+      shouldRespond: input.trigger?.shouldRespond,
+      triggerKind: input.trigger?.triggerKind,
+      botName: input.trigger?.botName,
+      isBotMentioned: input.trigger?.isBotMentioned,
+      isReplyToBot: input.trigger?.isReplyToBot,
     },
     message: {
       id: input.message.id || undefined,
@@ -85,6 +127,15 @@ export function buildBncrPromptVisibleContextFacts(
   facts: ReturnType<typeof buildBncrStructuredContextFacts>,
 ) {
   const result: {
+    trigger?: {
+      botName?: string;
+    };
+    sender?: {
+      isAdmin?: boolean;
+      isOwner?: boolean;
+      isAuthorizedSender?: boolean;
+      role?: 'owner' | 'admin' | 'user';
+    };
     reply?: {
       to: string;
       originatingTo: string;
@@ -96,6 +147,30 @@ export function buildBncrPromptVisibleContextFacts(
     }>;
   } = {};
 
+  if (
+    facts.sender.isAdmin === true ||
+    facts.sender.isOwner === true ||
+    facts.sender.isAuthorizedSender === true ||
+    facts.sender.role === 'owner' ||
+    facts.sender.role === 'admin'
+  ) {
+    const sender = {
+      ...(facts.sender.isAdmin === true ? { isAdmin: true } : {}),
+      ...(facts.sender.isOwner === true ? { isOwner: true } : {}),
+      ...(facts.sender.isAuthorizedSender === true ? { isAuthorizedSender: true } : {}),
+      ...(facts.sender.role === 'owner' || facts.sender.role === 'admin'
+        ? { role: facts.sender.role }
+        : {}),
+    };
+    if (Object.keys(sender).length > 0) result.sender = sender;
+  }
+
+  if (facts.trigger.botName) {
+    result.trigger = {
+      botName: facts.trigger.botName,
+    };
+  }
+
   if (facts.reply.originatingTo !== facts.reply.to) {
     result.reply = {
       to: facts.reply.to,
@@ -125,11 +200,25 @@ export type BncrStructuredContextFactsFromInboundPartsInput = {
   channelId: string;
   parsed: {
     accountId: string;
+    platform?: string;
     peer: {
       kind: string;
       id: string;
     };
     clientId?: string;
+    bridgeId?: string;
+    bridgeName?: string;
+    groupId?: string;
+    groupName?: string;
+    userId?: string;
+    userName?: string;
+    isGroup?: boolean;
+    isAdmin?: boolean;
+    shouldRespond?: boolean;
+    triggerKind?: string;
+    botName?: string;
+    isBotMentioned?: boolean;
+    isReplyToBot?: boolean;
     msgId?: string;
     mimeType?: string;
   };
@@ -147,18 +236,24 @@ export type BncrStructuredContextFactsFromInboundPartsInput = {
   prepared: {
     rawBody: string;
     body?: string;
-    mediaPath?: string | null;
-    mediaContentType?: string;
+    mediaItems?: Array<{
+      path: string;
+      contentType?: string;
+      kind?: string;
+    }>;
   };
   senderIdForContext: string;
   senderDisplayName?: string;
+  bridgeSenderId?: string;
+  bridgeSenderName?: string;
+  senderIsOwner?: boolean;
+  senderIsAuthorized?: boolean;
 };
 
 export function buildBncrStructuredContextFactsFromInboundParts(
   input: BncrStructuredContextFactsFromInboundPartsInput,
 ) {
-  const mediaPath = input.prepared.mediaPath || undefined;
-  const mediaContentType = input.prepared.mediaContentType || input.parsed.mimeType;
+  const mediaItems = Array.isArray(input.prepared.mediaItems) ? input.prepared.mediaItems : [];
   return buildBncrStructuredContextFacts({
     channelId: input.channelId,
     accountId: input.parsed.accountId,
@@ -180,6 +275,27 @@ export function buildBncrStructuredContextFactsFromInboundParts(
     sender: {
       id: input.senderIdForContext,
       displayName: input.senderDisplayName,
+      userId: input.parsed.userId,
+      userName: input.parsed.userName,
+      bridgeId: input.bridgeSenderId || input.parsed.bridgeId || input.parsed.clientId,
+      bridgeName: input.bridgeSenderName || input.parsed.bridgeName,
+      isAdmin: input.parsed.isAdmin,
+      isOwner: input.senderIsOwner === true ? true : undefined,
+      isAuthorizedSender: input.senderIsAuthorized === true ? true : undefined,
+      role: input.senderIsOwner ? 'owner' : input.parsed.isAdmin ? 'admin' : undefined,
+    },
+    platform: input.parsed.platform,
+    group: {
+      id: input.parsed.groupId,
+      name: input.parsed.groupName,
+      isGroup: input.parsed.isGroup,
+    },
+    trigger: {
+      shouldRespond: input.parsed.shouldRespond,
+      triggerKind: input.parsed.triggerKind,
+      botName: input.parsed.botName,
+      isBotMentioned: input.parsed.isBotMentioned,
+      isReplyToBot: input.parsed.isReplyToBot,
     },
     message: {
       id: input.parsed.msgId,
@@ -188,15 +304,11 @@ export function buildBncrStructuredContextFactsFromInboundParts(
       commandBody: input.prepared.rawBody,
       envelopeBody: input.prepared.body,
     },
-    media: mediaPath
-      ? [
-          {
-            path: mediaPath,
-            contentType: mediaContentType,
-            kind: inferBncrStructuredMediaKind(mediaContentType),
-            messageId: input.parsed.msgId,
-          },
-        ]
-      : [],
+    media: mediaItems.map((item) => ({
+      path: item.path,
+      contentType: item.contentType,
+      kind: item.kind || inferBncrStructuredMediaKind(item.contentType),
+      messageId: input.parsed.msgId,
+    })),
   });
 }

package/src/messaging/inbound/contracts.ts

@@ -15,21 +15,45 @@ export type BncrInboundParsedPeer = OpenClawChannelPeer;
 
 export type BncrInboundParamsInput = {
   accountId?: unknown;
+  protocolVersion?: unknown;
+  capabilities?: unknown;
   platform?: unknown;
   groupId?: unknown;
+  groupName?: unknown;
   userId?: unknown;
+  userName?: unknown;
   sessionKey?: unknown;
   originatingTo?: unknown;
   providedOriginatingTo?: unknown;
   to?: unknown;
   clientId?: unknown;
+  bridgeId?: unknown;
+  bridgeName?: unknown;
+  isGroup?: unknown;
+  isAdmin?: unknown;
   msg?: unknown;
   type?: unknown;
   base64?: unknown;
   path?: unknown;
+  paths?: unknown;
+  mediaList?: unknown;
   mimeType?: unknown;
   fileName?: unknown;
   msgId?: unknown;
+  shouldRespond?: unknown;
+  triggerKind?: unknown;
+  botName?: unknown;
+  isBotMentioned?: unknown;
+  isReplyToBot?: unknown;
+};
+
+export type BncrInboundMediaItem = {
+  path?: string;
+  base64?: string;
+  mimeType?: string;
+  fileName?: string;
+  type?: string;
+  transferId?: string;
 };
 
 export type BncrRememberSessionRoute = (

package/src/messaging/inbound/dispatch-prep.ts

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import { hasControlCommand } from 'openclaw/plugin-sdk/command-auth';
 import {
   formatDisplayScope,
   normalizeInboundSessionKey,
@@ -19,6 +20,7 @@ import {
 } from '../../openclaw/routing-runtime.ts';
 import type { BncrInboundApi, BncrInboundConfig, BncrRememberSessionRoute } from './contracts.ts';
 import { INBOUND_MEDIA_URL_MAX_BYTES, isHttpMediaUrl } from './media-url-download.ts';
+import { parseBncrNativeCommand } from './native-command.ts';
 import { loadInboundRemoteMedia } from './remote-media.ts';
 
 export type ParsedInbound = ReturnType<typeof import('./parse.ts')['parseBncrInboundParams']>;
@@ -27,6 +29,7 @@ export type BncrInboundConversationResolution = {
   accountId: string;
   chatType: 'direct' | 'group';
   route: ParsedInbound['route'];
+  originalResolvedRouteSessionKey: string;
   resolvedRoute: {
     sessionKey: string;
     agentId: string;
@@ -51,6 +54,13 @@ export type BncrInboundReplyRouteFact = {
 
 export type BncrPreparedInboundSessionContext = {
   storePath: string;
+  mediaItems: Array<{
+    path: string;
+    contentType?: string;
+    fileName?: string;
+    kind: 'image' | 'video' | 'audio' | 'document';
+    transferId?: string;
+  }>;
   mediaPath?: string;
   mediaContentType?: string;
   rawBody: string;
@@ -63,10 +73,27 @@ export type BncrInboundPreparation = {
   replyRouteFact: BncrInboundReplyRouteFact;
   senderIdForContext: string;
   senderDisplayName: string;
+  ownerAllowFrom?: string[];
+  bridgeSenderId?: string;
+  bridgeSenderName?: string;
 };
 
 const INBOUND_MEDIA_MAX_BYTES = 30 * 1024 * 1024;
 
+const BNCR_GENERIC_MEDIA_TEXTS = new Set([
+  '收到媒体文件',
+  '收到图片',
+  '收到视频',
+  '收到语音',
+  '收到音频',
+  '收到文件',
+  '[图片]',
+  '[视频]',
+  '[语音]',
+  '[音频]',
+  '[文件]',
+]);
+
 function assertResolvedAgentRoute(resolvedRoute: OpenClawResolvedAgentRoute): {
   sessionKey: string;
   agentId: string;
@@ -90,14 +117,140 @@ function formatRawBncrInboundTarget(route: ParsedInbound['route']): string {
   return `Bncr:${String(route.platform || '').trim()}:${String(route.groupId || '').trim()}:${String(route.userId || '').trim()}`;
 }
 
+function inferBncrInboundMediaKind(args: {
+  msgType?: string;
+  mediaContentType?: string;
+}): 'image' | 'video' | 'audio' | 'document' {
+  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';
+  return 'document';
+}
+
+function isBncrGenericMediaText(value: string): boolean {
+  const normalized = String(value || '').trim();
+  if (!normalized) return true;
+  return BNCR_GENERIC_MEDIA_TEXTS.has(normalized);
+}
+
+function resolveBncrInboundRawBody(args: {
+  extractedText?: string;
+  msgType?: string;
+  mediaItems?: Array<{ contentType?: string; kind?: string }>;
+}) {
+  const text = String(args.extractedText || '').trim();
+  if (
+    String(args.msgType || 'text')
+      .trim()
+      .toLowerCase() === 'text'
+  )
+    return text;
+  if (text && !isBncrGenericMediaText(text)) return text;
+  const items = Array.isArray(args.mediaItems) ? args.mediaItems : [];
+  if (items.length === 0) {
+    const mediaKind = inferBncrInboundMediaKind({
+      msgType: args.msgType,
+      mediaContentType: undefined,
+    });
+    return `<media:${mediaKind}>`;
+  }
+  const kinds = items
+    .map((item) =>
+      String(item?.kind || '')
+        .trim()
+        .toLowerCase(),
+    )
+    .filter(Boolean);
+  const contentTypes = items.map((item) => String(item?.contentType || '').trim()).filter(Boolean);
+  const firstKind =
+    kinds[0] ||
+    inferBncrInboundMediaKind({
+      msgType: args.msgType,
+      mediaContentType: contentTypes[0],
+    });
+  const uniformKind =
+    kinds.length > 0 && kinds.every((candidate) => candidate === firstKind)
+      ? firstKind
+      : 'document';
+  const count = Math.max(items.length, 1);
+  if (count <= 1) return `<media:${uniformKind}>`;
+  if (uniformKind === 'image') return `<media:image> (${count} images)`;
+  if (uniformKind === 'video') return `<media:video> (${count} videos)`;
+  if (uniformKind === 'audio') return `<media:audio> (${count} audio attachments)`;
+  return `<media:document> (${count} attachments)`;
+}
+
+async function saveBncrInboundMediaItem(args: {
+  api: BncrInboundApi;
+  item: ParsedInbound['mediaItems'][number];
+}) {
+  const pathFromTransfer = String(args.item?.path || '').trim();
+  const base64 = String(args.item?.base64 || '').trim();
+  const mimeType = String(args.item?.mimeType || '').trim() || undefined;
+  const fileName = String(args.item?.fileName || '').trim() || undefined;
+  const transferId = String(args.item?.transferId || '').trim() || undefined;
+  let mediaPath: string | undefined;
+  let mediaContentType = mimeType;
+  if (base64) {
+    const mediaBuf = decodeInboundMediaBase64(base64);
+    const saved = await saveOpenClawChannelMediaBuffer(
+      args.api,
+      mediaBuf,
+      mimeType,
+      'inbound',
+      30 * 1024 * 1024,
+      fileName,
+    );
+    mediaPath = saved.path;
+  } else if (pathFromTransfer && isHttpMediaUrl(pathFromTransfer)) {
+    const downloaded = await loadInboundRemoteMedia(
+      args.api,
+      pathFromTransfer,
+      INBOUND_MEDIA_URL_MAX_BYTES,
+    );
+    mediaContentType = downloaded.contentType || mimeType;
+    const saved = await saveOpenClawChannelMediaBuffer(
+      args.api,
+      downloaded.buffer,
+      mediaContentType,
+      'inbound',
+      INBOUND_MEDIA_URL_MAX_BYTES,
+      fileName,
+    );
+    mediaPath = saved.path;
+  } else if (pathFromTransfer && fs.existsSync(pathFromTransfer)) {
+    mediaPath = pathFromTransfer;
+  }
+  if (!mediaPath) return null;
+  const kind = inferBncrInboundMediaKind({
+    msgType: String(args.item?.type || '').trim(),
+    mediaContentType: mediaContentType || mimeType,
+  });
+  return {
+    path: mediaPath,
+    ...(mediaContentType ? { contentType: mediaContentType } : {}),
+    ...(fileName ? { fileName } : {}),
+    kind,
+    ...(transferId ? { transferId } : {}),
+  };
+}
+
 export function resolveBncrInboundConversation(args: {
   api: BncrInboundApi;
   cfg: BncrInboundConfig;
   channelId: string;
   parsed: ParsedInbound;
   canonicalAgentId: string;
+  resolvedAgentId?: string;
 }) {
-  const { api, cfg, channelId, parsed, canonicalAgentId } = args;
+  const { api, cfg, channelId, parsed, canonicalAgentId, resolvedAgentId } = args;
   const { accountId, route, peer, sessionKeyfromroute, providedOriginatingTo, extracted } = parsed;
 
   const resolvedRoute = assertResolvedAgentRoute(
@@ -109,8 +262,9 @@ export function resolveBncrInboundConversation(args: {
     }),
   );
 
+  const targetAgentId = (resolvedAgentId || '').trim() || resolvedRoute.agentId || canonicalAgentId;
   const baseSessionKey =
-    normalizeInboundSessionKey(sessionKeyfromroute, route, canonicalAgentId) ||
+    normalizeInboundSessionKey(sessionKeyfromroute, route, targetAgentId) ||
     resolvedRoute.sessionKey;
   const taskSessionKey = withTaskSessionKey(baseSessionKey, extracted.taskKey);
   const dispatchSessionKey = taskSessionKey || baseSessionKey;
@@ -122,7 +276,12 @@ export function resolveBncrInboundConversation(args: {
     accountId,
     chatType: peer.kind,
     route,
-    resolvedRoute,
+    originalResolvedRouteSessionKey: resolvedRoute.sessionKey,
+    resolvedRoute: {
+      ...resolvedRoute,
+      agentId: targetAgentId || resolvedRoute.agentId,
+      sessionKey: baseSessionKey || resolvedRoute.sessionKey,
+    },
     canonicalTo,
     rawTo,
     originatingTo,
@@ -198,40 +357,38 @@ export async function prepareBncrInboundSessionContext(args: {
     agentId: resolvedRoute.agentId,
   });
 
-  let mediaPath: string | undefined;
-  let mediaContentType = mimeType;
-  if (mediaBase64) {
-    const mediaBuf = decodeInboundMediaBase64(mediaBase64);
-    const saved = await saveOpenClawChannelMediaBuffer(
-      api,
-      mediaBuf,
-      mimeType,
-      'inbound',
-      30 * 1024 * 1024,
-      fileName,
-    );
-    mediaPath = saved.path;
-  } else if (mediaPathFromTransfer && isHttpMediaUrl(mediaPathFromTransfer)) {
-    const downloaded = await loadInboundRemoteMedia(
-      api,
-      mediaPathFromTransfer,
-      INBOUND_MEDIA_URL_MAX_BYTES,
-    );
-    mediaContentType = downloaded.contentType || mimeType;
-    const saved = await saveOpenClawChannelMediaBuffer(
-      api,
-      downloaded.buffer,
-      mediaContentType,
-      'inbound',
-      INBOUND_MEDIA_URL_MAX_BYTES,
-      fileName,
-    );
-    mediaPath = saved.path;
-  } else if (mediaPathFromTransfer && fs.existsSync(mediaPathFromTransfer)) {
-    mediaPath = mediaPathFromTransfer;
-  }
+  const parsedMediaItems = Array.isArray(parsed.mediaItems) ? parsed.mediaItems : [];
+  const fallbackMediaItems =
+    parsedMediaItems.length > 0
+      ? parsedMediaItems
+      : [
+          {
+            ...(mediaPathFromTransfer ? { path: mediaPathFromTransfer } : {}),
+            ...(mediaBase64 ? { base64: mediaBase64 } : {}),
+            ...(mimeType ? { mimeType } : {}),
+            ...(fileName ? { fileName } : {}),
+            ...(msgType ? { type: msgType } : {}),
+          },
+        ];
+  const mediaItems = (
+    await Promise.all(
+      fallbackMediaItems.map((item) =>
+        saveBncrInboundMediaItem({
+          api,
+          item,
+        }),
+      ),
+    )
+  ).filter((item): item is NonNullable<typeof item> => Boolean(item));
+  const primaryMedia = mediaItems[0];
+  const mediaPath = primaryMedia?.path;
+  const mediaContentType = primaryMedia?.contentType || mimeType;
 
-  const rawBody = extracted.text || (msgType === 'text' ? '' : `[${msgType}]`);
+  const rawBody = resolveBncrInboundRawBody({
+    extractedText: extracted.text,
+    msgType,
+    mediaItems,
+  });
   const body = formatOpenClawAgentEnvelope(api, {
     channel: 'Bncr',
     from: `${platform}:${groupId}:${userId}`,
@@ -246,6 +403,7 @@ export async function prepareBncrInboundSessionContext(args: {
 
   return {
     storePath,
+    mediaItems,
     mediaPath,
     mediaContentType,
     rawBody,
@@ -272,15 +430,18 @@ export async function prepareBncrInboundDispatch(args: {
   cfg: BncrInboundConfig;
   parsed: ParsedInbound;
   canonicalAgentId: string;
+  resolvedAgentId?: string;
   rememberSessionRoute: BncrRememberSessionRoute;
 }) {
-  const { api, channelId, cfg, parsed, canonicalAgentId, rememberSessionRoute } = args;
+  const { api, channelId, cfg, parsed, canonicalAgentId, resolvedAgentId, rememberSessionRoute } =
+    args;
   const resolution = resolveBncrInboundConversation({
     api,
     cfg,
     channelId,
     parsed,
     canonicalAgentId,
+    resolvedAgentId,
   });
   const prepared = await prepareBncrInboundSessionContext({
     api,
@@ -290,8 +451,19 @@ export async function prepareBncrInboundDispatch(args: {
     rememberSessionRoute,
   });
   const replyRouteFact = buildBncrInboundReplyRouteFact(resolution);
-  const senderIdForContext = parsed.clientId || resolution.canonicalTo;
-  const senderDisplayName = parsed.clientId ? 'bncr-client' : resolution.canonicalTo;
+  const senderIdForContext = parsed.userId || parsed.clientId || resolution.canonicalTo;
+  const senderDisplayName = parsed.userName || resolution.canonicalTo;
+  const isBncrNativeCommand =
+    parseBncrNativeCommand(parsed.extracted.text, {
+      allowBareWhoami: parsed.isAdmin !== true,
+    }) !== null;
+  const isOpenClawNativeCommand =
+    !isBncrNativeCommand &&
+    hasControlCommand(parsed.extracted.text, cfg as Parameters<typeof hasControlCommand>[1]);
+  const ownerAllowFrom =
+    parsed.isAdmin === true && isOpenClawNativeCommand && senderIdForContext
+      ? [senderIdForContext]
+      : undefined;
 
   return {
     resolution,
@@ -299,5 +471,8 @@ export async function prepareBncrInboundDispatch(args: {
     replyRouteFact,
     senderIdForContext,
     senderDisplayName,
+    ...(ownerAllowFrom ? { ownerAllowFrom } : {}),
+    bridgeSenderId: parsed.bridgeId || parsed.clientId,
+    bridgeSenderName: parsed.bridgeName || 'Bncr',
   } satisfies BncrInboundPreparation;
 }