@xmoxmo/bncr 0.2.5 → 0.2.7

package/src/messaging/inbound/commands.ts

@@ -1,10 +1,27 @@
 import { emitBncrLogLine } from '../../core/logging.ts';
+import { resolveBncrChannelPolicy } from '../../core/policy.ts';
 import {
   formatDisplayScope,
   normalizeInboundSessionKey,
   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']>;
 
@@ -14,6 +31,33 @@ type NativeCommand = {
   body: string;
 };
 
+type NativeVerboseCommand = {
+  handled: true;
+  verboseLevel?: 'on' | 'off' | 'full';
+  text: string;
+};
+
+function resolveBncrNativeVerboseCommand(command: NativeCommand): NativeVerboseCommand | null {
+  if (command.command !== 'verbose') return null;
+  const rawLevel = String(command.raw.slice('/verbose'.length) || '').trim().toLowerCase();
+  if (!rawLevel || rawLevel === 'status') {
+    return { handled: true, text: 'Current verbose level is unchanged.' };
+  }
+  if (rawLevel === 'on') return { handled: true, verboseLevel: 'on', text: 'Verbose logging enabled.' };
+  if (rawLevel === 'off') return { handled: true, verboseLevel: 'off', text: 'Verbose logging disabled.' };
+  if (rawLevel === 'full') return { handled: true, verboseLevel: 'full', text: 'Verbose logging set to full.' };
+  return { handled: true, text: `Unrecognized verbose level "${rawLevel}". Valid levels: off, on, full.` };
+}
+
+function logBncrNativeCommandEvent(
+  event: string,
+  fields: Record<string, unknown>,
+  options?: { debugOnly?: boolean; debugEnabled?: boolean },
+) {
+  if (options?.debugOnly && !options?.debugEnabled) return;
+  emitBncrLogLine('info', `[bncr] native-command ${JSON.stringify({ event, ...fields })}`);
+}
+
 export function parseBncrNativeCommand(text: string): NativeCommand | null {
   const raw = String(text || '').trim();
   if (!raw.startsWith('/')) return null;
@@ -45,7 +89,10 @@ export async function handleBncrNativeCommand(params: {
     mediaLocalRoots?: readonly string[];
   }) => Promise<void>;
   logger?: { warn?: (msg: string) => void; error?: (msg: string) => void };
-}): Promise<{ handled: false } | { handled: true; command: string; sessionKey: string }> {
+}): Promise<
+  | { handled: false }
+  | { handled: true; command: string; sessionKey: string; fallbackToAgent?: boolean }
+> {
   const {
     api,
     channelId,
@@ -56,11 +103,23 @@ export async function handleBncrNativeCommand(params: {
     enqueueFromReply,
     logger,
   } = params;
-  const { accountId, route, peer, sessionKeyfromroute, clientId, extracted, msgId } = parsed;
+  const { accountId, route, peer, sessionKeyfromroute, providedOriginatingTo, clientId, extracted, msgId } = parsed;
   const command = parseBncrNativeCommand(extracted.text);
   if (!command) return { handled: false };
+  const nativeCommandDebugEnabled = cfg?.channels?.[channelId]?.debug?.verbose === true;
+
+  logBncrNativeCommandEvent(
+    'detected',
+    {
+      command: command.command,
+      accountId,
+      to: formatDisplayScope(route),
+      msgId: msgId || null,
+    },
+    { debugOnly: true, debugEnabled: nativeCommandDebugEnabled },
+  );
 
-  const resolvedRoute = api.runtime.channel.routing.resolveAgentRoute({
+  const resolvedRoute = resolveOpenClawAgentRoute(api, {
     cfg,
     channel: channelId,
     accountId,
@@ -77,102 +136,296 @@ export async function handleBncrNativeCommand(params: {
     rememberSessionRoute(taskSessionKey, accountId, route);
 
   const displayTo = formatDisplayScope(route);
+  const originatingTo = providedOriginatingTo || displayTo;
   const body = command.body;
   if (!clientId) {
-    emitBncrLogLine('warn', '[bncr] inbound missing clientId for native command identity');
-    return { handled: false };
+    emitBncrLogLine(
+      'warn',
+      '[bncr] inbound missing clientId for native command identity; using route identity fallback',
+    );
   }
-  const senderIdForContext = clientId;
-  const senderDisplayName = 'bncr-client';
-  const storePath = api.runtime.channel.session.resolveStorePath(cfg?.session?.store, {
+  const senderIdForContext = clientId || displayTo;
+  const senderDisplayName = clientId ? 'bncr-client' : displayTo;
+  const storePath = resolveBncrInboundSessionStorePath({
+    storeConfig: cfg?.session?.store,
     agentId: resolvedRoute.agentId,
   });
 
-  const ctxPayload = api.runtime.channel.reply.finalizeInboundContext({
-    Body: body,
-    BodyForAgent: body,
-    RawBody: body,
-    CommandBody: body,
-    BodyForCommands: body,
-    From: senderIdForContext,
-    To: displayTo,
-    SessionKey: sessionKey,
-    CommandTargetSessionKey: sessionKey,
-    CommandSource: 'native',
-    CommandAuthorized: true,
-    AccountId: accountId,
-    ChatType: peer.kind,
-    ConversationLabel: displayTo,
-    SenderId: senderIdForContext,
-    SenderName: senderDisplayName,
-    SenderUsername: senderDisplayName,
-    Provider: channelId,
-    Surface: channelId,
-    WasMentioned: true,
-    MessageSid: msgId,
-    Timestamp: Date.now(),
-    OriginatingChannel: channelId,
-    OriginatingTo: displayTo,
+  const ctxPayload = resolveBncrChannelInboundRuntime(api).buildContext({
+    channel: channelId,
+    provider: channelId,
+    surface: channelId,
+    accountId,
+    messageId: msgId,
+    timestamp: Date.now(),
+    from: senderIdForContext,
+    sender: {
+      id: senderIdForContext,
+      name: senderDisplayName,
+      username: senderDisplayName,
+    },
+    conversation: {
+      kind: peer.kind,
+      id: peer.id,
+      label: displayTo,
+      routePeer: {
+        kind: peer.kind,
+        id: peer.id,
+      },
+    },
+    route: {
+      agentId: resolvedRoute.agentId,
+      accountId,
+      routeSessionKey: resolvedRoute.sessionKey,
+      dispatchSessionKey: sessionKey,
+      mainSessionKey: resolvedRoute.mainSessionKey,
+    },
+    reply: {
+      to: displayTo,
+      originatingTo,
+      replyToId: msgId,
+    },
+    message: {
+      inboundEventKind: 'user_request',
+      body,
+      rawBody: body,
+      bodyForAgent: body,
+      commandBody: body,
+      envelopeFrom: originatingTo,
+      senderLabel: senderDisplayName,
+    },
+    commandTurn: {
+      kind: 'native',
+      source: 'native',
+      authorized: true,
+      body,
+    },
+    access: {
+      mentions: {
+        canDetectMention: true,
+        wasMentioned: true,
+        effectiveWasMentioned: true,
+      },
+      commands: {
+        authorized: true,
+        allowTextCommands: true,
+        useAccessGroups: false,
+        authorizers: [],
+      },
+    },
+    extra: {
+      OriginatingChannel: channelId,
+    },
+  });
+
+  const sessionIdentityPatch = buildBncrInboundSessionIdentityPatch({
+    channelId,
+    accountId,
+    chatType: peer.kind,
+    displayTo,
+    senderId: senderIdForContext,
   });
 
-  await api.runtime.channel.session.recordInboundSession({
+  const nativeVerbose = resolveBncrNativeVerboseCommand(command);
+  if (nativeVerbose) {
+    logBncrNativeCommandEvent('handled-verbose', {
+      command: command.command,
+      accountId,
+      sessionKey,
+      to: displayTo,
+      msgId: msgId || null,
+      fallbackToAgent: false,
+    });
+    await recordAndPatchBncrInboundSessionEntry({
+      storePath,
+      sessionKey,
+      ctx: ctxPayload,
+      patch: {
+        ...sessionIdentityPatch,
+        ...(nativeVerbose.verboseLevel ? { verboseLevel: nativeVerbose.verboseLevel } : {}),
+      },
+    });
+    rememberSessionRoute(baseSessionKey, accountId, route);
+    await enqueueFromReply({
+      accountId,
+      sessionKey,
+      route,
+      payload: {
+        text: nativeVerbose.text,
+        replyToId: msgId || undefined,
+      },
+    });
+    return { handled: true, command: command.command, sessionKey };
+  }
+
+  await recordAndPatchBncrInboundSessionEntry({
     storePath,
     sessionKey,
     ctx: ctxPayload,
-    onRecordError: (err: unknown) => {
-      emitBncrLogLine(
-        'warn',
-        `[bncr] inbound record native command session failed: ${String(err)}`,
-      );
-    },
+    patch: sessionIdentityPatch,
   });
 
   const effectiveReply = buildBncrReplyConfig(cfg);
+  const channelPolicy = resolveBncrChannelPolicy(cfg?.channels?.bncr || {});
+  const pinnedMainDmOwner =
+    peer.kind === 'direct'
+      ? resolveBncrPinnedMainDmOwnerFromAllowlist({
+          dmScope: cfg?.session?.dmScope,
+          allowFrom: channelPolicy.allowFrom,
+          normalizeEntry: (entry: string) => String(entry || '').trim(),
+        })
+      : null;
+  const inboundLastRouteSessionKey = resolveOpenClawInboundLastRouteSessionKey({
+    route: resolvedRoute,
+    sessionKey,
+  });
 
   let responded = false;
-  await api.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-    ctx: ctxPayload,
-    cfg: effectiveReply.replyCfg,
-    dispatcherOptions: {
-      deliver: async (
-        payload: { text?: string; mediaUrl?: string; mediaUrls?: string[]; audioAsVoice?: boolean },
-        info?: { kind?: 'tool' | 'block' | 'final' },
-      ) => {
-        const kind = info?.kind;
-        const shouldForwardTool = effectiveReply.blockStreaming && effectiveReply.allowTool;
-
-        if (kind === 'tool' && !shouldForwardTool) {
-          return;
-        }
-
-        const hasPayload = Boolean(
-          payload?.text ||
-            payload?.mediaUrl ||
-            (Array.isArray(payload?.mediaUrls) && payload.mediaUrls.length > 0),
-        );
-        if (!hasPayload) return;
-        responded = true;
-        await enqueueFromReply({
-          accountId,
-          sessionKey,
-          route,
-          payload: {
-            ...payload,
-            kind: kind as 'tool' | 'block' | 'final' | undefined,
-            replyToId: msgId || undefined,
-          },
-        });
-      },
+  logBncrNativeCommandEvent(
+    'dispatch-native-turn',
+    {
+      command: command.command,
+      accountId,
+      sessionKey,
+      to: displayTo,
+      msgId: msgId || null,
     },
-    replyOptions: {
-      disableBlockStreaming: !effectiveReply.blockStreaming,
-      shouldEmitToolResult: effectiveReply.allowTool ? () => true : undefined,
+    { debugOnly: true, debugEnabled: nativeCommandDebugEnabled },
+  );
+  await resolveBncrChannelInboundRuntime(api).run({
+    channel: channelId,
+    accountId,
+    raw: parsed,
+    adapter: {
+      ingest: () => ({
+        id: msgId ?? `${displayTo}:${Date.now()}`,
+        timestamp: Date.now(),
+        rawText: body,
+        textForAgent: ctxPayload.BodyForAgent,
+        textForCommands: ctxPayload.CommandBody,
+        raw: parsed,
+      }),
+      resolveTurn: () => ({
+        channel: channelId,
+        accountId,
+        routeSessionKey: resolvedRoute.sessionKey,
+        storePath,
+        ctxPayload,
+        recordInboundSession: wrapBncrInboundRecordSessionLabelCorrection({
+          recordInboundSession: recordBncrInboundSession,
+          expectedLabel: displayTo,
+        }),
+        record: {
+          updateLastRoute:
+            peer.kind === 'direct'
+              ? {
+                  sessionKey: inboundLastRouteSessionKey,
+                  channel: channelId,
+                  to: displayTo,
+                  accountId,
+                  mainDmOwnerPin:
+                    inboundLastRouteSessionKey === resolvedRoute.mainSessionKey && pinnedMainDmOwner
+                      ? {
+                          ownerRecipient: pinnedMainDmOwner,
+                          senderRecipient: senderIdForContext,
+                        }
+                      : undefined,
+                }
+              : undefined,
+          onRecordError: (err: unknown) => {
+            emitBncrLogLine(
+              'warn',
+              `[bncr] inbound record native command session failed: ${String(err)}`,
+            );
+          },
+        },
+        runDispatch: () =>
+          dispatchOpenClawReplyWithBufferedBlockDispatcher(api, {
+            ctx: ctxPayload,
+            cfg: effectiveReply.replyCfg,
+            dispatcherOptions: {
+              deliver: async (
+                payload: {
+                  text?: string;
+                  mediaUrl?: string;
+                  mediaUrls?: string[];
+                  audioAsVoice?: boolean;
+                },
+                info?: { kind?: 'tool' | 'block' | 'final' },
+              ) => {
+                const kind = info?.kind;
+                const shouldForwardTool = effectiveReply.blockStreaming && effectiveReply.allowTool;
+
+                if (kind === 'tool' && !shouldForwardTool) {
+                  return;
+                }
+
+                const hasPayload = Boolean(
+                  payload?.text ||
+                    payload?.mediaUrl ||
+                    (Array.isArray(payload?.mediaUrls) && payload.mediaUrls.length > 0),
+                );
+                if (!hasPayload) return;
+                if (!responded) {
+                  logBncrNativeCommandEvent(
+                    'payload-produced',
+                    {
+                      command: command.command,
+                      accountId,
+                      sessionKey,
+                      to: displayTo,
+                      msgId: msgId || null,
+                      kind: kind || null,
+                      fallbackToAgent: false,
+                    },
+                    { debugOnly: true, debugEnabled: nativeCommandDebugEnabled },
+                  );
+                }
+                responded = true;
+                await enqueueFromReply({
+                  accountId,
+                  sessionKey,
+                  route,
+                  payload: {
+                    ...payload,
+                    kind: kind as 'tool' | 'block' | 'final' | undefined,
+                    replyToId: msgId || undefined,
+                  },
+                });
+              },
+            },
+            replyOptions: {
+              disableBlockStreaming: !effectiveReply.blockStreaming,
+              shouldEmitToolResult: effectiveReply.allowTool ? () => true : undefined,
+            },
+          }),
+      }),
     },
   });
 
   if (!responded) {
-    return { handled: false };
+    logBncrNativeCommandEvent('no-payload-fallback-to-agent', {
+      command: command.command,
+      accountId,
+      sessionKey,
+      to: displayTo,
+      msgId: msgId || null,
+      fallbackToAgent: true,
+    });
+    return { handled: true, command: command.command, sessionKey, fallbackToAgent: true };
   }
 
+  logBncrNativeCommandEvent(
+    'handled-with-payload',
+    {
+      command: command.command,
+      accountId,
+      sessionKey,
+      to: displayTo,
+      msgId: msgId || null,
+      fallbackToAgent: false,
+    },
+    { debugOnly: true, debugEnabled: nativeCommandDebugEnabled },
+  );
   return { handled: true, command: command.command, sessionKey };
 }

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,
+          },
+        ]
+      : [],
+  });
+}