@xmoxmo/bncr 0.2.6 → 0.2.8

package/src/messaging/inbound/dispatch.ts

@@ -1,6 +1,4 @@
 import fs from 'node:fs';
-import { resolvePinnedMainDmOwnerFromAllowlist } from 'openclaw/plugin-sdk/conversation-runtime';
-import { resolveInboundLastRouteSessionKey } from 'openclaw/plugin-sdk/routing';
 import { emitBncrLogLine } from '../../core/logging.ts';
 import { resolveBncrChannelPolicy } from '../../core/policy.ts';
 import {
@@ -9,8 +7,29 @@ import {
   withTaskSessionKey,
 } from '../../core/targets.ts';
 import { handleBncrNativeCommand } from './commands.ts';
+import {
+  buildBncrPromptVisibleContextFacts,
+  buildBncrStructuredContextFactsFromInboundParts,
+} from './context-facts.ts';
 import { buildBncrReplyConfig } from './reply-config.ts';
+import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
 import { wrapBncrInboundRecordSessionLabelCorrection } from './session-label.ts';
+import { saveOpenClawChannelMediaBuffer } from '../../openclaw/media-runtime.ts';
+import {
+  dispatchOpenClawReplyWithBufferedBlockDispatcher,
+  formatOpenClawAgentEnvelope,
+  resolveOpenClawEnvelopeFormatOptions,
+} from '../../openclaw/reply-runtime.ts';
+import {
+  resolveOpenClawAgentRoute,
+  resolveOpenClawInboundLastRouteSessionKey,
+} from '../../openclaw/routing-runtime.ts';
+import {
+  readBncrSessionUpdatedAt,
+  recordBncrInboundSession,
+  resolveBncrInboundSessionStorePath,
+  resolveBncrPinnedMainDmOwnerFromAllowlist,
+} from '../../openclaw/inbound-session-runtime.ts';
 
 type ParsedInbound = ReturnType<typeof import('./parse.ts')['parseBncrInboundParams']>;
 
@@ -93,7 +112,7 @@ export function resolveBncrInboundConversation(args: {
   const { api, cfg, channelId, parsed, canonicalAgentId } = args;
   const { accountId, route, peer, sessionKeyfromroute, providedOriginatingTo, extracted } = parsed;
 
-  const resolvedRoute = api.runtime.channel.routing.resolveAgentRoute({
+  const resolvedRoute = resolveOpenClawAgentRoute(api, {
     cfg,
     channel: channelId,
     accountId,
@@ -149,14 +168,16 @@ async function prepareBncrInboundSessionContext(args: {
     rememberSessionRoute(taskSessionKey, accountId, route);
   }
 
-  const storePath = api.runtime.channel.session.resolveStorePath(cfg?.session?.store, {
+  const storePath = resolveBncrInboundSessionStorePath({
+    storeConfig: cfg?.session?.store,
     agentId: resolvedRoute.agentId,
   });
 
   let mediaPath: string | undefined;
   if (mediaBase64) {
     const mediaBuf = decodeInboundMediaBase64(mediaBase64);
-    const saved = await api.runtime.channel.media.saveMediaBuffer(
+    const saved = await saveOpenClawChannelMediaBuffer(
+      api,
       mediaBuf,
       mimeType,
       'inbound',
@@ -169,15 +190,15 @@ async function prepareBncrInboundSessionContext(args: {
   }
 
   const rawBody = extracted.text || (msgType === 'text' ? '' : `[${msgType}]`);
-  const body = api.runtime.channel.reply.formatAgentEnvelope({
+  const body = formatOpenClawAgentEnvelope(api, {
     channel: 'Bncr',
     from: `${platform}:${groupId}:${userId}`,
     timestamp: Date.now(),
-    previousTimestamp: api.runtime.channel.session.readSessionUpdatedAt({
+    previousTimestamp: readBncrSessionUpdatedAt(api, {
       storePath,
       sessionKey: dispatchSessionKey,
     }),
-    envelope: api.runtime.channel.reply.resolveEnvelopeFormatOptions(cfg),
+    envelope: resolveOpenClawEnvelopeFormatOptions(api, cfg),
     body: rawBody,
   });
 
@@ -192,6 +213,7 @@ async function prepareBncrInboundSessionContext(args: {
 function buildBncrInboundTurnContext(args: {
   api: any;
   channelId: string;
+  parsed: ParsedInbound;
   msgId?: string | null;
   mimeType?: string;
   mediaPath?: string;
@@ -207,6 +229,7 @@ function buildBncrInboundTurnContext(args: {
   const {
     api,
     channelId,
+    parsed,
     msgId,
     mimeType,
     mediaPath,
@@ -216,8 +239,31 @@ function buildBncrInboundTurnContext(args: {
     resolution,
     prepared,
   } = args;
+  const structuredContextFacts = buildBncrStructuredContextFactsFromInboundParts({
+    channelId,
+    parsed,
+    resolution,
+    prepared: {
+      rawBody: prepared.rawBody,
+      body: prepared.body,
+      mediaPath,
+    },
+    senderIdForContext,
+    senderDisplayName,
+  });
+  const promptVisibleContextFacts = buildBncrPromptVisibleContextFacts(structuredContextFacts);
+  const supplementalUntrustedContext = Object.keys(promptVisibleContextFacts).length
+    ? [
+        {
+          label: 'Bncr inbound context',
+          source: channelId,
+          type: 'bncr.inbound_context',
+          payload: promptVisibleContextFacts,
+        },
+      ]
+    : [];
 
-  return api.runtime.channel.turn.buildContext({
+  return resolveBncrChannelInboundRuntime(api).buildContext({
     channel: channelId,
     provider: channelId,
     surface: channelId,
@@ -275,8 +321,13 @@ function buildBncrInboundTurnContext(args: {
           },
         ]
       : [],
+    supplemental: {
+      untrustedContext: supplementalUntrustedContext,
+    },
     extra: {
       OriginatingChannel: channelId,
+      BncrStructuredContextFacts: structuredContextFacts,
+      StructuredContextFacts: structuredContextFacts,
     },
   });
 }
@@ -291,7 +342,7 @@ function buildBncrInboundRecordUpdateLastRoute(args: {
   const { channelId, peer, senderIdForContext, resolution, pinnedMainDmOwner } = args;
   if (peer.kind !== 'direct') return undefined;
 
-  const sessionKey = resolveInboundLastRouteSessionKey({
+  const sessionKey = resolveOpenClawInboundLastRouteSessionKey({
     route: resolution.resolvedRoute,
     sessionKey: resolution.dispatchSessionKey,
   });
@@ -406,6 +457,7 @@ export async function dispatchBncrInbound(params: {
   const ctxPayload = buildBncrInboundTurnContext({
     api,
     channelId,
+    parsed,
     msgId,
     mimeType,
     mediaPath,
@@ -420,7 +472,7 @@ export async function dispatchBncrInbound(params: {
   const channelPolicy = resolveBncrChannelPolicy(cfg?.channels?.bncr || {});
   const pinnedMainDmOwner =
     peer.kind === 'direct'
-      ? resolvePinnedMainDmOwnerFromAllowlist({
+      ? resolveBncrPinnedMainDmOwnerFromAllowlist({
           dmScope: cfg?.session?.dmScope,
           allowFrom: channelPolicy.allowFrom,
           normalizeEntry: (entry: string) => String(entry || '').trim(),
@@ -434,7 +486,7 @@ export async function dispatchBncrInbound(params: {
     pinnedMainDmOwner,
   });
 
-  await api.runtime.channel.turn.run({
+  await resolveBncrChannelInboundRuntime(api).run({
     channel: channelId,
     accountId,
     raw: parsed,
@@ -454,7 +506,7 @@ export async function dispatchBncrInbound(params: {
         storePath,
         ctxPayload,
         recordInboundSession: wrapBncrInboundRecordSessionLabelCorrection({
-          recordInboundSession: api.runtime.channel.session.recordInboundSession,
+          recordInboundSession: recordBncrInboundSession,
           expectedLabel: canonicalTo,
         }),
         record: {
@@ -464,7 +516,7 @@ export async function dispatchBncrInbound(params: {
           },
         },
         runDispatch: () =>
-          api.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+          dispatchOpenClawReplyWithBufferedBlockDispatcher(api, {
             ctx: ctxPayload,
             cfg: effectiveReply.replyCfg,
             dispatcherOptions: {

package/src/messaging/inbound/gate.ts

@@ -1,6 +1,10 @@
 import { normalizeAccountId } from '../../core/accounts.ts';
 import { resolveBncrChannelPolicy } from '../../core/policy.ts';
 import { buildDisplayScopeCandidates } from '../../core/targets.ts';
+import {
+  defineOpenClawStableChannelIngressIdentity,
+  resolveOpenClawChannelMessageIngress,
+} from '../../openclaw/ingress-runtime.ts';
 
 export type BncrGateResult = { allowed: true } | { allowed: false; reason: string };
 
@@ -10,13 +14,40 @@ function asString(v: unknown, fallback = ''): string {
   return String(v);
 }
 
-function matchesAllowList(list: string[], candidates: string[]): boolean {
-  if (!list.length) return false;
-  const normalized = new Set(list.map((x) => asString(x).trim()).filter(Boolean));
-  return candidates.some((x) => normalized.has(asString(x).trim()));
+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 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';
+  }
 }
 
-export function checkBncrMessageGate(params: {
+export async function checkBncrMessageGate(params: {
   parsed: any;
   cfg: any;
   account: { accountId: string; enabled?: boolean };
@@ -34,31 +65,40 @@ export function checkBncrMessageGate(params: {
   const route = parsed?.route;
   const isGroup = asString(route?.groupId || '0') !== '0';
 
-  if (!isGroup && policy.dmPolicy === 'disabled') {
-    return { allowed: false, reason: 'dm disabled' };
-  }
-
-  if (isGroup && policy.groupPolicy === 'disabled') {
-    return { allowed: false, reason: 'group disabled' };
-  }
-
   const candidates = buildDisplayScopeCandidates(route);
-
-  if (!isGroup && policy.dmPolicy === 'allowlist') {
-    if (!matchesAllowList(policy.allowFrom, candidates)) {
-      return { allowed: false, reason: 'dm allowlist blocked' };
-    }
-  }
-
-  if (isGroup && policy.groupPolicy === 'allowlist') {
-    if (!matchesAllowList(policy.groupAllowFrom, candidates)) {
-      return { allowed: false, reason: 'group allowlist blocked' };
-    }
-  }
+  const displayScope = candidates[0] || '';
+  const routeKey = candidates.find((candidate) => candidate !== displayScope) || displayScope;
 
   // requireMention 默认值为 false。
   // 设计目标：当它未来真正生效时，含义是“群消息只有在明确提到机器人时才允许进入处理链”。
   // 但当前 parse 层尚未稳定提取 mentions，上游客户端也未统一透传 mention 信号，
   // 因此现阶段即使配置为 true，也仍不做实际拦截，避免出现半实现状态。
-  return { allowed: 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,
+  });
+
+  if (resolved.ingress.admission === 'dispatch' || resolved.ingress.admission === 'observe') {
+    return { allowed: true };
+  }
+
+  return { allowed: false, reason: gateReasonFromIngress(resolved.ingress.reasonCode) };
 }

package/src/messaging/inbound/runtime-compat.ts

@@ -0,0 +1,41 @@
+import { emitBncrLogLine } from '../../core/logging.ts';
+
+type ChannelRuntimeCompat = {
+  buildContext: (...args: any[]) => any;
+  run: (...args: any[]) => Promise<any> | any;
+  runPreparedReply?: (...args: any[]) => Promise<any> | any;
+  dispatchReply?: (...args: any[]) => Promise<any> | any;
+};
+
+let warnedLegacyTurnRuntime = false;
+
+export function resolveBncrChannelInboundRuntime(api: any): ChannelRuntimeCompat {
+  const channelRuntime = api?.runtime?.channel;
+  const inboundRuntime = channelRuntime?.inbound;
+  if (inboundRuntime?.buildContext && inboundRuntime?.run) {
+    return inboundRuntime;
+  }
+
+  const legacyTurnRuntime = channelRuntime?.turn;
+  if (legacyTurnRuntime?.buildContext && legacyTurnRuntime?.run) {
+    if (!warnedLegacyTurnRuntime) {
+      warnedLegacyTurnRuntime = true;
+      const channelRuntimeKeys = Object.keys(channelRuntime ?? {}).sort().join(',') || 'none';
+      const inboundRuntimeKeys = Object.keys(inboundRuntime ?? {}).sort().join(',') || 'none';
+      emitBncrLogLine(
+        'warn',
+        `[bncr] inbound runtime fallback=turn|preferred=inbound|channelKeys=${channelRuntimeKeys}|inboundKeys=${inboundRuntimeKeys}`,
+      );
+    }
+    return {
+      buildContext: legacyTurnRuntime.buildContext,
+      run: legacyTurnRuntime.run,
+      runPreparedReply: legacyTurnRuntime.runPrepared,
+      dispatchReply: legacyTurnRuntime.dispatchAssembled ?? legacyTurnRuntime.runAssembled,
+    };
+  }
+
+  throw new Error(
+    'OpenClaw channel inbound runtime is unavailable: expected runtime.channel.inbound.* or legacy runtime.channel.turn.*',
+  );
+}

package/src/messaging/inbound/session-label.ts

@@ -1,8 +1,8 @@
-import {
-  recordSessionMetaFromInbound,
-  updateSessionStoreEntry,
-} from 'openclaw/plugin-sdk/session-store-runtime';
 import { emitBncrLogLine } from '../../core/logging.ts';
+import {
+  recordBncrSessionMetaFromInbound,
+  updateBncrSessionStoreEntry,
+} from '../../openclaw/inbound-session-runtime.ts';
 
 type RecordInboundSessionFn = (args: any) => Promise<unknown> | unknown;
 
@@ -57,7 +57,7 @@ export async function correctBncrInboundSessionLabel(args: {
   if (!storePath || !sessionKey || !expectedLabel) return;
 
   try {
-    await updateSessionStoreEntry({
+    await updateBncrSessionStoreEntry({
       storePath,
       sessionKey,
       update: (entry: any) => {
@@ -82,14 +82,14 @@ export async function recordAndPatchBncrInboundSessionEntry(args: {
 
   try {
     if (args.ctx) {
-      await recordSessionMetaFromInbound({
+      await recordBncrSessionMetaFromInbound({
         storePath,
         sessionKey,
         ctx: args.ctx as any,
         createIfMissing: true,
       });
     }
-    await updateSessionStoreEntry({
+    await updateBncrSessionStoreEntry({
       storePath,
       sessionKey,
       update: () => args.patch,

package/src/messaging/outbound/durable-message-adapter.ts

@@ -0,0 +1,107 @@
+import { defineChannelMessageAdapter } from 'openclaw/plugin-sdk/channel-outbound';
+import type {
+  ChannelMessageAdapterShape,
+  ChannelMessageSendMediaContext,
+  ChannelMessageSendPayloadContext,
+  ChannelMessageSendResult,
+  ChannelMessageSendTextContext,
+} from 'openclaw/plugin-sdk/channel-outbound';
+
+import { buildFileTransferOutboxEntry, buildTextOutboxEntry } from '../../core/outbox-entry-builders.ts';
+import type { BncrRoute, OutboxEntry } from '../../core/types.ts';
+import { buildBncrDurableQueuedResult } from './durable-queue-adapter.ts';
+
+export type BncrDurableMessageQueuedAdapterDeps<TConfig = unknown> = {
+  enqueueText: (ctx: ChannelMessageSendTextContext<TConfig>) => Promise<OutboxEntry> | OutboxEntry;
+  enqueueMedia?: (ctx: ChannelMessageSendMediaContext<TConfig>) => Promise<OutboxEntry> | OutboxEntry;
+  enqueuePayload?: (ctx: ChannelMessageSendPayloadContext<TConfig>) => Promise<OutboxEntry> | OutboxEntry;
+  now?: () => number;
+};
+
+export type BncrDurableMessageQueuedAdapterBuilderDeps<TConfig = unknown> = {
+  createMessageId: () => string;
+  now: () => number;
+  normalizeAccountId: (accountId?: string | null) => string;
+  normalizeReplyToId: (value?: string | null) => string;
+  resolveTarget: (ctx: ChannelMessageSendTextContext<TConfig>) => {
+    route: BncrRoute;
+    sessionKey: string;
+    accountId?: string | null;
+  };
+  filePushEvent?: string;
+};
+
+// This adapter intentionally models only the OpenClaw -> bncr-plugin handoff.
+// Once a message is accepted into bncr's own outbox, OpenClaw should stop managing it;
+// client/platform ACK, retry, and deadLetter remain owned by the bncr service framework.
+export function createBncrDurableMessageQueuedAdapter<TConfig = unknown>(
+  deps: BncrDurableMessageQueuedAdapterDeps<TConfig>,
+): ChannelMessageAdapterShape<TConfig, ChannelMessageSendResult> {
+  return defineChannelMessageAdapter({
+    id: 'bncr-queued-outbox',
+    receive: {
+      defaultAckPolicy: 'manual',
+      supportedAckPolicies: ['manual'],
+    },
+    send: {
+      text: async (ctx) => toChannelMessageSendResult(await deps.enqueueText(ctx), deps.now),
+      media: deps.enqueueMedia
+        ? async (ctx) => toChannelMessageSendResult(await deps.enqueueMedia?.(ctx), deps.now)
+        : undefined,
+      payload: deps.enqueuePayload
+        ? async (ctx) => toChannelMessageSendResult(await deps.enqueuePayload?.(ctx), deps.now)
+        : undefined,
+    },
+  });
+}
+
+export function createBncrDurableMessageQueuedAdapterFromBuilders<TConfig = unknown>(
+  deps: BncrDurableMessageQueuedAdapterBuilderDeps<TConfig>,
+): ChannelMessageAdapterShape<TConfig, ChannelMessageSendResult> {
+  return createBncrDurableMessageQueuedAdapter<TConfig>({
+    now: deps.now,
+    enqueueText: (ctx) => {
+      const resolved = deps.resolveTarget(ctx);
+      return buildTextOutboxEntry({
+        createMessageId: deps.createMessageId,
+        now: deps.now,
+        normalizeAccountId: deps.normalizeAccountId,
+        normalizeReplyToId: deps.normalizeReplyToId,
+        accountId: resolved.accountId ?? ctx.accountId ?? undefined,
+        sessionKey: resolved.sessionKey,
+        route: resolved.route,
+        text: ctx.text,
+        kind: 'final',
+        replyToId: ctx.replyToId ?? undefined,
+      });
+    },
+    enqueueMedia: (ctx) => {
+      const resolved = deps.resolveTarget(ctx);
+      return buildFileTransferOutboxEntry({
+        createMessageId: deps.createMessageId,
+        now: deps.now,
+        normalizeAccountId: deps.normalizeAccountId,
+        pushEvent: deps.filePushEvent ?? 'bncr.file.push',
+        accountId: resolved.accountId ?? ctx.accountId ?? undefined,
+        sessionKey: resolved.sessionKey,
+        route: resolved.route,
+        mediaUrl: ctx.mediaUrl,
+        mediaLocalRoots: ctx.mediaLocalRoots,
+        text: ctx.text,
+        asVoice: ctx.audioAsVoice,
+        audioAsVoice: ctx.audioAsVoice,
+        kind: 'final',
+        replyToId: ctx.replyToId ?? undefined,
+      });
+    },
+  });
+}
+
+function toChannelMessageSendResult(entry: OutboxEntry | undefined, now?: () => number): ChannelMessageSendResult {
+  if (!entry) throw new Error('bncr durable message adapter did not receive an outbox entry');
+  const queued = buildBncrDurableQueuedResult({ entry, sentAt: now?.() });
+  return {
+    receipt: queued.receipt as any,
+    messageId: queued.receipt.primaryPlatformMessageId,
+  };
+}

package/src/messaging/outbound/durable-queue-adapter.ts

@@ -0,0 +1,157 @@
+import type { BncrRoute, OutboxEntry } from '../../core/types.ts';
+import { normalizeOutboundReplyToId } from './reply-target-policy.ts';
+
+export type BncrDurableQueuedReceipt = {
+  primaryPlatformMessageId: string;
+  platformMessageIds: string[];
+  parts: Array<{
+    platformMessageId: string;
+    kind: 'text' | 'media' | 'voice' | 'unknown';
+    index: number;
+    threadId?: string;
+    replyToId?: string;
+    raw: {
+      channel: 'bncr';
+      channelId: 'bncr';
+      messageId: string;
+      chatId: string;
+      conversationId: string;
+      timestamp: number;
+      meta: BncrDurableQueuedReceiptMeta;
+    };
+  }>;
+  threadId?: string;
+  replyToId?: string;
+  sentAt: number;
+  raw: Array<{
+    channel: 'bncr';
+    channelId: 'bncr';
+    messageId: string;
+    chatId: string;
+    conversationId: string;
+    timestamp: number;
+    meta: BncrDurableQueuedReceiptMeta;
+  }>;
+};
+
+export type BncrDurableQueuedReceiptMeta = {
+  status: 'accepted';
+  deliveryStage: 'queued';
+  queue: 'bncr.outbox';
+  finalAckManagedBy: 'bncr-outbox';
+  ackSemantics: 'plugin-accepted-not-client-acked';
+  accountId: string;
+  sessionKey: string;
+  route: BncrRoute;
+  outboxPayloadType?: string;
+};
+
+export type BncrDurableQueuedResult = {
+  status: 'sent';
+  results: Array<{
+    channel: 'bncr';
+    channelId: 'bncr';
+    messageId: string;
+    chatId: string;
+    conversationId: string;
+    timestamp: number;
+    meta: BncrDurableQueuedReceiptMeta;
+  }>;
+  receipt: BncrDurableQueuedReceipt;
+  payloadOutcomes: Array<{
+    index: number;
+    status: 'sent';
+    results: BncrDurableQueuedResult['results'];
+  }>;
+};
+
+export function buildBncrDurableQueuedResult(args: {
+  entry: OutboxEntry;
+  index?: number;
+  threadId?: string;
+  replyToId?: string;
+  sentAt?: number;
+}): BncrDurableQueuedResult {
+  const sentAt = Number.isFinite(args.sentAt) ? Number(args.sentAt) : args.entry.createdAt;
+  const platformMessageId = args.entry.messageId;
+  const replyToId = normalizeOutboundReplyToId({ replyToId: args.replyToId ?? extractReplyToId(args.entry) }) || undefined;
+  const chatId = formatQueuedReceiptChatId(args.entry.route);
+  const meta: BncrDurableQueuedReceiptMeta = {
+    status: 'accepted',
+    deliveryStage: 'queued',
+    queue: 'bncr.outbox',
+    finalAckManagedBy: 'bncr-outbox',
+    ackSemantics: 'plugin-accepted-not-client-acked',
+    accountId: args.entry.accountId,
+    sessionKey: args.entry.sessionKey,
+    route: args.entry.route,
+    outboxPayloadType: extractPayloadType(args.entry),
+  };
+  const result = {
+    channel: 'bncr' as const,
+    channelId: 'bncr' as const,
+    messageId: platformMessageId,
+    chatId,
+    conversationId: args.entry.sessionKey,
+    timestamp: sentAt,
+    meta,
+  };
+  const receipt: BncrDurableQueuedReceipt = {
+    primaryPlatformMessageId: platformMessageId,
+    platformMessageIds: [platformMessageId],
+    parts: [
+      {
+        platformMessageId,
+        kind: inferReceiptKind(args.entry),
+        index: args.index ?? 0,
+        threadId: args.threadId,
+        replyToId,
+        raw: result,
+      },
+    ],
+    threadId: args.threadId,
+    replyToId,
+    sentAt,
+    raw: [result],
+  };
+  return {
+    status: 'sent',
+    results: [result],
+    receipt,
+    payloadOutcomes: [
+      {
+        index: args.index ?? 0,
+        status: 'sent',
+        results: [result],
+      },
+    ],
+  };
+}
+
+function extractPayloadType(entry: OutboxEntry): string | undefined {
+  const payload = entry.payload as any;
+  return typeof payload?.type === 'string' ? payload.type : undefined;
+}
+
+function extractReplyToId(entry: OutboxEntry): string | undefined {
+  const payload = entry.payload as any;
+  const metaReply = payload?._meta?.replyToId;
+  const replyToId = payload?.replyToId ?? metaReply;
+  return typeof replyToId === 'string' ? replyToId : undefined;
+}
+
+function inferReceiptKind(entry: OutboxEntry): 'text' | 'media' | 'voice' | 'unknown' {
+  const payload = entry.payload as any;
+  if (payload?._meta?.kind === 'file-transfer') {
+    if (payload?._meta?.asVoice === true || payload?._meta?.audioAsVoice === true) return 'voice';
+    return 'media';
+  }
+  if (payload?.message?.type === 'text') return 'text';
+  return 'unknown';
+}
+
+function formatQueuedReceiptChatId(route: BncrRoute): string {
+  const platform = route.platform || 'unknown';
+  if (route.groupId) return `Bncr:${platform}:${route.groupId}:${route.userId}`;
+  return `Bncr:${platform}:${route.userId}`;
+}

package/src/messaging/outbound/session-route.ts

@@ -1,4 +1,4 @@
-import { buildChannelOutboundSessionRoute } from 'openclaw/plugin-sdk/core';
+import { buildOpenClawChannelOutboundSessionRoute } from '../../openclaw/session-route-runtime.ts';
 import {
   buildCanonicalBncrSessionKey,
   formatDisplayScope,
@@ -72,7 +72,7 @@ export function resolveBncrOutboundSessionRoute(params: ResolveBncrOutboundSessi
   const sessionKey = buildCanonicalBncrSessionKey(route, canonicalAgentId);
   const displayTo = formatDisplayScope(route);
 
-  const built = buildChannelOutboundSessionRoute({
+  const built = buildOpenClawChannelOutboundSessionRoute({
     cfg: params.cfg,
     agentId: canonicalAgentId,
     channel: params.channel,