@xmoxmo/bncr 0.4.6 → 0.4.8

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

@@ -5,6 +5,37 @@ import {
   updateBncrSessionStoreEntry,
 } from '../../openclaw/inbound-session-runtime.ts';
 
+function formatBncrSessionLabel(displayTo: string): string {
+  const raw = String(displayTo || '').trim();
+  const parts = raw.split(':');
+  if (parts.length === 4 && parts[0] === 'Bncr') {
+    const [, platform, groupId, userId] = parts;
+    if (platform && groupId && groupId !== '0') return `Bncr:${platform}:Group:${groupId}`;
+    if (platform && userId && userId !== '0') return `Bncr:${platform}:User:${userId}`;
+  }
+  return raw;
+}
+
+function formatBncrSessionRouteTarget(displayTo: string): string {
+  const raw = String(displayTo || '').trim();
+  const parts = raw.split(':');
+  if (parts.length === 4 && parts[0] === 'Bncr') {
+    const [, platform, groupId, userId] = parts;
+    if (platform && groupId && groupId !== '0') return `Bncr:${platform}:${groupId}:0`;
+    if (platform && userId && userId !== '0') return `Bncr:${platform}:0:${userId}`;
+  }
+  return raw;
+}
+
+function formatBncrSessionGroupKey(displayTo: string): string | null {
+  const raw = String(displayTo || '').trim();
+  const parts = raw.split(':');
+  if (parts.length !== 4 || parts[0] !== 'Bncr') return null;
+  const [, platform, groupId] = parts;
+  if (!platform || !groupId || groupId === '0') return null;
+  return `${platform.toLowerCase()}:${groupId}`;
+}
+
 type RecordInboundSessionFn = (args: {
   storePath?: string;
   sessionKey?: string;
@@ -21,30 +52,35 @@ export function buildBncrInboundSessionIdentityPatch(args: {
   senderId: string;
 }) {
   const { channelId, accountId, chatType, displayTo, senderId } = args;
+  const displayLabel = formatBncrSessionLabel(displayTo);
+  const routeTarget = formatBncrSessionRouteTarget(displayTo);
+  const groupKey = chatType === 'group' ? formatBncrSessionGroupKey(displayTo) : null;
   return {
-    label: displayTo,
+    label: displayLabel,
+    displayName: displayLabel,
     channel: channelId,
     chatType,
+    ...(groupKey ? { groupId: groupKey } : {}),
     origin: {
-      label: displayTo,
+      label: displayLabel,
       provider: channelId,
       surface: channelId,
       chatType,
       from: senderId,
-      to: displayTo,
+      to: routeTarget,
       accountId,
     },
     deliveryContext: {
       channel: channelId,
-      to: displayTo,
+      to: routeTarget,
       accountId,
     },
     route: {
       channel: channelId,
       accountId,
-      target: { to: displayTo },
+      target: { to: routeTarget },
     },
-    lastTo: displayTo,
+    lastTo: routeTarget,
   };
 }
 
@@ -56,20 +92,93 @@ function normalizeNonEmptyString(value: unknown): string | null {
 export async function correctBncrInboundSessionLabel(args: {
   storePath: string;
   sessionKey: string;
-  expectedLabel: string;
+  expectedPatch: Record<string, unknown>;
 }) {
   const storePath = normalizeNonEmptyString(args.storePath);
   const sessionKey = normalizeNonEmptyString(args.sessionKey);
-  const expectedLabel = normalizeNonEmptyString(args.expectedLabel);
-  if (!storePath || !sessionKey || !expectedLabel) return;
+  if (!storePath || !sessionKey) return;
+
+  const expectedPatch = args.expectedPatch;
+  const expectedLabel = normalizeNonEmptyString(expectedPatch.label);
+  const expectedDisplayName = normalizeNonEmptyString(expectedPatch.displayName);
+  const expectedGroupId = normalizeNonEmptyString(expectedPatch.groupId);
+  const expectedOriginTo = normalizeNonEmptyString(
+    (expectedPatch.origin as { to?: unknown } | undefined)?.to,
+  );
+  const expectedDeliveryTo = normalizeNonEmptyString(
+    (expectedPatch.deliveryContext as { to?: unknown } | undefined)?.to,
+  );
+  const expectedRouteTo = normalizeNonEmptyString(
+    (
+      (expectedPatch.route as { target?: { to?: unknown } } | undefined)?.target as
+        | { to?: unknown }
+        | undefined
+    )?.to,
+  );
+  const expectedLastTo = normalizeNonEmptyString(expectedPatch.lastTo);
+  if (
+    !expectedLabel ||
+    !expectedDisplayName ||
+    !expectedOriginTo ||
+    !expectedDeliveryTo ||
+    !expectedRouteTo ||
+    !expectedLastTo
+  )
+    return;
 
   try {
     await updateBncrSessionStoreEntry({
       storePath,
       sessionKey,
       update: (entry: SessionStoreEntryLike) => {
-        if (entry?.label === expectedLabel) return null;
-        return { label: expectedLabel };
+        const origin =
+          entry?.origin && typeof entry.origin === 'object'
+            ? (entry.origin as Record<string, unknown>)
+            : {};
+        const deliveryContext =
+          entry?.deliveryContext && typeof entry.deliveryContext === 'object'
+            ? (entry.deliveryContext as Record<string, unknown>)
+            : {};
+        const route =
+          entry?.route && typeof entry.route === 'object'
+            ? (entry.route as Record<string, unknown>)
+            : {};
+        const routeTarget =
+          route.target && typeof route.target === 'object'
+            ? (route.target as Record<string, unknown>)
+            : {};
+
+        const unchanged =
+          entry?.label === expectedLabel &&
+          entry?.displayName === expectedDisplayName &&
+          normalizeNonEmptyString(entry?.groupId) === expectedGroupId &&
+          normalizeNonEmptyString(origin.to) === expectedOriginTo &&
+          normalizeNonEmptyString(deliveryContext.to) === expectedDeliveryTo &&
+          normalizeNonEmptyString(routeTarget.to) === expectedRouteTo &&
+          normalizeNonEmptyString(entry?.lastTo) === expectedLastTo;
+        if (unchanged) return null;
+
+        return {
+          ...(expectedGroupId ? { groupId: expectedGroupId } : {}),
+          label: expectedLabel,
+          displayName: expectedDisplayName,
+          origin: {
+            ...origin,
+            ...(expectedPatch.origin as Record<string, unknown>),
+          },
+          deliveryContext: {
+            ...deliveryContext,
+            ...(expectedPatch.deliveryContext as Record<string, unknown>),
+          },
+          route: {
+            ...route,
+            ...(expectedPatch.route as Record<string, unknown>),
+            target: {
+              to: expectedRouteTo,
+            },
+          },
+          lastTo: expectedLastTo,
+        };
       },
     });
   } catch (err) {
@@ -108,7 +217,7 @@ export async function recordAndPatchBncrInboundSessionEntry(args: {
 
 export function wrapBncrInboundRecordSessionLabelCorrection(args: {
   recordInboundSession: RecordInboundSessionFn;
-  expectedLabel: string;
+  expectedPatch: Record<string, unknown>;
 }): RecordInboundSessionFn {
   return async (recordArgs) => {
     const result = await args.recordInboundSession(recordArgs);
@@ -116,7 +225,7 @@ export function wrapBncrInboundRecordSessionLabelCorrection(args: {
     await correctBncrInboundSessionLabel({
       storePath: recordArgs.storePath,
       sessionKey: recordArgs.sessionKey,
-      expectedLabel: args.expectedLabel,
+      expectedPatch: args.expectedPatch,
     });
     return result;
   };

package/src/messaging/inbound/session-meta-task.ts

@@ -0,0 +1,17 @@
+export function createBncrSessionMetaTaskBarrier() {
+  const pending = new Set<Promise<unknown>>();
+
+  return {
+    track(task: Promise<unknown>) {
+      if (!task || typeof task.then !== 'function') return;
+      pending.add(task);
+      void task.finally(() => {
+        pending.delete(task);
+      });
+    },
+    async wait() {
+      if (pending.size === 0) return;
+      await Promise.allSettled([...pending]);
+    },
+  };
+}

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,22 +259,47 @@ 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,
+    enqueueFromReply: runtime.enqueueFromReply,
     flushOnInboundAccepted: (accountId) =>
       runtime.flushPushQueueBestEffort({
         accountId,
         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,