@xmoxmo/bncr 0.2.6 → 0.2.7

package/src/messaging/inbound/commands.ts

@@ -1,5 +1,3 @@
-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 {
@@ -8,11 +6,22 @@ import {
   withTaskSessionKey,
 } from '../../core/targets.ts';
 import { buildBncrReplyConfig } from './reply-config.ts';
+import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
 import {
   buildBncrInboundSessionIdentityPatch,
   recordAndPatchBncrInboundSessionEntry,
   wrapBncrInboundRecordSessionLabelCorrection,
 } from './session-label.ts';
+import { dispatchOpenClawReplyWithBufferedBlockDispatcher } from '../../openclaw/reply-runtime.ts';
+import {
+  resolveOpenClawAgentRoute,
+  resolveOpenClawInboundLastRouteSessionKey,
+} from '../../openclaw/routing-runtime.ts';
+import {
+  recordBncrInboundSession,
+  resolveBncrInboundSessionStorePath,
+  resolveBncrPinnedMainDmOwnerFromAllowlist,
+} from '../../openclaw/inbound-session-runtime.ts';
 
 type ParsedInbound = ReturnType<typeof import('./parse.ts')['parseBncrInboundParams']>;
 
@@ -110,7 +119,7 @@ export async function handleBncrNativeCommand(params: {
     { debugOnly: true, debugEnabled: nativeCommandDebugEnabled },
   );
 
-  const resolvedRoute = api.runtime.channel.routing.resolveAgentRoute({
+  const resolvedRoute = resolveOpenClawAgentRoute(api, {
     cfg,
     channel: channelId,
     accountId,
@@ -137,11 +146,12 @@ export async function handleBncrNativeCommand(params: {
   }
   const senderIdForContext = clientId || displayTo;
   const senderDisplayName = clientId ? 'bncr-client' : displayTo;
-  const storePath = api.runtime.channel.session.resolveStorePath(cfg?.session?.store, {
+  const storePath = resolveBncrInboundSessionStorePath({
+    storeConfig: cfg?.session?.store,
     agentId: resolvedRoute.agentId,
   });
 
-  const ctxPayload = api.runtime.channel.turn.buildContext({
+  const ctxPayload = resolveBncrChannelInboundRuntime(api).buildContext({
     channel: channelId,
     provider: channelId,
     surface: channelId,
@@ -259,13 +269,13 @@ export async function handleBncrNativeCommand(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(),
         })
       : null;
-  const inboundLastRouteSessionKey = resolveInboundLastRouteSessionKey({
+  const inboundLastRouteSessionKey = resolveOpenClawInboundLastRouteSessionKey({
     route: resolvedRoute,
     sessionKey,
   });
@@ -282,7 +292,7 @@ export async function handleBncrNativeCommand(params: {
     },
     { debugOnly: true, debugEnabled: nativeCommandDebugEnabled },
   );
-  await api.runtime.channel.turn.run({
+  await resolveBncrChannelInboundRuntime(api).run({
     channel: channelId,
     accountId,
     raw: parsed,
@@ -302,7 +312,7 @@ export async function handleBncrNativeCommand(params: {
         storePath,
         ctxPayload,
         recordInboundSession: wrapBncrInboundRecordSessionLabelCorrection({
-          recordInboundSession: api.runtime.channel.session.recordInboundSession,
+          recordInboundSession: recordBncrInboundSession,
           expectedLabel: displayTo,
         }),
         record: {
@@ -330,7 +340,7 @@ export async function handleBncrNativeCommand(params: {
           },
         },
         runDispatch: () =>
-          api.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+          dispatchOpenClawReplyWithBufferedBlockDispatcher(api, {
             ctx: ctxPayload,
             cfg: effectiveReply.replyCfg,
             dispatcherOptions: {

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

@@ -0,0 +1,200 @@
+export type BncrStructuredContextFactsInput = {
+  channelId: string;
+  accountId: string;
+  route: {
+    agentId?: string;
+    routeSessionKey?: string;
+    dispatchSessionKey?: string;
+    mainSessionKey?: string;
+  };
+  conversation: {
+    kind: string;
+    id: string;
+    label: string;
+  };
+  reply: {
+    to: string;
+    originatingTo: string;
+  };
+  sender: {
+    id: string;
+    displayName?: string;
+  };
+  message: {
+    id?: string | null;
+    rawBody: string;
+    bodyForAgent?: string;
+    commandBody?: string;
+    envelopeBody?: string;
+  };
+  media?: Array<{
+    path: string;
+    contentType?: string;
+    kind?: string;
+    messageId?: string;
+  }>;
+};
+
+export function buildBncrStructuredContextFacts(input: BncrStructuredContextFactsInput) {
+  const rawBody = input.message.rawBody;
+  return {
+    channel: {
+      id: input.channelId,
+      accountId: input.accountId,
+    },
+    route: {
+      agentId: input.route.agentId,
+      routeSessionKey: input.route.routeSessionKey,
+      dispatchSessionKey: input.route.dispatchSessionKey,
+      mainSessionKey: input.route.mainSessionKey,
+    },
+    conversation: {
+      kind: input.conversation.kind,
+      id: input.conversation.id,
+      label: input.conversation.label,
+    },
+    reply: {
+      to: input.reply.to,
+      originatingTo: input.reply.originatingTo,
+    },
+    sender: {
+      id: input.sender.id,
+      displayName: input.sender.displayName || input.sender.id,
+    },
+    message: {
+      id: input.message.id || undefined,
+      rawBody,
+      bodyForAgent: input.message.bodyForAgent ?? rawBody,
+      commandBody: input.message.commandBody ?? rawBody,
+      envelopeBody: input.message.envelopeBody,
+    },
+    media: (input.media || []).map((item) => ({
+      path: item.path,
+      contentType: item.contentType,
+      kind: item.kind,
+      messageId: item.messageId,
+    })),
+  };
+}
+
+// Keep this payload intentionally small: OpenClaw already renders standard
+// conversation/sender/message metadata as untrusted context. Only include
+// bncr-specific facts that are not otherwise visible to the model, so normal
+// text turns do not get a duplicate "Bncr inbound context" JSON block.
+export function buildBncrPromptVisibleContextFacts(
+  facts: ReturnType<typeof buildBncrStructuredContextFacts>,
+) {
+  const result: {
+    reply?: {
+      to: string;
+      originatingTo: string;
+    };
+    media?: Array<{
+      contentType?: string;
+      kind?: string;
+      messageId?: string;
+    }>;
+  } = {};
+
+  if (facts.reply.originatingTo !== facts.reply.to) {
+    result.reply = {
+      to: facts.reply.to,
+      originatingTo: facts.reply.originatingTo,
+    };
+  }
+
+  if (facts.media.length > 0) {
+    result.media = facts.media.map((item) => ({
+      contentType: item.contentType,
+      kind: item.kind,
+      messageId: item.messageId,
+    }));
+  }
+
+  return result;
+}
+
+function inferBncrStructuredMediaKind(contentType: string | undefined) {
+  if (contentType?.startsWith('image/')) return 'image';
+  if (contentType?.startsWith('video/')) return 'video';
+  if (contentType?.startsWith('audio/')) return 'audio';
+  return 'document';
+}
+
+export type BncrStructuredContextFactsFromInboundPartsInput = {
+  channelId: string;
+  parsed: {
+    accountId: string;
+    peer: {
+      kind: string;
+      id: string;
+    };
+    clientId?: string;
+    msgId?: string;
+    mimeType?: string;
+  };
+  resolution: {
+    chatType: string;
+    canonicalTo: string;
+    originatingTo: string;
+    resolvedRoute: {
+      agentId?: string;
+      sessionKey?: string;
+      mainSessionKey?: string;
+    };
+    dispatchSessionKey?: string;
+  };
+  prepared: {
+    rawBody: string;
+    body?: string;
+    mediaPath?: string | null;
+  };
+  senderIdForContext: string;
+  senderDisplayName?: string;
+};
+
+export function buildBncrStructuredContextFactsFromInboundParts(
+  input: BncrStructuredContextFactsFromInboundPartsInput,
+) {
+  const mediaPath = input.prepared.mediaPath || undefined;
+  return buildBncrStructuredContextFacts({
+    channelId: input.channelId,
+    accountId: input.parsed.accountId,
+    route: {
+      agentId: input.resolution.resolvedRoute.agentId,
+      routeSessionKey: input.resolution.resolvedRoute.sessionKey,
+      dispatchSessionKey: input.resolution.dispatchSessionKey,
+      mainSessionKey: input.resolution.resolvedRoute.mainSessionKey,
+    },
+    conversation: {
+      kind: input.resolution.chatType,
+      id: input.parsed.peer.id,
+      label: input.resolution.canonicalTo,
+    },
+    reply: {
+      to: input.resolution.canonicalTo,
+      originatingTo: input.resolution.originatingTo,
+    },
+    sender: {
+      id: input.senderIdForContext,
+      displayName: input.senderDisplayName,
+    },
+    message: {
+      id: input.parsed.msgId,
+      rawBody: input.prepared.rawBody,
+      bodyForAgent: input.prepared.rawBody,
+      commandBody: input.prepared.rawBody,
+      envelopeBody: input.prepared.body,
+    },
+    media: mediaPath
+      ? [
+          {
+            path: mediaPath,
+            contentType: input.parsed.mimeType,
+            kind: inferBncrStructuredMediaKind(input.parsed.mimeType),
+            messageId: input.parsed.msgId,
+          },
+        ]
+      : [],
+  });
+}

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,39 @@
+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;
+      emitBncrLogLine(
+        'warn',
+        '[bncr] using legacy runtime.channel.turn compatibility path; upgrade path prefers runtime.channel.inbound',
+      );
+    }
+    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,