@xmoxmo/bncr 0.4.5 → 0.4.7

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

@@ -1,41 +1,93 @@
+import { readBncrSessionUpdatedAt } from '../../openclaw/inbound-session-runtime.ts';
+import { resolveOpenClawEnvelopeFormatOptions } from '../../openclaw/reply-runtime.ts';
 import {
   buildBncrPromptVisibleContextFacts,
   buildBncrStructuredContextFactsFromInboundParts,
 } from './context-facts.ts';
-import type { BncrInboundApi, BncrInboundContextPayload } from './contracts.ts';
+import type { BncrInboundApi, BncrInboundConfig, BncrInboundContextPayload } from './contracts.ts';
 import type {
   BncrInboundConversationResolution,
   BncrPreparedInboundSessionContext,
   ParsedInbound,
 } from './dispatch-prep.ts';
+import {
+  type BncrGroupHistoryMap,
+  buildBncrInboundHistory,
+  buildBncrPendingGroupContext,
+} from './group-history.ts';
 import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
 
+function parseSlashCommandName(body: string): string | undefined {
+  const raw = String(body || '').trim();
+  if (!raw.startsWith('/')) return undefined;
+  return raw.slice(1).split(/\s+/, 1)[0]?.split('@', 1)[0] || undefined;
+}
+
+function applyBncrLegacyCommandFields(args: {
+  ctx: BncrInboundContextPayload;
+  channelId: string;
+  senderIdForContext: string;
+  resolution: BncrInboundConversationResolution;
+  rawBody: string;
+  ownerAllowFrom?: string[];
+  isAuthorizedTextCommand: boolean;
+}) {
+  const { ctx, channelId, senderIdForContext, resolution, rawBody, ownerAllowFrom } = args;
+  ctx.From = senderIdForContext;
+  ctx.To = resolution.canonicalTo;
+  ctx.SenderId = senderIdForContext;
+  ctx.OriginatingChannel = channelId;
+  if (ownerAllowFrom?.length) ctx.OwnerAllowFrom = ownerAllowFrom;
+  if (args.isAuthorizedTextCommand) {
+    ctx.CommandAuthorized = true;
+    ctx.CommandSource = 'text';
+    ctx.CommandTurn = {
+      kind: 'text-slash',
+      source: 'text',
+      authorized: true,
+      commandName: parseSlashCommandName(rawBody),
+      body: rawBody,
+    };
+  }
+  return ctx;
+}
+
 export function buildBncrInboundTurnContext(args: {
   api: BncrInboundApi;
+  cfg: BncrInboundConfig;
   channelId: string;
   parsed: ParsedInbound;
   msgId?: string | null;
-  mimeType?: string;
-  mediaPath?: string;
   peer: ParsedInbound['peer'];
   senderIdForContext: string;
   senderDisplayName: string;
+  ownerAllowFrom?: string[];
+  bridgeSenderId?: string;
+  bridgeSenderName?: string;
   resolution: BncrInboundConversationResolution;
   prepared: BncrPreparedInboundSessionContext;
+  groupHistories: BncrGroupHistoryMap;
+  shouldDispatch: boolean;
 }): BncrInboundContextPayload | Promise<BncrInboundContextPayload> {
   const {
     api,
+    cfg,
     channelId,
     parsed,
     msgId,
-    mimeType,
-    mediaPath,
     peer,
     senderIdForContext,
     senderDisplayName,
+    ownerAllowFrom,
+    bridgeSenderId,
+    bridgeSenderName,
     resolution,
     prepared,
+    groupHistories,
+    shouldDispatch,
   } = args;
+  const senderIsOwner = parsed.isAdmin === true || Boolean(ownerAllowFrom?.length);
+  const senderIsAuthorized = senderIsOwner;
   const structuredContextFacts = buildBncrStructuredContextFactsFromInboundParts({
     channelId,
     parsed,
@@ -43,11 +95,14 @@ export function buildBncrInboundTurnContext(args: {
     prepared: {
       rawBody: prepared.rawBody,
       body: prepared.body,
-      mediaPath,
-      mediaContentType: mimeType,
+      mediaItems: prepared.mediaItems,
     },
     senderIdForContext,
     senderDisplayName,
+    bridgeSenderId,
+    bridgeSenderName,
+    senderIsOwner,
+    senderIsAuthorized,
   });
   const promptVisibleContextFacts = buildBncrPromptVisibleContextFacts(structuredContextFacts);
   const supplementalUntrustedContext = Object.keys(promptVisibleContextFacts).length
@@ -60,72 +115,130 @@ export function buildBncrInboundTurnContext(args: {
         },
       ]
     : [];
+  const platformWantsReply = parsed.shouldRespond === true;
+  const wasMentioned = parsed.isBotMentioned === true || platformWantsReply;
+  const isAuthorizedTextCommand = Boolean(ownerAllowFrom?.length);
+  const bodyForAgent =
+    shouldDispatch && parsed.peer.kind === 'group'
+      ? buildBncrPendingGroupContext({
+          api,
+          historyMap: groupHistories,
+          parsed,
+          channelLabel: resolution.canonicalTo,
+          currentTimestamp: Date.now(),
+          previousTimestamp: readBncrSessionUpdatedAt(api, {
+            storePath: prepared.storePath,
+            sessionKey: resolution.dispatchSessionKey,
+          }),
+          envelope: resolveOpenClawEnvelopeFormatOptions(api, cfg),
+          currentMessage: prepared.body,
+        })
+      : prepared.body;
+  const inboundHistory =
+    shouldDispatch && parsed.peer.kind === 'group'
+      ? buildBncrInboundHistory({ historyMap: groupHistories, parsed })
+      : undefined;
 
-  return resolveBncrChannelInboundRuntime(api).buildContext({
-    channel: channelId,
-    provider: channelId,
-    surface: channelId,
-    accountId: resolution.accountId,
-    messageId: msgId,
-    timestamp: Date.now(),
-    from: senderIdForContext,
-    sender: {
-      id: senderIdForContext,
-      name: senderDisplayName,
-      username: senderDisplayName,
-    },
-    conversation: {
-      kind: resolution.chatType,
-      id: peer.id,
-      label: resolution.canonicalTo,
-      routePeer: {
-        kind: peer.kind,
+  return Promise.resolve(
+    resolveBncrChannelInboundRuntime(api).buildContext({
+      channel: channelId,
+      provider: channelId,
+      surface: channelId,
+      accountId: resolution.accountId,
+      messageId: msgId,
+      timestamp: Date.now(),
+      from: senderIdForContext,
+      sender: {
+        id: senderIdForContext,
+        name: senderDisplayName,
+        username: parsed.userName || senderDisplayName,
+      },
+      conversation: {
+        kind: resolution.chatType,
         id: peer.id,
+        label: resolution.canonicalTo,
+        routePeer: {
+          kind: peer.kind,
+          id: peer.id,
+        },
       },
-    },
-    route: {
-      agentId: resolution.resolvedRoute.agentId,
-      accountId: resolution.accountId,
-      routeSessionKey: resolution.resolvedRoute.sessionKey,
-      dispatchSessionKey: resolution.dispatchSessionKey,
-      mainSessionKey: resolution.resolvedRoute.mainSessionKey,
-    },
-    reply: {
-      to: resolution.canonicalTo,
-      originatingTo: resolution.originatingTo,
-    },
-    message: {
-      inboundEventKind: 'user_request',
-      body: prepared.body,
+      route: {
+        agentId: resolution.resolvedRoute.agentId,
+        accountId: resolution.accountId,
+        routeSessionKey: resolution.resolvedRoute.sessionKey,
+        dispatchSessionKey: resolution.dispatchSessionKey,
+        mainSessionKey: resolution.resolvedRoute.mainSessionKey,
+      },
+      reply: {
+        to: resolution.canonicalTo,
+        originatingTo: resolution.originatingTo,
+      },
+      message: {
+        inboundEventKind: 'user_request',
+        body: prepared.body,
+        rawBody: prepared.rawBody,
+        bodyForAgent,
+        inboundHistory,
+        commandBody: prepared.rawBody,
+        envelopeFrom: resolution.originatingTo,
+        senderLabel: senderDisplayName,
+      },
+      ...(isAuthorizedTextCommand
+        ? {
+            commandTurn: {
+              kind: 'text-slash' as const,
+              source: 'text' as const,
+              authorized: true,
+              commandName: parseSlashCommandName(prepared.rawBody),
+              body: prepared.rawBody,
+            },
+          }
+        : {}),
+      media:
+        prepared.mediaItems.length > 0
+          ? prepared.mediaItems.map((item) => ({
+              path: item.path,
+              contentType: item.contentType,
+              kind: item.kind,
+              messageId: msgId ?? undefined,
+            }))
+          : [],
+      access: {
+        mentions: {
+          canDetectMention: true,
+          wasMentioned,
+          effectiveWasMentioned: wasMentioned,
+        },
+        ...(isAuthorizedTextCommand
+          ? {
+              commands: {
+                authorized: true,
+                allowTextCommands: true,
+                useAccessGroups: false,
+                authorizers: [],
+              },
+            }
+          : {}),
+      },
+      supplemental: {
+        untrustedContext: supplementalUntrustedContext,
+      },
+      extra: {
+        OriginatingChannel: channelId,
+        ...(ownerAllowFrom?.length ? { OwnerAllowFrom: ownerAllowFrom } : {}),
+        BncrStructuredContextFacts: structuredContextFacts,
+        StructuredContextFacts: structuredContextFacts,
+      },
+    }),
+  ).then((ctx) =>
+    applyBncrLegacyCommandFields({
+      ctx,
+      channelId,
+      senderIdForContext,
+      resolution,
       rawBody: prepared.rawBody,
-      bodyForAgent: prepared.rawBody,
-      commandBody: prepared.rawBody,
-      envelopeFrom: resolution.originatingTo,
-      senderLabel: senderDisplayName,
-    },
-    media: mediaPath
-      ? [
-          {
-            path: mediaPath,
-            contentType: mimeType,
-            kind: mimeType?.startsWith('image/')
-              ? 'image'
-              : mimeType?.startsWith('video/')
-                ? 'video'
-                : mimeType?.startsWith('audio/')
-                  ? 'audio'
-                  : 'document',
-            messageId: msgId ?? undefined,
-          },
-        ]
-      : [],
-    supplemental: {
-      untrustedContext: supplementalUntrustedContext,
-    },
-    extra: {
-      OriginatingChannel: channelId,
-      BncrStructuredContextFacts: structuredContextFacts,
-      StructuredContextFacts: structuredContextFacts,
-    },
-  });
+      ownerAllowFrom,
+      isAuthorizedTextCommand,
+    }),
+  );
 }

package/src/openclaw/channel-runtime-contracts.ts

@@ -47,6 +47,7 @@ export type OpenClawInboundRuntimeResolvedTurn = {
   record: {
     updateLastRoute: unknown;
     onRecordError: (err: unknown) => void;
+    trackSessionMetaTask?: (task: Promise<unknown>) => void;
   };
   runDispatch: () => Promise<unknown> | unknown;
 };

package/src/plugin/channel-components.ts

@@ -5,6 +5,7 @@ import { formatDisplayScope, normalizeStoredSessionKey, parseRouteLike } from '.
 import type { BncrRoute } from '../core/types.ts';
 import type { BncrInboundParamsInput } from '../messaging/inbound/contracts.ts';
 import { dispatchBncrInbound } from '../messaging/inbound/dispatch.ts';
+import type { BncrGroupHistoryMap } from '../messaging/inbound/group-history.ts';
 import { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
 import { OUTBOUND_FLUSH_REASON, OUTBOUND_FLUSH_TRIGGER } from '../messaging/outbound/reasons.ts';
 import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
@@ -150,6 +151,9 @@ export function createBncrFileInboundHandlersComponent(runtime: {
     typeof createBncrFileInboundHandlers
   >[0]['refreshAcceptedFileTransferLiveState'];
   logWarn: Parameters<typeof createBncrFileInboundHandlers>[0]['logWarn'];
+  buildCanonicalSessionKey: Parameters<
+    typeof createBncrFileInboundHandlers
+  >[0]['buildCanonicalSessionKey'];
   fileRecvTransfers: Parameters<typeof createBncrFileInboundHandlers>[0]['fileRecvTransfers'];
   inboundFileTransferMaxBytes: number;
   inboundFileTransferMaxChunks: number;
@@ -166,6 +170,7 @@ export function createBncrFileInboundHandlersComponent(runtime: {
     logWarn: runtime.logWarn,
     parseRouteLike,
     normalizeStoredSessionKey,
+    buildCanonicalSessionKey: runtime.buildCanonicalSessionKey,
     saveInboundMediaBuffer: async ({ buffer, mimeType, fileName }) =>
       await saveOpenClawChannelMediaBuffer(
         runtime.getApi(),
@@ -209,6 +214,10 @@ export function createBncrInboundHandlersComponent(runtime: {
   >[0]['buildActiveConnectionDebugList'];
   markLastInboundAt: (accountId: string) => void;
   ensureCanonicalAgentId: Parameters<typeof createBncrInboundHandlers>[0]['ensureCanonicalAgentId'];
+  defaultAdminAgentId: Parameters<typeof createBncrInboundHandlers>[0]['defaultAdminAgentId'];
+  defaultPublicAgentId: Parameters<typeof createBncrInboundHandlers>[0]['defaultPublicAgentId'];
+  sceneRegistry: Parameters<typeof createBncrInboundHandlers>[0]['sceneRegistry'];
+  groupHistories: BncrGroupHistoryMap;
   prepareInboundAcceptance: Parameters<
     typeof createBncrInboundHandlers
   >[0]['prepareInboundAcceptance'];
@@ -250,6 +259,10 @@ export function createBncrInboundHandlersComponent(runtime: {
     markLastInboundAt: runtime.markLastInboundAt,
     getConfig: () => getOpenClawRuntimeConfig(runtime.getApi()),
     ensureCanonicalAgentId: runtime.ensureCanonicalAgentId,
+    defaultAdminAgentId: runtime.defaultAdminAgentId,
+    defaultPublicAgentId: runtime.defaultPublicAgentId,
+    sceneRegistry: runtime.sceneRegistry,
+    groupHistories: runtime.groupHistories,
     prepareInboundAcceptance: runtime.prepareInboundAcceptance,
     formatDisplayScope,
     logInboundSummary: runtime.logInboundSummary,
@@ -259,13 +272,33 @@ export function createBncrInboundHandlersComponent(runtime: {
         trigger: OUTBOUND_FLUSH_TRIGGER.INBOUND,
         reason: OUTBOUND_FLUSH_REASON.INBOUND_ACCEPTED,
       }),
-    dispatchInbound: ({ cfg, parsed, canonicalAgentId }) =>
+    dispatchInbound: ({
+      cfg,
+      parsed,
+      canonicalAgentId,
+      resolvedAgentId,
+      shouldDispatch,
+      shouldAccumulate,
+      sceneRegistry,
+      groupHistories,
+      defaultAdminAgentId,
+      defaultPublicAgentId,
+      now,
+    }) =>
       dispatchBncrInbound({
         api: runtime.getApi(),
         channelId: runtime.channelId,
         cfg,
         parsed,
         canonicalAgentId,
+        resolvedAgentId,
+        shouldDispatch,
+        shouldAccumulate,
+        sceneRegistry,
+        groupHistories,
+        defaultAdminAgentId,
+        defaultPublicAgentId,
+        now,
         rememberSessionRoute: runtime.rememberSessionRoute,
         enqueueFromReply: runtime.enqueueFromReply,
         setInboundActivity: runtime.setInboundActivity,

package/src/plugin/channel-inbound-helpers.ts

@@ -55,6 +55,7 @@ export function resolveInboundSessionContext(args: {
   route: BncrRoute;
   sessionKeyFromRoute?: string;
   canonicalAgentId: string;
+  resolvedAgentId?: string;
   taskKey?: string;
   text: string;
   extractedText?: string;
@@ -74,15 +75,21 @@ export function resolveInboundSessionContext(args: {
       peer: args.peer,
     }),
   );
+  const normalizedAgentId =
+    (args.resolvedAgentId || '').trim() || resolvedRoute.agentId || args.canonicalAgentId;
   const baseSessionKey =
     normalizeInboundSessionKey(
       args.sessionKeyFromRoute || '',
       args.route,
-      args.canonicalAgentId || '',
+      normalizedAgentId || '',
     ) || resolvedRoute.sessionKey;
   const taskSessionKey = withTaskSessionKey(baseSessionKey, args.taskKey);
   return {
-    resolvedRoute,
+    resolvedRoute: {
+      ...resolvedRoute,
+      agentId: normalizedAgentId || resolvedRoute.agentId,
+      sessionKey: baseSessionKey || resolvedRoute.sessionKey,
+    },
     baseSessionKey,
     taskSessionKey,
     sessionKey: taskSessionKey || baseSessionKey,

package/src/plugin/channel-runtime-builders-delivery.ts

@@ -7,6 +7,7 @@ import type {
   FileSendTransferState,
   OutboxEntry,
 } from '../core/types.ts';
+import type { BncrGroupHistoryMap } from '../messaging/inbound/group-history.ts';
 import type { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
 import type {
   NormalizedReplyPayload,
@@ -18,7 +19,11 @@ import type {
   buildInboundAcceptedLifecycleDebugInfo as buildInboundAcceptedLifecycleDebugInfoFromRuntime,
   buildInboundResponsePayload as buildInboundResponsePayloadFromRuntime,
 } from './channel-inbound-helpers.ts';
-import type { BncrChannelConfigRoot, BncrVerifiedTarget } from './channel-runtime-types.ts';
+import type {
+  BncrChannelConfigRoot,
+  BncrSceneRecord,
+  BncrVerifiedTarget,
+} from './channel-runtime-types.ts';
 import type { LeaseEventPayload } from './connection-handlers.ts';
 import type { BncrActiveConnectionDebugEntry } from './connection-state.ts';
 import type { FileAckPayloadState, FileAckWaiter } from './file-ack-runtime.ts';
@@ -121,6 +126,11 @@ export function buildBncrStateTransientRuntime(deps: {
   maxDeadLetterEntries: number;
   maxSessionRouteEntries: number;
   maxAccountActivityEntries: number;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  groupHistories: Map<
+    string,
+    import('./channel-runtime-types.ts').BncrPersistedGroupHistoryEntry[]
+  >;
   outbox: Map<string, OutboxEntry>;
   getDeadLetter: () => OutboxEntry[];
   setDeadLetter: (entries: OutboxEntry[]) => void;
@@ -446,6 +456,15 @@ export function buildBncrInboundSurfaceRuntime(deps: {
     peer?: unknown;
     channelId?: string;
   }) => string;
+  defaultAdminAgentId: (args: {
+    cfg: BncrChannelConfigRoot;
+    accountId: string;
+    peer?: unknown;
+    channelId?: string;
+  }) => string;
+  defaultPublicAgentId: () => string;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  groupHistories: BncrGroupHistoryMap;
   prepareInboundAcceptance: (args: {
     parsed: ReturnType<typeof parseBncrInboundParams>;
     canonicalAgentId: string;
@@ -456,6 +475,9 @@ export function buildBncrInboundSurfaceRuntime(deps: {
         sessionKey: string;
         inboundText: string;
         hasMedia: boolean;
+        resolvedAgentId: string;
+        shouldDispatch: boolean;
+        shouldAccumulate: boolean;
       }
     | {
         ok: false;
@@ -486,6 +508,7 @@ export function buildBncrInboundSurfaceRuntime(deps: {
   }) => Promise<void>;
   setInboundActivity: (accountId: string, at: number) => void;
   scheduleSave: () => void;
+  buildCanonicalSessionKey: (route: BncrRoute) => string;
   fileRecvTransfers: Parameters<typeof createBncrFileInboundHandlers>[0]['fileRecvTransfers'];
   inboundFileTransferMaxBytes: number;
   inboundFileTransferMaxChunks: number;

package/src/plugin/channel-runtime-types.ts

@@ -44,6 +44,46 @@ export type BncrPersistedLastSession = {
   updatedAt: number;
 };
 
+export type BncrSceneKind = 'direct' | 'group';
+
+export type BncrSceneStatus = 'pending' | 'allowed' | 'denied';
+
+export type BncrGroupReplyMode = 'admin' | 'mention' | 'hybrid' | 'all';
+
+export type BncrSceneRecord = {
+  sceneKey: string;
+  kind: BncrSceneKind;
+  status: BncrSceneStatus;
+  platform: string;
+  userId?: string;
+  userName?: string;
+  groupId?: string;
+  groupName?: string;
+  agentId?: string;
+  groupReplyMode?: BncrGroupReplyMode;
+  lastSeenAt: number;
+};
+
+export type BncrPersistedGroupHistoryEntry = {
+  sender: string;
+  body: string;
+  timestamp?: number;
+  messageId?: string;
+  media?: BncrPersistedGroupHistoryMediaEntry[];
+};
+
+export type BncrPersistedGroupHistoryMediaEntry = {
+  path?: string;
+  contentType?: string;
+  kind?: 'image' | 'video' | 'audio' | 'document' | 'unknown';
+  messageId?: string;
+};
+
+export type BncrPersistedGroupHistoryBucket = {
+  key: string;
+  entries: BncrPersistedGroupHistoryEntry[];
+};
+
 export type BncrStatusRuntimeSnapshot = {
   connected?: boolean;
   running?: boolean;
@@ -133,6 +173,8 @@ export type PersistedState = {
   outbox: OutboxEntry[];
   deadLetter: OutboxEntry[];
   sessionRoutes: BncrPersistedSessionRoute[];
+  sceneRegistry?: BncrSceneRecord[];
+  groupHistories?: BncrPersistedGroupHistoryBucket[];
   lastSessionByAccount?: BncrPersistedLastSession[];
   lastActivityByAccount?: BncrPersistedAccountTimestamp[];
   lastInboundByAccount?: BncrPersistedAccountTimestamp[];

package/src/plugin/file-inbound-init.ts

@@ -45,34 +45,49 @@ export function createBncrFileInboundInitHandler(runtime: BncrFileInboundRuntime
     const chunkSize = runtime.finiteNonNegativeNumberOrNull(params?.chunkSize ?? 256 * 1024);
     const totalChunks = runtime.finiteNonNegativeNumberOrNull(params?.totalChunks);
     const fileSha256 = runtime.asString(params?.fileSha256 || '').trim();
+    const routeFromParams = runtime.parseRouteLike({
+      platform: runtime.asString(params?.platform || '').trim(),
+      groupId: runtime.asString(params?.groupId || '0').trim() || '0',
+      userId: runtime.asString(params?.userId || '0').trim() || '0',
+    });
+
+    const reject = (error: string) => {
+      runtime.logWarn(
+        'file',
+        `file.init reject accountId=${accountId} connId=${connId} clientId=${clientId || '-'} transferId=${transferId || '-'} error=${error} sessionKey=${sessionKey || '-'} fileSize=${fileSize ?? 'null'} chunkSize=${chunkSize ?? 'null'} totalChunks=${totalChunks ?? 'null'}`,
+      );
+      respond(false, { error });
+    };
 
     if (!transferId || !sessionKey || !fileSize || !chunkSize || !totalChunks) {
-      respond(false, { error: 'transferId/sessionKey/fileSize/chunkSize/totalChunks required' });
+      reject('transferId/sessionKey/fileSize/chunkSize/totalChunks required');
       return;
     }
     if (fileSize > runtime.inboundFileTransferMaxBytes) {
-      respond(false, {
-        error: `fileSize too large size=${fileSize} max=${runtime.inboundFileTransferMaxBytes}`,
-      });
+      reject(`fileSize too large size=${fileSize} max=${runtime.inboundFileTransferMaxBytes}`);
       return;
     }
     if (totalChunks > runtime.inboundFileTransferMaxChunks) {
-      respond(false, {
-        error: `totalChunks too large total=${totalChunks} max=${runtime.inboundFileTransferMaxChunks}`,
-      });
+      reject(
+        `totalChunks too large total=${totalChunks} max=${runtime.inboundFileTransferMaxChunks}`,
+      );
       return;
     }
     const expectedTotalChunks = Math.ceil(fileSize / chunkSize);
     if (totalChunks !== expectedTotalChunks) {
-      respond(false, {
-        error: `totalChunks mismatch total=${totalChunks} expected=${expectedTotalChunks}`,
-      });
+      reject(`totalChunks mismatch total=${totalChunks} expected=${expectedTotalChunks}`);
       return;
     }
 
-    const normalized = runtime.normalizeStoredSessionKey(sessionKey);
+    let normalized = runtime.normalizeStoredSessionKey(sessionKey);
+    if (!normalized && routeFromParams) {
+      normalized = {
+        sessionKey: runtime.buildCanonicalSessionKey(routeFromParams),
+        route: routeFromParams,
+      };
+    }
     if (!normalized) {
-      respond(false, { error: 'invalid sessionKey' });
+      reject('invalid sessionKey');
       return;
     }
 

package/src/plugin/file-inbound-runtime.ts

@@ -1,4 +1,5 @@
 import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrSessionKind } from '../core/targets.ts';
 import type { BncrRoute, FileRecvTransferState } from '../core/types.ts';
 
 export type BncrFileInboundLeaseEventKind =
@@ -40,6 +41,7 @@ export type BncrFileInboundRuntime = {
   normalizeStoredSessionKey: (
     sessionKey: string,
   ) => { sessionKey: string; route: BncrRoute } | null;
+  buildCanonicalSessionKey: (route: BncrRoute, kind?: BncrSessionKind) => string;
   saveInboundMediaBuffer: (args: {
     buffer: Buffer;
     mimeType: string;