@xmoxmo/bncr 0.4.6 → 0.4.8

package/src/messaging/inbound/dispatch.ts

@@ -1,4 +1,5 @@
 import { emitBncrLogLine } from '../../core/logging.ts';
+import type { BncrSceneRecord } from '../../plugin/channel-runtime-types.ts';
 import { handleBncrNativeCommand } from './commands.ts';
 import type {
   BncrEnqueueFromReply,
@@ -15,6 +16,12 @@ import {
   prepareBncrInboundDispatch,
   resolveBncrInboundConversation,
 } from './dispatch-prep.ts';
+import {
+  type BncrGroupHistoryMap,
+  clearBncrPendingGroupHistory,
+  recordBncrPendingGroupMedia,
+  recordBncrPendingGroupText,
+} from './group-history.ts';
 import { runBncrInboundReplyDispatch } from './reply-dispatch.ts';
 import { buildBncrInboundTurnContext } from './turn-context.ts';
 
@@ -31,6 +38,14 @@ export async function dispatchBncrInbound(params: {
   cfg: BncrInboundConfig;
   parsed: ParsedInbound;
   canonicalAgentId: string;
+  shouldDispatch?: boolean;
+  shouldAccumulate?: boolean;
+  resolvedAgentId?: string;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  groupHistories: BncrGroupHistoryMap;
+  defaultAdminAgentId: string;
+  defaultPublicAgentId: string;
+  now: () => number;
   rememberSessionRoute: BncrRememberSessionRoute;
   enqueueFromReply: BncrEnqueueFromReply;
   setInboundActivity: (accountId: string, at: number) => void;
@@ -43,6 +58,14 @@ export async function dispatchBncrInbound(params: {
     cfg,
     parsed,
     canonicalAgentId,
+    shouldDispatch = true,
+    shouldAccumulate = shouldDispatch,
+    resolvedAgentId,
+    sceneRegistry,
+    groupHistories = new Map(),
+    defaultAdminAgentId,
+    defaultPublicAgentId,
+    now,
     rememberSessionRoute,
     enqueueFromReply,
     setInboundActivity,
@@ -57,6 +80,11 @@ export async function dispatchBncrInbound(params: {
     cfg,
     parsed,
     canonicalAgentId,
+    resolvedAgentId,
+    sceneRegistry,
+    defaultAdminAgentId,
+    defaultPublicAgentId,
+    now,
     rememberSessionRoute,
     enqueueFromReply,
     logger,
@@ -79,12 +107,23 @@ export async function dispatchBncrInbound(params: {
     cfg,
     parsed,
     canonicalAgentId,
+    resolvedAgentId,
     rememberSessionRoute,
   });
-  const { resolution, prepared, replyRouteFact, senderIdForContext, senderDisplayName } =
-    preparedDispatch;
+  const {
+    resolution,
+    prepared,
+    replyRouteFact,
+    senderIdForContext,
+    senderDisplayName,
+    ownerAllowFrom,
+    bridgeSenderId,
+    bridgeSenderName,
+  } = preparedDispatch;
   const { dispatchSessionKey: sessionKey } = resolution;
-  const { storePath, mediaPath, mediaContentType, rawBody } = prepared;
+  const { storePath, mediaItems, rawBody } = prepared;
+  const primaryMedia = mediaItems[0];
+  const mediaContentType = primaryMedia?.contentType;
   if (!clientId) {
     emitBncrLogLine(
       'warn',
@@ -93,18 +132,39 @@ export async function dispatchBncrInbound(params: {
   }
   const ctxPayload = await buildBncrInboundTurnContext({
     api,
+    cfg,
     channelId,
     parsed,
     msgId,
-    mimeType: mediaContentType || mimeType,
-    mediaPath,
     peer,
     senderIdForContext,
     senderDisplayName,
+    ownerAllowFrom,
+    bridgeSenderId,
+    bridgeSenderName,
     resolution,
     prepared,
+    groupHistories,
+    shouldDispatch,
   });
 
+  if (!shouldDispatch && shouldAccumulate) {
+    recordBncrPendingGroupText({
+      historyMap: groupHistories,
+      parsed,
+      senderDisplayName,
+      bodyText: rawBody,
+    });
+    await recordBncrPendingGroupMedia({
+      historyMap: groupHistories,
+      parsed,
+      senderDisplayName,
+      bodyText: rawBody,
+      mediaItems,
+      mediaContentType: mediaContentType || mimeType,
+    });
+  }
+
   await runBncrInboundReplyDispatch({
     api,
     channelId,
@@ -118,11 +178,17 @@ export async function dispatchBncrInbound(params: {
     resolution,
     replyRouteFact,
     senderIdForContext,
+    senderDisplayName,
+    shouldDispatch,
     setInboundActivity,
     scheduleSave,
     enqueueFromReply,
   });
 
+  if (shouldDispatch) {
+    clearBncrPendingGroupHistory({ historyMap: groupHistories, parsed });
+  }
+
   return {
     accountId,
     sessionKey,

package/src/messaging/inbound/gate.ts

@@ -1,59 +1,46 @@
 import { normalizeAccountId } from '../../core/accounts.ts';
-import { resolveBncrChannelPolicy } from '../../core/policy.ts';
-import { buildDisplayScopeCandidates } from '../../core/targets.ts';
-import type { BncrRoute } from '../../core/types.ts';
-import {
-  defineOpenClawStableChannelIngressIdentity,
-  resolveOpenClawChannelMessageIngress,
-} from '../../openclaw/ingress-runtime.ts';
 import type { BncrInboundConfig, BncrInboundParamsInput } from './contracts.ts';
 
-type RouteLike = Partial<Pick<BncrRoute, 'groupId' | 'userId' | 'platform'>>;
-type AccessGroupsLike = Parameters<typeof resolveOpenClawChannelMessageIngress>[0]['accessGroups'];
-
 export type BncrGateResult = { allowed: true } | { allowed: false; reason: string };
 
+const REQUIRED_PROTOCOL_VERSION = 'scene-routing-v1';
+const REQUIRED_CAPABILITY = 'scene-routing-v1';
+
 function asString(v: unknown, fallback = ''): string {
   if (typeof v === 'string') return v;
   if (v == null) return fallback;
   return String(v);
 }
 
-const bncrIngressIdentity = defineOpenClawStableChannelIngressIdentity({
-  key: 'displayScope',
-  kind: 'plugin:bncr-display-scope',
-  normalize: (value: string) => asString(value).trim() || null,
-  sensitivity: 'pii',
-  entryIdPrefix: 'bncr-allow',
-  aliases: [
-    {
-      key: 'routeKey',
-      kind: 'plugin:bncr-route-key',
-      normalize: (value: string) => asString(value).trim() || null,
-      sensitivity: 'pii',
-    },
-  ],
-});
+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 gateReasonFromIngress(reasonCode?: string): string {
-  switch (reasonCode) {
-    case 'dm_policy_disabled':
-      return 'dm disabled';
-    case 'dm_policy_not_allowlisted':
-    case 'dm_policy_pairing_required':
-      return 'dm allowlist blocked';
-    case 'group_policy_disabled':
-      return 'group disabled';
-    case 'group_policy_not_allowlisted':
-    case 'group_policy_empty_allowlist':
-      return 'group allowlist blocked';
-    default:
-      return reasonCode || 'ingress blocked';
+function asCapabilities(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 [];
 }
 
 export async function checkBncrMessageGate(params: {
-  parsed: BncrInboundParamsInput & { route?: RouteLike };
+  parsed: BncrInboundParamsInput & {
+    route?: Partial<{ groupId: string; userId: string; platform: string }>;
+  };
   cfg: BncrInboundConfig;
   account: { accountId: string; enabled?: boolean };
 }): Promise<BncrGateResult> {
@@ -61,57 +48,40 @@ export async function checkBncrMessageGate(params: {
   const accountId = normalizeAccountId(account?.accountId);
   const channelCfg = cfg?.channels?.bncr || {};
   const accountCfg = channelCfg?.accounts?.[accountId] || {};
-  const policy = resolveBncrChannelPolicy(channelCfg);
-
-  if (policy.enabled === false || account?.enabled === false || accountCfg?.enabled === false) {
+  if (
+    channelCfg?.enabled === false ||
+    account?.enabled === false ||
+    accountCfg?.enabled === false
+  ) {
     return { allowed: false, reason: 'account disabled' };
   }
 
-  const route = parsed?.route;
-  if (!route?.platform || !route?.groupId || !route?.userId) {
-    return { allowed: false, reason: 'invalid route' };
+  const protocolVersion = asString(parsed?.protocolVersion || '').trim();
+  const capabilities = asCapabilities(parsed?.capabilities);
+  if (
+    protocolVersion !== REQUIRED_PROTOCOL_VERSION ||
+    !capabilities.includes(REQUIRED_CAPABILITY)
+  ) {
+    return { allowed: false, reason: 'client protocol outdated' };
   }
-  const resolvedRoute: BncrRoute = {
-    platform: route.platform,
-    groupId: route.groupId,
-    userId: route.userId,
-  };
-  const isGroup = asString(route?.groupId || '0') !== '0';
-
-  const candidates = buildDisplayScopeCandidates(resolvedRoute);
-  const displayScope = candidates[0] || '';
-  const routeKey = candidates.find((candidate) => candidate !== displayScope) || displayScope;
 
-  // requireMention 默认值为 false。
-  // 设计目标：当它未来真正生效时，含义是“群消息只有在明确提到机器人时才允许进入处理链”。
-  // 但当前 parse 层尚未稳定提取 mentions，上游客户端也未统一透传 mention 信号，
-  // 因此现阶段即使配置为 true，也仍不做实际拦截，避免出现半实现状态。
-  const resolved = await resolveOpenClawChannelMessageIngress({
-    channelId: 'bncr',
-    accountId,
-    identity: bncrIngressIdentity,
-    subject: {
-      stableId: displayScope,
-      aliases: { routeKey },
-    },
-    conversation: {
-      kind: isGroup ? 'group' : 'direct',
-      id: isGroup ? asString(route?.groupId) : asString(route?.userId || displayScope),
-    },
-    event: { kind: 'message', authMode: 'inbound', mayPair: !isGroup },
-    policy: {
-      dmPolicy: policy.dmPolicy,
-      groupPolicy: policy.groupPolicy,
-      groupAllowFromFallbackToAllowFrom: false,
-    },
-    allowFrom: policy.dmPolicy === 'open' ? ['*', ...policy.allowFrom] : policy.allowFrom,
-    groupAllowFrom: policy.groupAllowFrom,
-    accessGroups: cfg?.accessGroups as AccessGroupsLike,
-  });
-
-  if (resolved.ingress.admission === 'dispatch' || resolved.ingress.admission === 'observe') {
-    return { allowed: true };
+  const platform = asString(parsed?.platform || '').trim();
+  const userId = asString(parsed?.userId || '').trim();
+  const clientId = asString(parsed?.clientId || '').trim();
+  const groupId = asString(parsed?.groupId || '').trim();
+  const isGroupProvided = parsed && Object.hasOwn(parsed, 'isGroup');
+  const isAdminProvided = parsed && Object.hasOwn(parsed, 'isAdmin');
+  const isGroup = asBoolean(parsed?.isGroup, false);
+  if (!platform || !userId || !clientId || !isGroupProvided || !isAdminProvided) {
+    return { allowed: false, reason: 'inbound schema incomplete' };
+  }
+  if (isGroup && !groupId) {
+    return { allowed: false, reason: 'inbound schema incomplete' };
   }
 
-  return { allowed: false, reason: gateReasonFromIngress(resolved.ingress.reasonCode) };
+  const route = parsed?.route;
+  if (!route?.platform || !route?.groupId || !route?.userId) {
+    return { allowed: false, reason: 'invalid route' };
+  }
+  return { allowed: true };
 }

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;
   });
 }