@xmoxmo/bncr 0.3.3 → 0.3.5

package/src/messaging/inbound/dispatch.ts

@@ -6,30 +6,29 @@ import {
   normalizeInboundSessionKey,
   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';
+  readBncrSessionUpdatedAt,
+  recordBncrInboundSession,
+  resolveBncrInboundSessionStorePath,
+  resolveBncrPinnedMainDmOwnerFromAllowlist,
+} from '../../openclaw/inbound-session-runtime.ts';
 import { saveOpenClawChannelMediaBuffer } from '../../openclaw/media-runtime.ts';
 import {
   dispatchOpenClawReplyWithBufferedBlockDispatcher,
   formatOpenClawAgentEnvelope,
   resolveOpenClawEnvelopeFormatOptions,
 } from '../../openclaw/reply-runtime.ts';
+import { resolveOpenClawAgentRoute } from '../../openclaw/routing-runtime.ts';
+import type { OutboundReplyTargetPolicy } from '../outbound/reply-target-policy.ts';
+import { handleBncrNativeCommand } from './commands.ts';
 import {
-  resolveOpenClawAgentRoute,
-  resolveOpenClawInboundLastRouteSessionKey,
-} from '../../openclaw/routing-runtime.ts';
-import {
-  readBncrSessionUpdatedAt,
-  recordBncrInboundSession,
-  resolveBncrInboundSessionStorePath,
-  resolveBncrPinnedMainDmOwnerFromAllowlist,
-} from '../../openclaw/inbound-session-runtime.ts';
+  buildBncrPromptVisibleContextFacts,
+  buildBncrStructuredContextFactsFromInboundParts,
+} from './context-facts.ts';
+import { buildBncrInboundRecordUpdateLastRoute } from './last-route.ts';
+import { buildBncrReplyConfig } from './reply-config.ts';
+import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
+import { wrapBncrInboundRecordSessionLabelCorrection } from './session-label.ts';
 
 type ParsedInbound = ReturnType<typeof import('./parse.ts')['parseBncrInboundParams']>;
 
@@ -68,10 +67,7 @@ export function estimateBase64DecodedBytes(value: string): number {
   return Math.max(0, Math.floor((normalized.length * 3) / 4) - padding);
 }
 
