@xmoxmo/bncr 0.2.6 → 0.2.8

package/src/core/extended-diagnostics.ts

@@ -2,6 +2,10 @@ import type { RegisterTraceEntry } from './register-trace.ts';
 
 type ExtendedDiagnosticsInput = {
   diagnostics: Record<string, any>;
+  runtimeSurface?: {
+    channel: Record<string, boolean>;
+    missing: string[];
+  };
   register: {
     bridgeId: string;
     gatewayPid: number;
@@ -48,6 +52,12 @@ type ExtendedDiagnosticsInput = {
 export function buildExtendedDiagnostics(input: ExtendedDiagnosticsInput) {
   return {
     ...input.diagnostics,
+    runtimeSurface: input.runtimeSurface
+      ? {
+          channel: { ...input.runtimeSurface.channel },
+          missing: input.runtimeSurface.missing.slice(),
+        }
+      : undefined,
     register: {
       ...input.register,
       traceRecent: input.register.traceRecent.slice(),

package/src/core/file-ack.ts

@@ -0,0 +1,9 @@
+export function buildFileAckKey(args: {
+  transferId: string;
+  stage: string;
+  chunkIndex?: number;
+}): string {
+  const n = Number(args.chunkIndex);
+  const idx = Number.isInteger(n) && n >= 0 ? String(n) : '-';
+  return `${args.transferId}|${args.stage}|${idx}`;
+}

package/src/core/file-transfer-payloads.ts

@@ -0,0 +1,72 @@
+import type { BncrRoute } from './accounts.ts';
+
+export function buildFileTransferInitPayload(args: {
+  transferId: string;
+  sessionKey: string;
+  route: BncrRoute;
+  fileName: string;
+  mimeType?: string;
+  fileSize: number;
+  chunkSize: number;
+  totalChunks: number;
+  fileSha256: string;
+  ts: number;
+}) {
+  return {
+    transferId: args.transferId,
+    direction: 'oc2bncr' as const,
+    sessionKey: args.sessionKey,
+    platform: args.route.platform,
+    groupId: args.route.groupId,
+    userId: args.route.userId,
+    fileName: args.fileName,
+    mimeType: args.mimeType,
+    fileSize: args.fileSize,
+    chunkSize: args.chunkSize,
+    totalChunks: args.totalChunks,
+    fileSha256: args.fileSha256,
+    ts: args.ts,
+  };
+}
+
+export function buildFileTransferChunkPayload(args: {
+  transferId: string;
+  chunkIndex: number;
+  offset: number;
+  size: number;
+  chunkSha256: string;
+  base64: string;
+  ts: number;
+}) {
+  return {
+    transferId: args.transferId,
+    chunkIndex: args.chunkIndex,
+    offset: args.offset,
+    size: args.size,
+    chunkSha256: args.chunkSha256,
+    base64: args.base64,
+    ts: args.ts,
+  };
+}
+
+export function buildFileTransferAbortPayload(args: {
+  transferId: string;
+  reason: string;
+  ts: number;
+}) {
+  return {
+    transferId: args.transferId,
+    reason: args.reason,
+    ts: args.ts,
+  };
+}
+
+export function buildFileTransferCompletePayload(args: {
+  transferId: string;
+  ts: number;
+}) {
+  return {
+    transferId: args.transferId,
+    ts: args.ts,
+  };
+}

package/src/core/register-trace.ts

@@ -33,6 +33,19 @@ export type RegisterTraceSummary = {
   likelyStartupFanoutOnly: boolean;
 };
 
+export type RegisterDriftSnapshot = {
+  capturedAt: number;
+  registerCount: number;
+  apiGeneration: number;
+  postWarmupRegisterCount: number;
+  apiInstanceId: string | null;
+  registryFingerprint: string | null;
+  dominantBucket: string | null;
+  sourceBuckets: Record<string, number>;
+  traceWindowSize: number;
+  traceRecent: Array<Record<string, unknown>>;
+};
+
 export function classifyRegisterTrace(stack: string) {
   if (
     stack.includes('prepareSecretsRuntimeSnapshot') ||
@@ -68,6 +81,72 @@ export function dominantRegisterBucket(sourceBuckets: Record<string, number>) {
   return winner;
 }
 
+export function buildRegisterTraceEntry(args: {
+  ts: number;
+  bridgeId: string;
+  gatewayPid: number;
+  registerCount: number;
+  apiGeneration: number;
+  apiRebound: boolean;
+  apiInstanceId: string | null;
+  registryFingerprint: string | null;
+  source: string | null;
+  pluginVersion: string | null;
+  stack: string;
+}): RegisterTraceEntry {
+  return {
+    ts: args.ts,
+    bridgeId: args.bridgeId,
+    gatewayPid: args.gatewayPid,
+    registerCount: args.registerCount,
+    apiGeneration: args.apiGeneration,
+    apiRebound: args.apiRebound,
+    apiInstanceId: args.apiInstanceId,
+    registryFingerprint: args.registryFingerprint,
+    source: args.source,
+    pluginVersion: args.pluginVersion,
+    stack: args.stack,
+    stackBucket: classifyRegisterTrace(args.stack),
+  };
+}
+
+export function appendBoundedRegisterTrace(
+  traceRecent: RegisterTraceEntry[],
+  trace: RegisterTraceEntry,
+  maxEntries = 12,
+) {
+  traceRecent.push(trace);
+  const cap = Math.max(0, Math.floor(finiteNumberOr(maxEntries, 12)));
+  if (cap === 0) {
+    traceRecent.splice(0, traceRecent.length);
+    return;
+  }
+  if (traceRecent.length > cap) traceRecent.splice(0, traceRecent.length - cap);
+}
+
+export function buildRegisterDriftSnapshot(args: {
+  capturedAt: number;
+  registerCount: number;
+  apiGeneration: number;
+  summary: RegisterTraceSummary;
+  apiInstanceId: string | null;
+  registryFingerprint: string | null;
+  traceRecent: RegisterTraceEntry[];
+}): RegisterDriftSnapshot {
+  return {
+    capturedAt: args.capturedAt,
+    registerCount: args.registerCount,
+    apiGeneration: args.apiGeneration,
+    postWarmupRegisterCount: args.summary.postWarmupRegisterCount,
+    apiInstanceId: args.apiInstanceId,
+    registryFingerprint: args.registryFingerprint,
+    dominantBucket: args.summary.dominantBucket,
+    sourceBuckets: { ...args.summary.sourceBuckets },
+    traceWindowSize: args.traceRecent.length,
+    traceRecent: args.traceRecent.map((trace) => ({ ...trace })),
+  };
+}
+
 export function buildRegisterTraceSummary(args: {
   traceRecent: RegisterTraceEntry[];
   firstRegisterAt: number | null;

package/src/core/targets.ts

@@ -51,8 +51,17 @@ function parseRouteFromStandardDisplayScope(scope: string): BncrRoute | null {
   return null;
 }
 
-export function parseRouteFromDisplayScope(scope: string): BncrRoute | null {
+function normalizeDisplayScopePrefix(scope: string): string {
   const raw = asString(scope).trim();
+  if (!raw) return '';
+  if (raw.startsWith('Bncr:')) return raw;
+  if (/^bncr[:-]/i.test(raw)) return raw;
+  if (!parseRouteFromStandardDisplayScope(raw)) return raw;
+  return `Bncr:${raw}`;
+}
+
+export function parseRouteFromDisplayScope(scope: string): BncrRoute | null {
+  const raw = normalizeDisplayScopePrefix(scope);
   if (!raw) return null;
 
   const payload = raw.match(/^Bncr:(.+)$/)?.[1];

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