-export function assertInboundMediaBase64Size(
-  value: string,
-  maxBytes = INBOUND_MEDIA_MAX_BYTES,
-) {
+export function assertInboundMediaBase64Size(value: string, maxBytes = INBOUND_MEDIA_MAX_BYTES) {
   const estimatedBytes = estimateBase64DecodedBytes(value);
   if (estimatedBytes > maxBytes) {
     throw new Error(
@@ -161,7 +157,8 @@ async function prepareBncrInboundSessionContext(args: {
     groupId,
     userId,
   } = parsed;
-  const { accountId, route, resolvedRoute, baseSessionKey, taskSessionKey, dispatchSessionKey } = resolution;
+  const { accountId, route, resolvedRoute, baseSessionKey, taskSessionKey, dispatchSessionKey } =
+    resolution;
 
   rememberSessionRoute(baseSessionKey, accountId, route);
   if (taskSessionKey && taskSessionKey !== baseSessionKey) {
@@ -332,36 +329,6 @@ function buildBncrInboundTurnContext(args: {
   });
 }
 
-function buildBncrInboundRecordUpdateLastRoute(args: {
-  channelId: string;
-  peer: ParsedInbound['peer'];
-  senderIdForContext: string;
-  resolution: BncrInboundConversationResolution;
-  pinnedMainDmOwner: string | null;
-}) {
-  const { channelId, peer, senderIdForContext, resolution, pinnedMainDmOwner } = args;
-  if (peer.kind !== 'direct') return undefined;
-
-  const sessionKey = resolveOpenClawInboundLastRouteSessionKey({
-    route: resolution.resolvedRoute,
-    sessionKey: resolution.dispatchSessionKey,
-  });
-
-  return {
-    sessionKey,
-    channel: channelId,
-    to: resolution.canonicalTo,
-    accountId: resolution.accountId,
-    mainDmOwnerPin:
-      sessionKey === resolution.resolvedRoute.mainSessionKey && pinnedMainDmOwner
-        ? {
-            ownerRecipient: pinnedMainDmOwner,
-            senderRecipient: senderIdForContext,
-          }
-        : undefined,
-  };
-}
-
 function buildBncrInboundReplyRouteFact(
   resolution: BncrInboundConversationResolution,
 ): BncrInboundReplyRouteFact {
@@ -388,6 +355,7 @@ export async function dispatchBncrInbound(params: {
     route: any;
     payload: { text?: string; mediaUrl?: string; mediaUrls?: string[] };
     mediaLocalRoots?: readonly string[];
+    replyTargetPolicy?: OutboundReplyTargetPolicy;
   }) => Promise<void>;
   setInboundActivity: (accountId: string, at: number) => void;
   scheduleSave: () => void;
@@ -444,7 +412,7 @@ export async function dispatchBncrInbound(params: {
     resolution,
     rememberSessionRoute,
   });
-  const { storePath, mediaPath, rawBody, body } = prepared;
+  const { storePath, mediaPath, rawBody } = prepared;
   const replyRouteFact = buildBncrInboundReplyRouteFact(resolution);
   if (!clientId) {
     emitBncrLogLine(
@@ -480,9 +448,12 @@ export async function dispatchBncrInbound(params: {
       : null;
   const updateLastRoute = buildBncrInboundRecordUpdateLastRoute({
     channelId,
-    peer,
+    peerKind: peer.kind,
     senderIdForContext,
-    resolution,
+    accountId: resolution.accountId,
+    to: resolution.canonicalTo,
+    resolvedRoute: resolution.resolvedRoute,
+    sessionKey: resolution.dispatchSessionKey,
     pinnedMainDmOwner,
   });
 

package/src/messaging/inbound/last-route.ts

@@ -0,0 +1,46 @@
+import { resolveOpenClawInboundLastRouteSessionKey } from '../../openclaw/routing-runtime.ts';
+
+export function buildBncrInboundRecordUpdateLastRoute(args: {
+  channelId: string;
+  peerKind: 'direct' | 'group';
+  senderIdForContext: string;
+  accountId: string;
+  to: string;
+  resolvedRoute: {
+    sessionKey: string;
+    mainSessionKey?: string;
+  };
+  sessionKey: string;
+  pinnedMainDmOwner: string | null;
+}) {
+  const {
+    channelId,
+    peerKind,
+    senderIdForContext,
+    accountId,
+    to,
+    resolvedRoute,
+    sessionKey,
+    pinnedMainDmOwner,
+  } = args;
+  if (peerKind !== 'direct') return undefined;
+
+  const inboundLastRouteSessionKey = resolveOpenClawInboundLastRouteSessionKey({
+    route: resolvedRoute,
+    sessionKey,
+  });
+
+  return {
+    sessionKey: inboundLastRouteSessionKey,
+    channel: channelId,
+    to,
+    accountId,
+    mainDmOwnerPin:
+      inboundLastRouteSessionKey === resolvedRoute.mainSessionKey && pinnedMainDmOwner
+        ? {
+            ownerRecipient: pinnedMainDmOwner,
+            senderRecipient: senderIdForContext,
+          }
+        : undefined,
+  };
+}

package/src/messaging/inbound/native-command.ts

@@ -0,0 +1,49 @@
+export type NativeCommand = {
+  command: string;
+  raw: string;
+  body: string;
+};
+
+export type NativeVerboseCommand = {
+  handled: true;
+  verboseLevel?: 'on' | 'off' | 'full';
+  text: string;
+};
+
+export function parseBncrNativeCommand(text: string): NativeCommand | null {
+  const raw = String(text || '').trim();
+  if (!raw.startsWith('/')) return null;
+  const match = raw.match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/i);
+  if (!match) return null;
+
+  const command = String(match[1] || '')
+    .trim()
+    .toLowerCase();
+  if (!command) return null;
+
+  const rest = String(match[2] || '').trim();
+  const body = command === 'help' ? ['/commands', rest].filter(Boolean).join(' ') : raw;
+  return { command, raw, body };
+}
+
+export 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.`,
+  };
+}

package/src/messaging/inbound/native-reply-delivery.ts

@@ -0,0 +1,43 @@
+type BncrNativeReplyKind = 'tool' | 'block' | 'final';
+
+export type BncrNativeReplyDeliveryPayload = {
+  text?: string;
+  mediaUrl?: string;
+  mediaUrls?: string[];
+  audioAsVoice?: boolean;
+  replyToId?: string;
+};
+
+export function buildBncrNativeReplyDeliveryPayload(args: {
+  payload?: {
+    text?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    audioAsVoice?: boolean;
+  };
+  kind?: BncrNativeReplyKind;
+  effectiveReply: {
+    blockStreaming: boolean;
+    allowTool: boolean;
+  };
+  msgId?: string;
+}): BncrNativeReplyDeliveryPayload | null {
+  const { payload, kind, effectiveReply, msgId } = args;
+  const shouldForwardTool = effectiveReply.blockStreaming && effectiveReply.allowTool;
+
+  if (kind === 'tool' && !shouldForwardTool) {
+    return null;
+  }
+
+  const hasPayload = Boolean(
+    payload?.text ||
+      payload?.mediaUrl ||
+      (Array.isArray(payload?.mediaUrls) && payload.mediaUrls.length > 0),
+  );
+  if (!hasPayload) return null;
+
+  return {
+    ...payload,
+    replyToId: msgId || undefined,
+  };
+}

package/src/messaging/inbound/parse.ts

@@ -49,9 +49,9 @@ export function parseBncrInboundParams(params: any) {
   const groupId = asString(params?.groupId || '0').trim() || '0';
   const userId = asString(params?.userId || '').trim();
   const sessionKeyfromroute = asString(params?.sessionKey || '').trim();
-  const providedOriginatingTo = asString(
-    params?.originatingTo || params?.providedOriginatingTo || params?.to || '',
-  ).trim() || undefined;
+  const providedOriginatingTo =
+    asString(params?.originatingTo || params?.providedOriginatingTo || params?.to || '').trim() ||
+    undefined;
   const clientId = asString(params?.clientId || '').trim() || undefined;
 
   const route: BncrRoute = {

package/src/messaging/inbound/runtime-compat.ts

@@ -20,8 +20,14 @@ export function resolveBncrChannelInboundRuntime(api: any): ChannelRuntimeCompat
   if (legacyTurnRuntime?.buildContext && legacyTurnRuntime?.run) {
     if (!warnedLegacyTurnRuntime) {
       warnedLegacyTurnRuntime = true;
-      const channelRuntimeKeys = Object.keys(channelRuntime ?? {}).sort().join(',') || 'none';
-      const inboundRuntimeKeys = Object.keys(inboundRuntime ?? {}).sort().join(',') || 'none';
+      const channelRuntimeKeys =
+        Object.keys(channelRuntime ?? {})
+          .sort()
+          .join(',') || 'none';
+      const inboundRuntimeKeys =
+        Object.keys(inboundRuntime ?? {})
+          .sort()
+          .join(',') || 'none';
       emitBncrLogLine(
         'warn',
         `[bncr] inbound runtime fallback=turn|preferred=inbound|channelKeys=${channelRuntimeKeys}|inboundKeys=${inboundRuntimeKeys}`,

package/src/messaging/outbound/build-send-action.ts

@@ -56,8 +56,7 @@ export function buildBncrMessageAction(input: MinimalBncrSendInput): BuiltBncrMe
 
   const channel = asString(input.channel || 'bncr').trim() || 'bncr';
   const action = asString(input.action || 'send').trim() || 'send';
-  const idempotencyKey =
-    asString(input.idempotencyKey || '').trim() || `bncr-${randomUUID()}`;
+  const idempotencyKey = asString(input.idempotencyKey || '').trim() || `bncr-${randomUUID()}`;
   const accountId =
     asString(pickFirstString(paramsObj.accountId, input.accountId) || '').trim() || undefined;
 

package/src/messaging/outbound/diagnostics.ts

@@ -1,7 +1,226 @@
-import type { BncrConnection } from '../../core/types.ts';
+import type { BncrConnection, OutboxEntry } from '../../core/types.ts';
 import { OUTBOUND_TERMINAL_REASON, type OutboundScheduleSource } from './reasons.ts';
 import type { RetryRerouteDecision } from './retry-policy.ts';
 
+type OutboxIncidentSummaryInput = {
+  pending: number;
+  oldestPendingAt?: number | null;
+  lastAttemptAt?: number | null;
+  lastPushAt?: number | null;
+  lastPushError?: string | null;
+  hasGatewayContext: boolean;
+  activeOutboundConnection: boolean;
+  activeOutboundConnectionCount: number;
+  prePushGuardSkipCount?: number;
+  lastPrePushGuardSkipAt?: number | null;
+  lastPrePushGuardSkipReason?: string | null;
+  lastAckQueueLatencyMs?: number | null;
+  lastAckPushLatencyMs?: number | null;
+  lastLateAckQueueLatencyMs?: number | null;
+  lastLateAckPushLatencyMs?: number | null;
+  lastLateAckOkAt?: number | null;
+  adaptiveAckTimeoutMs?: number | null;
+  adaptiveAckTimeoutReason?: string | null;
+  nowMs?: number;
+};
+
+function finiteNumberOrNull(value: unknown): number | null {
+  if (value == null) return null;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function positiveAgeMs(nowMs: number, at: unknown): number | null {
+  const n = finiteNumberOrNull(at);
+  if (n === null || n < 0) return null;
+  return Math.max(0, nowMs - n);
+}
+
+export function buildOutboxIncidentSummary(input: OutboxIncidentSummaryInput) {
+  const pending = Math.max(0, Math.floor(finiteNumberOrNull(input.pending) || 0));
+  const nowMs = finiteNumberOrNull(input.nowMs) || Date.now();
+  const lastPushError =
+    typeof input.lastPushError === 'string' && input.lastPushError ? input.lastPushError : null;
+  const lastPrePushGuardSkipReason =
+    typeof input.lastPrePushGuardSkipReason === 'string' && input.lastPrePushGuardSkipReason
+      ? input.lastPrePushGuardSkipReason
+      : null;
+  const oldestPendingAgeMs = positiveAgeMs(nowMs, input.oldestPendingAt);
+  const lastLateAckAgeMs = positiveAgeMs(nowMs, input.lastLateAckOkAt);
+  const adaptiveAckTimeoutReason =
+    typeof input.adaptiveAckTimeoutReason === 'string' && input.adaptiveAckTimeoutReason
+      ? input.adaptiveAckTimeoutReason
+      : null;
+  const hasRecentLateAck = lastLateAckAgeMs !== null && lastLateAckAgeMs <= 3_600_000;
+  const hasActiveAdaptiveAck =
+    adaptiveAckTimeoutReason !== null &&
+    ![
+      'no-timeout-evidence',
+      'no-late-ack-evidence',
+      'missing-latency',
+      'late-ack-expired',
+      'recovered',
+    ].includes(adaptiveAckTimeoutReason);
+
+  let type = 'none';
+  let severity: 'ok' | 'warning' | 'critical' = 'ok';
+  let recommendedAction = 'none';
+
+  if (pending > 0 && !input.hasGatewayContext) {
+    type = 'no-gateway-context';
+    severity = 'critical';
+    recommendedAction = 'check-channel-message-runtime-context';
+  } else if (pending > 0 && !input.activeOutboundConnection) {
+    type = 'no-active-outbound-connection';
+    severity = 'critical';
+    recommendedAction = 'reconnect-bncr-client';
+  } else if (pending > 0 && lastPrePushGuardSkipReason) {
+    type = lastPrePushGuardSkipReason;
+    severity = 'warning';
+    recommendedAction = 'inspect-pre-push-guard';
+  } else if (pending > 0 && lastPushError) {
+    type =
+      lastPushError.includes('ack') || lastPushError.includes('timeout')
+        ? 'ack-timeout'
+        : lastPushError;
+    severity = type === 'ack-timeout' ? 'critical' : 'warning';
+    recommendedAction = 'inspect-ack-and-route-state';
+  } else if (pending > 0 && oldestPendingAgeMs !== null && oldestPendingAgeMs >= 120_000) {
+    type = 'outbox-backlog';
+    severity = 'warning';
+    recommendedAction = 'inspect-outbox-drain';
+  } else if (pending > 0) {
+    type = 'pending-outbox';
+    severity = 'warning';
+    recommendedAction = 'inspect-outbox-drain';
+  } else if (hasRecentLateAck || hasActiveAdaptiveAck) {
+    type = 'slow-or-late-ack';
+    severity = 'warning';
+    recommendedAction = 'inspect-ack-latency';
+  }
+
+  return {
+    active: type !== 'none',
+    type,
+    severity,
+    recommendedAction,
+    pending,
+    oldestPendingAgeMs,
+    lastAttemptAgeMs: positiveAgeMs(nowMs, input.lastAttemptAt),
+    lastPushAgeMs: positiveAgeMs(nowMs, input.lastPushAt),
+    lastPushError,
+    hasGatewayContext: input.hasGatewayContext,
+    activeOutboundConnection: input.activeOutboundConnection,
+    activeOutboundConnectionCount: Math.max(
+      0,
+      Math.floor(finiteNumberOrNull(input.activeOutboundConnectionCount) || 0),
+    ),
+    prePushGuardSkipCount: Math.max(
+      0,
+      Math.floor(finiteNumberOrNull(input.prePushGuardSkipCount) || 0),
+    ),
+    lastPrePushGuardSkipAgeMs: positiveAgeMs(nowMs, input.lastPrePushGuardSkipAt),
+    lastPrePushGuardSkipReason,
+    ack: {
+      lastQueueLatencyMs: finiteNumberOrNull(input.lastAckQueueLatencyMs),
+      lastPushLatencyMs: finiteNumberOrNull(input.lastAckPushLatencyMs),
+      lastLateQueueLatencyMs: finiteNumberOrNull(input.lastLateAckQueueLatencyMs),
+      lastLatePushLatencyMs: finiteNumberOrNull(input.lastLateAckPushLatencyMs),
+      lastLateAckAgeMs,
+      adaptiveTimeoutMs: finiteNumberOrNull(input.adaptiveAckTimeoutMs),
+      adaptiveTimeoutReason: adaptiveAckTimeoutReason,
+    },
+  };
+}
+
+export function buildExtendedOutboundDiagnostics(input: {
+  outbox: Record<string, any>;
+  enqueueCount: number;
+  lastEnqueueAt?: number | null;
+  prePushGuardSkipCount: number;
+  lastPrePushGuardSkipAt?: number | null;
+  lastPrePushGuardSkipReason?: string | null;
+  hasGatewayContext: boolean;
+  lastGatewayContextAt?: number | null;
+  ackObservability: Record<string, any>;
+  nowMs?: number;
+}) {
+  const lastEnqueueAt = finiteNumberOrNull(input.lastEnqueueAt);
+  const lastPrePushGuardSkipAt = finiteNumberOrNull(input.lastPrePushGuardSkipAt);
+  const lastGatewayContextAt = finiteNumberOrNull(input.lastGatewayContextAt);
+  return {
+    ...input.outbox,
+    enqueueCount: input.enqueueCount,
+    lastEnqueueAt,
+    prePushGuardSkipCount: input.prePushGuardSkipCount,
+    lastPrePushGuardSkipAt,
+    lastPrePushGuardSkipReason: input.lastPrePushGuardSkipReason || null,
+    hasGatewayContext: input.hasGatewayContext,
+    lastGatewayContextAt,
+    incident: buildOutboxIncidentSummary({
+      ...input.outbox,
+      hasGatewayContext: input.hasGatewayContext,
+      prePushGuardSkipCount: input.prePushGuardSkipCount,
+      lastPrePushGuardSkipAt,
+      lastPrePushGuardSkipReason: input.lastPrePushGuardSkipReason || null,
+      lastAckQueueLatencyMs: input.ackObservability.lastAckQueueLatencyMs,
+      lastAckPushLatencyMs: input.ackObservability.lastAckPushLatencyMs,
+      lastLateAckQueueLatencyMs: input.ackObservability.lastLateAckQueueLatencyMs,
+      lastLateAckPushLatencyMs: input.ackObservability.lastLateAckPushLatencyMs,
+      lastLateAckOkAt: input.ackObservability.lastLateAckOkAt,
+      adaptiveAckTimeoutMs: input.ackObservability.currentAckTimeoutMs,
+      adaptiveAckTimeoutReason: input.ackObservability.recommendedAckTimeoutReason,
+      nowMs: input.nowMs,
+    }),
+  };
+}
+
+export function buildOutboxQueueDiagnostics(args: {
+  accountId: string;
+  outboxEntries: Iterable<OutboxEntry>;
+  pendingAllAccounts: number;
+  pushConnIds: Iterable<string>;
+}) {
+  const accountEntries = Array.from(args.outboxEntries).filter(
+    (entry) => entry.accountId === args.accountId,
+  );
+  let oldestPendingAt: number | null = null;
+  let newestPendingAt: number | null = null;
+  let lastAttemptAt: number | null = null;
+  let lastPushAt: number | null = null;
+  let lastError: string | null = null;
+
+  for (const entry of accountEntries) {
+    const createdAt = Number(entry.createdAt);
+    if (Number.isFinite(createdAt)) {
+      oldestPendingAt = oldestPendingAt === null ? createdAt : Math.min(oldestPendingAt, createdAt);
+      newestPendingAt = newestPendingAt === null ? createdAt : Math.max(newestPendingAt, createdAt);
+    }
+    const attemptAt = Number(entry.lastAttemptAt);
+    if (Number.isFinite(attemptAt) && (lastAttemptAt === null || attemptAt > lastAttemptAt)) {
+      lastAttemptAt = attemptAt;
+    }
+    const pushAt = Number(entry.lastPushAt);
+    if (Number.isFinite(pushAt) && (lastPushAt === null || pushAt > lastPushAt)) {
+      lastPushAt = pushAt;
+      lastError = entry.lastError || null;
+    }
+  }
+
+  const pushConnIds = Array.from(args.pushConnIds);
+  return {
+    pending: accountEntries.length,
+    pendingAllAccounts: args.pendingAllAccounts,
+    oldestPendingAt,
+    newestPendingAt,
+    lastAttemptAt,
+    lastPushAt,
+    lastPushError: lastError,
+    activeOutboundConnection: pushConnIds.length > 0,
+    activeOutboundConnectionCount: pushConnIds.length,
+  };
+}
+
 export function buildOutboxScheduleDebugInfo(args: {
   bridgeId: string;
   accountId?: string | null;
@@ -187,7 +406,7 @@ export function buildOutboxDrainStuckDebugInfo(args: {
     outboxSize: args.outboxSize,
     pending: args.pending,
     runningMs: args.runningMs,
-    runningSince: args.runningSince || null,
+    runningSince: args.runningSince ?? null,
     hasGatewayContext: args.hasGatewayContext,
     activeConnectionCount: args.activeConnectionCount,
     waiters: {

package/src/messaging/outbound/durable-message-adapter.ts

@@ -1,4 +1,3 @@
-import { defineChannelMessageAdapter } from 'openclaw/plugin-sdk/channel-message';
 import type {
   ChannelMessageAdapterShape,
   ChannelMessageSendMediaContext,
@@ -6,15 +5,23 @@ import type {
   ChannelMessageSendResult,
   ChannelMessageSendTextContext,
 } from 'openclaw/plugin-sdk/channel-message';
+import { defineChannelMessageAdapter } from 'openclaw/plugin-sdk/channel-message';
 
-import { buildFileTransferOutboxEntry, buildTextOutboxEntry } from '../../core/outbox-entry-builders.ts';
+import {
+  buildFileTransferOutboxEntry,
+  buildTextOutboxEntry,
+} from '../../core/outbox-entry-builders.ts';
 import type { BncrRoute, OutboxEntry } from '../../core/types.ts';
 import { buildBncrDurableQueuedResult } from './durable-queue-adapter.ts';
 
 export type BncrDurableMessageQueuedAdapterDeps<TConfig = unknown> = {
   enqueueText: (ctx: ChannelMessageSendTextContext<TConfig>) => Promise<OutboxEntry> | OutboxEntry;
-  enqueueMedia?: (ctx: ChannelMessageSendMediaContext<TConfig>) => Promise<OutboxEntry> | OutboxEntry;
-  enqueuePayload?: (ctx: ChannelMessageSendPayloadContext<TConfig>) => Promise<OutboxEntry> | OutboxEntry;
+  enqueueMedia?: (
+    ctx: ChannelMessageSendMediaContext<TConfig>,
+  ) => Promise<OutboxEntry> | OutboxEntry;
+  enqueuePayload?: (
+    ctx: ChannelMessageSendPayloadContext<TConfig>,
+  ) => Promise<OutboxEntry> | OutboxEntry;
   now?: () => number;
 };
 
@@ -97,7 +104,10 @@ export function createBncrDurableMessageQueuedAdapterFromBuilders<TConfig = unkn
   });
 }
 
-function toChannelMessageSendResult(entry: OutboxEntry | undefined, now?: () => number): ChannelMessageSendResult {
+function toChannelMessageSendResult(
+  entry: OutboxEntry | undefined,
+  now?: () => number,
+): ChannelMessageSendResult {
   if (!entry) throw new Error('bncr durable message adapter did not receive an outbox entry');
   const queued = buildBncrDurableQueuedResult({ entry, sentAt: now?.() });
   return {

package/src/messaging/outbound/durable-queue-adapter.ts

@@ -74,7 +74,9 @@ export function buildBncrDurableQueuedResult(args: {
 }): BncrDurableQueuedResult {
   const sentAt = Number.isFinite(args.sentAt) ? Number(args.sentAt) : args.entry.createdAt;
   const platformMessageId = args.entry.messageId;
-  const replyToId = normalizeOutboundReplyToId({ replyToId: args.replyToId ?? extractReplyToId(args.entry) }) || undefined;
+  const replyToId =
+    normalizeOutboundReplyToId({ replyToId: args.replyToId ?? extractReplyToId(args.entry) }) ||
+    undefined;
   const chatId = formatQueuedReceiptChatId(args.entry.route);
   const meta: BncrDurableQueuedReceiptMeta = {
     status: 'accepted',

package/src/messaging/outbound/media.ts

@@ -66,7 +66,8 @@ export function buildBncrMediaOutboundFrame(params: {
     messageId: params.messageId,
     idempotencyKey: params.messageId,
     sessionKey: params.sessionKey,
-    replyToId: normalizeOutboundReplyToId({ kind: params.kind, replyToId: params.replyToId }) || undefined,
+    replyToId:
+      normalizeOutboundReplyToId({ kind: params.kind, replyToId: params.replyToId }) || undefined,
     message: {
       platform: params.route.platform,
       groupId: params.route.groupId,

package/src/messaging/outbound/queue-selectors.ts

@@ -34,7 +34,10 @@ export function computeOutboxRetryWait(nextAttemptAt: number, nowMs: number): nu
   return Math.max(0, finiteNumberOr(nextAttemptAt, 0) - finiteNumberOr(nowMs, 0));
 }
 
-export function updateMinOutboxDelay(currentDelay: number | null, candidateDelay: number | null): number | null {
+export function updateMinOutboxDelay(
+  currentDelay: number | null,
+  candidateDelay: number | null,
+): number | null {
   if (candidateDelay == null) return currentDelay;
   return currentDelay == null ? candidateDelay : Math.min(currentDelay, candidateDelay);
 }
@@ -51,7 +54,9 @@ export function selectOutboxTargetAccounts(args: {
   const filterAcc = args.accountId ? args.normalizeAccountId(args.accountId) : null;
   if (filterAcc) return [filterAcc];
   return Array.from(
-    new Set(Array.from(args.outboxEntries).map((entry) => args.normalizeAccountId(entry.accountId))),
+    new Set(
+      Array.from(args.outboxEntries).map((entry) => args.normalizeAccountId(entry.accountId)),
+    ),
   );
 }
 
@@ -112,7 +117,11 @@ export function selectOutboxFileTransferRouteCandidates(args: {
   );
   const ownerConnId =
     args.ownerConnId && !attemptedConnIds.has(args.ownerConnId) ? args.ownerConnId : undefined;
-  let connIds = ownerConnId ? [ownerConnId] : filteredCandidates.length > 0 ? filteredCandidates : routeCandidates;
+  let connIds = ownerConnId
+    ? [ownerConnId]
+    : filteredCandidates.length > 0
+      ? filteredCandidates
+      : routeCandidates;
   let routeReason: OutboxFileTransferRouteSelection['routeReason'] = ownerConnId
     ? 'owner'
     : connIds.length > 0
@@ -128,7 +137,8 @@ export function selectOutboxFileTransferRouteCandidates(args: {
     const filteredRecentInboundConnIds = recentInboundConnIds.filter(
       (connId) => !attemptedConnIds.has(connId),
     );
-    connIds = filteredRecentInboundConnIds.length > 0 ? filteredRecentInboundConnIds : recentInboundConnIds;
+    connIds =
+      filteredRecentInboundConnIds.length > 0 ? filteredRecentInboundConnIds : recentInboundConnIds;
     routeReason = connIds.length > 0 ? 'recent-inbound-fallback' : 'none';
   }
 
@@ -154,9 +164,12 @@ export function selectOutboxRouteCandidates(args: {
   const revalidatedCandidates = routeCandidates.filter(
     (connId) => attemptedConnIds.has(connId) && args.isRevalidatedAttemptedConn(connId),
   );
-  const preferredCandidates = unattemptedCandidates.length > 0 ? unattemptedCandidates : routeCandidates;
+  const preferredCandidates =
+    unattemptedCandidates.length > 0 ? unattemptedCandidates : routeCandidates;
   const ownerConnId =
-    args.ownerConnId && preferredCandidates.includes(args.ownerConnId) ? args.ownerConnId : undefined;
+    args.ownerConnId && preferredCandidates.includes(args.ownerConnId)
+      ? args.ownerConnId
+      : undefined;
   let connIds = ownerConnId ? [ownerConnId] : preferredCandidates;
   let routeReason: OutboxRouteSelection['routeReason'] = ownerConnId
     ? 'owner'