@xmoxmo/bncr 0.6.0 → 0.6.1

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

@@ -20,6 +20,7 @@ import {
   buildBncrGroupContextFromEntries,
   collectBncrHistoryMediaFromEntries,
 } from './group-history.ts';
+import type { BncrOutboundReplayEntry } from './outbound-replay-cache.ts';
 import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
 
 function parseSlashCommandName(body: string): string | undefined {
@@ -78,6 +79,7 @@ export function buildBncrInboundTurnContext(args: {
   historyLimit?: number;
   silentHistoryFlush?: boolean;
   pendingHistoryEntries?: readonly BncrHistoryEntry[];
+  outboundReplayEntries?: readonly BncrOutboundReplayEntry[];
 }): BncrInboundContextPayload | Promise<BncrInboundContextPayload> {
   const {
     api,
@@ -98,7 +100,13 @@ export function buildBncrInboundTurnContext(args: {
   const pendingHistoryEntries = Array.isArray(args.pendingHistoryEntries)
     ? args.pendingHistoryEntries
     : [];
+  const outboundReplayEntries = Array.isArray(args.outboundReplayEntries)
+    ? args.outboundReplayEntries
+    : [];
   const silentHistoryFlush = args.silentHistoryFlush === true;
+  const contextEntries = silentHistoryFlush
+    ? pendingHistoryEntries
+    : [...pendingHistoryEntries, ...outboundReplayEntries];
   const flushSenderId = 'bncr-history-system';
   const flushSenderName = 'Bncr History System';
   const flushRawBody =
@@ -123,11 +131,11 @@ export function buildBncrInboundTurnContext(args: {
   const senderIsOwner = parsed.isAdmin === true || Boolean(ownerAllowFrom?.length);
   const senderIsAuthorized = senderIsOwner;
   const inboundHistory = undefined;
-  const pendingHistoryMedia = shouldDispatch
-    ? collectBncrHistoryMediaFromEntries({ entries: pendingHistoryEntries })
+  const contextMedia = shouldDispatch
+    ? collectBncrHistoryMediaFromEntries({ entries: contextEntries })
     : [];
-  const pendingHistoryContext = shouldDispatch
-    ? pendingHistoryEntries.map((entry) => ({
+  const structuredContextEntries = shouldDispatch
+    ? contextEntries.map((entry) => ({
         messageId: entry.messageId,
         sender: entry.sender,
         senderId: entry.senderId,
@@ -155,7 +163,7 @@ export function buildBncrInboundTurnContext(args: {
     bridgeSenderName,
     senderIsOwner,
     senderIsAuthorized,
-    pendingHistoryContext,
+    pendingHistoryContext: structuredContextEntries,
   });
   const promptVisibleContextFacts = buildBncrPromptVisibleContextFacts(structuredContextFacts);
   const supplementalUntrustedContext = [
@@ -177,10 +185,10 @@ export function buildBncrInboundTurnContext(args: {
   const wasMentioned = parsed.isBotMentioned === true || platformWantsReply;
   const isAuthorizedTextCommand = Boolean(ownerAllowFrom?.length);
   const bodyForAgent =
-    shouldDispatch && pendingHistoryEntries.length > 0
+    shouldDispatch && contextEntries.length > 0
       ? buildBncrGroupContextFromEntries({
           api,
-          entries: pendingHistoryEntries,
+          entries: contextEntries,
           channelLabel: resolution.canonicalTo,
           currentTimestamp: Date.now(),
           previousTimestamp: readBncrSessionUpdatedAt(api, {
@@ -199,7 +207,7 @@ export function buildBncrInboundTurnContext(args: {
     kind: item.kind,
     messageId: msgId ?? undefined,
   }));
-  const media = [...pendingHistoryMedia, ...currentTurnMedia];
+  const media = [...contextMedia, ...currentTurnMedia];
 
   return Promise.resolve(
     resolveBncrChannelInboundRuntime(api).buildContext({

package/src/plugin/ack-outbox-runtime-group.ts

@@ -105,6 +105,7 @@ export function createBncrAckOutboxRuntimeGroup(runtime: {
   setOutboxEntry: (messageId: string, entry: OutboxEntry) => void;
   resolveMessageAck: (messageId: string, result: 'acked' | 'timeout') => boolean;
   moveToDeadLetter: (entry: OutboxEntry, reason: string) => void;
+  markRecentOutboundAcked?: (entry: OutboxEntry) => void;
   recordAckTimeoutTelemetry: (accountId: string) => void;
   degradeOutboundCapability: (args: {
     accountId: string;
@@ -154,6 +155,7 @@ export function createBncrAckOutboxRuntimeGroup(runtime: {
       runtime.resolveMessageAck(messageId, result);
     },
     moveToDeadLetter: runtime.moveToDeadLetter,
+    markRecentOutboundAcked: runtime.markRecentOutboundAcked,
     logOutboxAckSummary: outboxAckLogs.logOutboxAckSummary,
   });
 

package/src/plugin/bridge-call.ts

@@ -0,0 +1,168 @@
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrRecentOutboundEntry } from '../core/types.ts';
+import type { BncrStatusRuntimeSnapshot } from './channel-runtime-types.ts';
+
+export const BNCR_LOCAL_BRIDGE_METHODS = [
+  'bncr.methods',
+  'bncr.status.channel',
+  'bncr.status.account',
+  'bncr.status.headline',
+  'bncr.outbound.recent',
+  'bncr.diagnostics',
+  'bncr.deadLetter.inspect',
+  'bncr.deadLetter.prune',
+] as const;
+
+export type BncrBridgeCallDiagnosticsBridge = {
+  diagnostics: (args: Record<string, unknown>) => Promise<Record<string, unknown>>;
+  deadLetterInspect: (args: Record<string, unknown>) => Promise<Record<string, unknown>>;
+  deadLetterPrune: (args: Record<string, unknown>) => Promise<Record<string, unknown>>;
+};
+
+export type BncrBridgeCallBridge = {
+  call: (
+    method: string,
+    args: Record<string, unknown>,
+    accountId?: string,
+  ) => Promise<Record<string, unknown>>;
+};
+
+export type BncrBridgeCallRecentOutboundBridge = {
+  listRecentOutbound: (sessionKey: string) => BncrRecentOutboundEntry[];
+  listRecentOutboundByAccount: (accountId: string) => BncrRecentOutboundEntry[];
+};
+
+/**
+ * Runs a gateway-style handler with a captured respond callback so local
+ * diagnostics/dead-letter handlers can be exposed through the message tool.
+ */
+export async function invokeBncrBridgeGatewayHandler(
+  handler: (ctx: GatewayRequestHandlerOptions) => Promise<void>,
+  args: Record<string, unknown>,
+): Promise<Record<string, unknown>> {
+  let ok = false;
+  let payload: unknown;
+  const ctx = {
+    params: args,
+    respond: (accepted: boolean, value: unknown) => {
+      ok = accepted;
+      payload = value;
+    },
+  } as unknown as GatewayRequestHandlerOptions;
+
+  await handler(ctx);
+
+  if (!ok) {
+    const message =
+      payload &&
+      typeof payload === 'object' &&
+      typeof (payload as { message?: unknown }).message === 'string'
+        ? (payload as { message: string }).message
+        : 'bridge handler rejected request';
+    throw new Error(message);
+  }
+  if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+    throw new Error('bridge handler returned an invalid payload');
+  }
+  return payload as Record<string, unknown>;
+}
+
+/**
+ * Local methods run inside the plugin process; any other method is forwarded
+ * dynamically to the OpenClawClient RPC bridge.
+ */
+export function createBncrBridgeCallBridge(runtime: {
+  defaultAccountId: string;
+  getStatusBridge: () => {
+    getChannelSummary: (
+      defaultAccountId: string,
+    ) => Record<string, unknown> | Promise<Record<string, unknown>>;
+    getAccountRuntimeSnapshot: (accountId?: string) => BncrStatusRuntimeSnapshot;
+    getStatusHeadline: (accountId?: string) => string;
+  };
+  getDiagnosticsBridge: () => BncrBridgeCallDiagnosticsBridge;
+  getRecentOutboundBridge: () => BncrBridgeCallRecentOutboundBridge;
+  callClientRpc: (
+    method: string,
+    args: Record<string, unknown>,
+    accountId: string,
+  ) => Promise<Record<string, unknown>>;
+}): BncrBridgeCallBridge {
+  const resolveAccountId = (args: Record<string, unknown>, accountId?: string) => {
+    const argsAccountId = typeof args.accountId === 'string' ? args.accountId.trim() : '';
+    return accountId || argsAccountId || runtime.defaultAccountId;
+  };
+
+  const localHandlers: Record<
+    string,
+    (args: Record<string, unknown>, accountId: string) => Promise<Record<string, unknown>>
+  > = {
+    'bncr.methods': async (_args, accountId) => {
+      const localMethods = [...BNCR_LOCAL_BRIDGE_METHODS];
+      let clientMethods: string[] = [];
+      let clientError: string | null = null;
+      try {
+        const clientResult = await runtime.callClientRpc('bncr.methods', { accountId }, accountId);
+        const raw = (clientResult as { result?: { methods?: unknown } })?.result?.methods;
+        clientMethods = Array.isArray(raw)
+          ? raw.filter((item): item is string => typeof item === 'string')
+          : [];
+      } catch (error) {
+        clientError = error instanceof Error ? error.message : String(error);
+      }
+      return {
+        methods: [...new Set([...localMethods, ...clientMethods])],
+        ...(clientError ? { clientError } : {}),
+      };
+    },
+    'bncr.status.channel': async (_args, accountId) => ({
+      value: await runtime.getStatusBridge().getChannelSummary(accountId),
+    }),
+    'bncr.status.account': async (_args, accountId) => ({
+      value: runtime.getStatusBridge().getAccountRuntimeSnapshot(accountId),
+    }),
+    'bncr.status.headline': async (_args, accountId) => ({
+      value: runtime.getStatusBridge().getStatusHeadline(accountId),
+    }),
+    'bncr.outbound.recent': async (args, accountId) => {
+      const sessionKey = typeof args.sessionKey === 'string' ? args.sessionKey.trim() : '';
+      const rawLimit = typeof args.limit === 'number' ? args.limit : Number(args.limit);
+      const limit = Number.isFinite(rawLimit) ? Math.max(1, Math.floor(rawLimit)) : undefined;
+      const recentBridge = runtime.getRecentOutboundBridge();
+      const entries = sessionKey
+        ? recentBridge.listRecentOutbound(sessionKey)
+        : recentBridge.listRecentOutboundByAccount(accountId);
+      return {
+        accountId,
+        sessionKey: sessionKey || undefined,
+        limit,
+        total: entries.length,
+        entries: typeof limit === 'number' ? entries.slice(0, limit) : entries,
+        now: Date.now(),
+      };
+    },
+    'bncr.diagnostics': (args) => runtime.getDiagnosticsBridge().diagnostics(args),
+    'bncr.deadLetter.inspect': (args) => runtime.getDiagnosticsBridge().deadLetterInspect(args),
+    'bncr.deadLetter.prune': (args) => runtime.getDiagnosticsBridge().deadLetterPrune(args),
+  };
+
+  return {
+    call: async (method, args, accountId) => {
+      const normalizedMethod = String(method || '').trim();
+      if (!normalizedMethod) {
+        throw new Error('bridge method is required');
+      }
+      const normalizedArgs = args ?? {};
+      const resolvedAccountId = resolveAccountId(normalizedArgs, accountId);
+      const localHandler = localHandlers[normalizedMethod];
+      if (localHandler) {
+        return {
+          ok: true,
+          method: normalizedMethod,
+          result: await localHandler(normalizedArgs, resolvedAccountId),
+        };
+      }
+      return runtime.callClientRpc(normalizedMethod, normalizedArgs, resolvedAccountId);
+    },
+  };
+}

package/src/plugin/bridge-outbox-facade.ts

@@ -6,7 +6,12 @@ import {
   collectDueOutboxEntries,
 } from '../core/outbox-queue.ts';
 import { formatDisplayScope } from '../core/targets.ts';
-import type { OutboxEntry } from '../core/types.ts';
+import type { BncrRecentOutboundEntry, OutboxEntry } from '../core/types.ts';
+import {
+  type BncrOutboundReplayCache,
+  type BncrOutboundReplayEntry,
+  recordBncrOutboundReplay,
+} from '../messaging/inbound/outbound-replay-cache.ts';
 import {
   buildBncrOutboxFailureEntryPatch,
   buildBncrOutboxPushSuccessEntryPatch,
@@ -36,6 +41,9 @@ export function createBncrBridgeOutboxFacade(runtime: {
   lastPrePushGuardSkipReasonByAccount: Map<string, string>;
   deadLetterSinceStartByAccount: Map<string, number>;
   lastOutboundByAccount: Map<string, number>;
+  outboundReplayCache?: BncrOutboundReplayCache;
+  resolveOutboundSender?: (entry: OutboxEntry) => { sender: string; senderId?: string };
+  isOutboundAckRequired?: (accountId: string) => boolean;
   scheduleSave: () => void;
   flushPushQueueBestEffort: (args?: {
     accountId?: string;
@@ -48,6 +56,25 @@ export function createBncrBridgeOutboxFacade(runtime: {
   resolveMessageAck: (messageId: string, result?: 'acked' | 'timeout') => boolean;
   markActivity: (accountId: string, at?: number) => void;
 }) {
+  const recordOutboundMessage = (entry: OutboxEntry, status: 'pushed' | 'acked') => {
+    if (!runtime.outboundReplayCache) return;
+    const senderInfo = runtime.resolveOutboundSender?.(entry) ?? {
+      sender: entry.accountId,
+      senderId: entry.accountId,
+    };
+    recordBncrOutboundReplay({
+      cache: runtime.outboundReplayCache,
+      entry,
+      sender: senderInfo.sender,
+      senderId: senderInfo.senderId,
+      status,
+    });
+  };
+
+  const markRecentOutboundAcked = (entry: OutboxEntry) => {
+    recordOutboundMessage(entry, 'acked');
+  };
+
   const recordOutboxPrePushFailure = (args: {
     entry: OutboxEntry;
     lastError: string;
@@ -120,6 +147,9 @@ export function createBncrBridgeOutboxFacade(runtime: {
     });
     Object.assign(args.entry, nextEntry);
     runtime.outbox.set(nextEntry.messageId, args.entry);
+    if (runtime.isOutboundAckRequired?.(args.entry.accountId) === false) {
+      recordOutboundMessage(args.entry, 'pushed');
+    }
     runtime.lastOutboundByAccount.set(nextEntry.accountId, pushedAt);
     runtime.markActivity(nextEntry.accountId, pushedAt);
     runtime.scheduleSave();
@@ -181,6 +211,41 @@ export function createBncrBridgeOutboxFacade(runtime: {
     return result.duePayloads;
   };
 
+  const buildRecentOutboundEntry = (
+    cacheKey: string,
+    replay: BncrOutboundReplayEntry,
+  ): BncrRecentOutboundEntry => {
+    const keyParts = cacheKey.split(':');
+    const accountId = replay.accountId || keyParts[0] || '';
+    const route = replay.route
+      ? replay.route
+      : keyParts[1] && keyParts[2]
+        ? keyParts[2].startsWith('-')
+          ? { platform: keyParts[1], groupId: keyParts[2], userId: '0' }
+          : { platform: keyParts[1], groupId: '0', userId: keyParts[2] }
+        : { platform: '', groupId: '0', userId: '0' };
+    return {
+      messageId: replay.messageId || '',
+      accountId,
+      sessionKey: replay.sessionKey || '',
+      route,
+      ...(replay.type ? { type: replay.type } : {}),
+      ...(replay.type ? { kind: replay.type } : {}),
+      text: replay.body,
+      ...(replay.mediaUrl ? { mediaUrl: replay.mediaUrl } : {}),
+      createdAt: replay.createdAt ?? replay.timestamp ?? runtime.now(),
+      ...(replay.timestamp ? { lastPushAt: replay.timestamp } : {}),
+      status: replay.status === 'acked' ? 'acked' : 'pushed',
+    };
+  };
+
+  const listReplayEntries = () => {
+    if (!runtime.outboundReplayCache) return [];
+    return Array.from(runtime.outboundReplayCache.entries()).flatMap(([cacheKey, entries]) =>
+      entries.map((entry) => buildRecentOutboundEntry(cacheKey, entry)),
+    );
+  };
+
   return {
     recordOutboxPrePushFailure,
     recordPrePushGuardSkip,
@@ -190,5 +255,18 @@ export function createBncrBridgeOutboxFacade(runtime: {
     enqueueOutbound,
     moveToDeadLetter,
     collectDue,
+    listRecentOutbound: (sessionKey: string) => {
+      const normalized = runtime.asString(sessionKey || '').trim();
+      return listReplayEntries()
+        .filter((entry) => entry.sessionKey === normalized)
+        .sort((a, b) => b.createdAt - a.createdAt);
+    },
+    listRecentOutboundByAccount: (accountId: string) => {
+      const normalized = runtime.normalizeAccountId(accountId);
+      return listReplayEntries()
+        .filter((entry) => entry.accountId === normalized)
+        .sort((a, b) => b.createdAt - a.createdAt);
+    },
+    markRecentOutboundAcked,
   };
 }

package/src/plugin/channel-components.ts

@@ -6,6 +6,7 @@ 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 type { BncrOutboundReplayCache } from '../messaging/inbound/outbound-replay-cache.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';
@@ -211,6 +212,7 @@ export function createBncrInboundHandlersComponent(runtime: {
   defaultPublicAgentId: Parameters<typeof createBncrInboundHandlers>[0]['defaultPublicAgentId'];
   sceneRegistry: Parameters<typeof createBncrInboundHandlers>[0]['sceneRegistry'];
   groupHistories: BncrGroupHistoryMap;
+  outboundReplayCache: BncrOutboundReplayCache;
   prepareInboundAcceptance: Parameters<
     typeof createBncrInboundHandlers
   >[0]['prepareInboundAcceptance'];
@@ -256,6 +258,7 @@ export function createBncrInboundHandlersComponent(runtime: {
     defaultPublicAgentId: runtime.defaultPublicAgentId,
     sceneRegistry: runtime.sceneRegistry,
     groupHistories: runtime.groupHistories,
+    outboundReplayCache: runtime.outboundReplayCache,
     prepareInboundAcceptance: runtime.prepareInboundAcceptance,
     formatDisplayScope,
     logInboundSummary: runtime.logInboundSummary,
@@ -275,6 +278,7 @@ export function createBncrInboundHandlersComponent(runtime: {
       shouldAccumulate,
       sceneRegistry,
       groupHistories,
+      outboundReplayCache,
       defaultAdminAgentId,
       defaultPublicAgentId,
       now,
@@ -290,6 +294,7 @@ export function createBncrInboundHandlersComponent(runtime: {
         shouldAccumulate,
         sceneRegistry,
         groupHistories,
+        outboundReplayCache,
         defaultAdminAgentId,
         defaultPublicAgentId,
         now,

package/src/plugin/channel-plugin-bridge-group.ts

@@ -1,7 +1,13 @@
 import type { ChannelMessageSendResult } from 'openclaw/plugin-sdk/channel-message';
-import type { BncrRoute } from '../core/types.ts';
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrRecentOutboundEntry, BncrRoute } from '../core/types.ts';
 import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
 import type { OutboundReplyTargetPolicy } from '../messaging/outbound/reply-target-policy.ts';
+import {
+  type BncrBridgeCallDiagnosticsBridge,
+  createBncrBridgeCallBridge,
+  invokeBncrBridgeGatewayHandler,
+} from './bridge-call.ts';
 import type {
   BncrChannelConfigRoot,
   BncrChannelSendContext,
@@ -34,6 +40,8 @@ export type BncrChannelPluginBridge = {
   getStatusHeadline: (accountId: string) => string;
   resolveVerifiedTarget: (to: string, accountId: string) => BncrVerifiedTarget;
   rememberSessionRoute: (sessionKey: string, accountId: string, route: BncrRoute) => void;
+  listRecentOutbound: (sessionKey: string) => BncrRecentOutboundEntry[];
+  listRecentOutboundByAccount: (accountId: string) => BncrRecentOutboundEntry[];
   enqueueFromReply: (args: {
     accountId: string;
     sessionKey: string;
@@ -44,6 +52,14 @@ export type BncrChannelPluginBridge = {
   }) => Promise<void>;
   channelStartAccount: (ctx: unknown) => void | Promise<void>;
   channelStopAccount: (ctx: unknown) => void | Promise<void>;
+  handleDiagnostics: (ctx: GatewayRequestHandlerOptions) => Promise<void>;
+  handleDeadLetterInspect: (ctx: GatewayRequestHandlerOptions) => Promise<void>;
+  handleDeadLetterPrune: (ctx: GatewayRequestHandlerOptions) => Promise<void>;
+  callClientRpc: (
+    method: string,
+    args: Record<string, unknown>,
+    accountId: string,
+  ) => Promise<Record<string, unknown>>;
 };
 
 export function createBncrChannelPluginBridgeGroup(runtime: {
@@ -118,6 +134,31 @@ export function createBncrChannelPluginBridgeGroup(runtime: {
     };
   };
 
+  const getDiagnosticsBridge = (): BncrBridgeCallDiagnosticsBridge => {
+    const bridge = runtime.getBridge();
+    return {
+      diagnostics: async (args) => invokeBncrBridgeGatewayHandler(bridge.handleDiagnostics, args),
+      deadLetterInspect: async (args) =>
+        invokeBncrBridgeGatewayHandler(bridge.handleDeadLetterInspect, args),
+      deadLetterPrune: async (args) =>
+        invokeBncrBridgeGatewayHandler(bridge.handleDeadLetterPrune, args),
+    };
+  };
+
+  const getBridgeCallBridge = () => {
+    const bridge = runtime.getBridge();
+    return createBncrBridgeCallBridge({
+      defaultAccountId: runtime.defaultAccountId,
+      getStatusBridge,
+      getDiagnosticsBridge,
+      getRecentOutboundBridge: () => ({
+        listRecentOutbound: (sessionKey) => bridge.listRecentOutbound(sessionKey),
+        listRecentOutboundByAccount: (accountId) => bridge.listRecentOutboundByAccount(accountId),
+      }),
+      callClientRpc: (method, args, accountId) => bridge.callClientRpc(method, args, accountId),
+    });
+  };
+
   return {
     getMessageSendBridge,
     getOutboundBridge,
@@ -125,5 +166,6 @@ export function createBncrChannelPluginBridgeGroup(runtime: {
     getStatusBridge,
     getToolActionBridge,
     getGatewayBridge,
+    getBridgeCallBridge,
   };
 }

package/src/plugin/channel-plugin-surface-group.ts

@@ -1,4 +1,5 @@
 import type { ChannelMessageSendResult } from 'openclaw/plugin-sdk/channel-message';
+import { Type } from 'typebox';
 import { listAccountIds, normalizeAccountId, resolveAccount } from '../core/accounts.ts';
 import { BncrConfigSchema } from '../core/config-schema.ts';
 import { resolveBncrChannelPolicy } from '../core/policy.ts';
@@ -6,9 +7,11 @@ import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
 import type { OutboundReplyTargetPolicy } from '../messaging/outbound/reply-target-policy.ts';
 import type { OpenClawChannelToolSend, openClawJsonResult } from '../openclaw/sdk-helpers.ts';
 import { readOpenClawStringParam } from '../openclaw/sdk-helpers.ts';
+import type { BncrBridgeCallBridge } from './bridge-call.ts';
 import type {
   BncrChannelConfigRoot,
   BncrChannelSendContext,
+  BncrMessageToolSchemaContribution,
   BncrSceneRecord,
   BncrStatusRuntimeSnapshot,
   BncrVerifiedTarget,
@@ -35,6 +38,33 @@ type BncrChannelMeta = {
 
 type PluginSurfaceResult = ReturnType<typeof openClawJsonResult>;
 
+const BNCR_MESSAGE_TOOL_SCHEMA: BncrMessageToolSchemaContribution = {
+  visibility: 'current-channel',
+  properties: {
+    bridgeMethod: Type.Optional(
+      Type.String({
+        description:
+          'Bncr-only bridge method forwarded to the OpenClawClient RPC bridge; use bncr.methods to list calls, or bncr.client.adapters.call to invoke a Bncr adapter method generically.',
+      }),
+    ),
+    extra: Type.Optional(
+      Type.Record(Type.String(), Type.Unknown(), {
+        description: 'Bncr-specific structured params merged into the unified outbound normalizer.',
+      }),
+    ),
+    type: Type.Optional(
+      Type.String({
+        description: 'Explicit outbound type such as text, audio, video, voice, file, or appmsg.',
+      }),
+    ),
+    downloadMedia: Type.Optional(
+      Type.Boolean({
+        description: 'Force URL media to be downloaded before sending.',
+      }),
+    ),
+  },
+};
+
 export function createBncrChannelPluginSurfaceGroup(runtime: {
   channelId: string;
   sceneRegistry: Map<string, BncrSceneRecord>;
@@ -80,6 +110,7 @@ export function createBncrChannelPluginSurfaceGroup(runtime: {
     channelStartAccount: BncrGatewayAccountBridge['channelStartAccount'];
     channelStopAccount: BncrGatewayAccountBridge['channelStopAccount'];
   };
+  getBridgeCallBridge: () => BncrBridgeCallBridge;
   channelMeta: BncrChannelMeta;
   channelCapabilities: {
     chatTypes: Array<'direct' | 'group' | 'thread'>;
@@ -121,11 +152,12 @@ export function createBncrChannelPluginSurfaceGroup(runtime: {
       }
 
       return {
-        actions: ['send'] as const,
+        actions: ['send', 'delete', 'unsend'] as const,
         capabilities: [] as const,
+        schema: BNCR_MESSAGE_TOOL_SCHEMA,
       };
     },
-    supportsAction: ({ action }) => action === 'send',
+    supportsAction: ({ action }) => action === 'send' || action === 'delete' || action === 'unsend',
     extractToolSend: ({ args }) =>
       runtime.extractToolSend(
         (args && typeof args === 'object' ? (args as Record<string, unknown>) : {}) as Record<
@@ -135,19 +167,62 @@ export function createBncrChannelPluginSurfaceGroup(runtime: {
         'sendMessage',
       ) || null,
     handleAction: async ({ action, params, accountId, mediaLocalRoots }) => {
-      if (action !== 'send') {
-        throw new Error(`Action ${action} is not supported for provider ${runtime.channelId}.`);
-      }
-
       /* -- extract raw params (no normalization) ----------------------- */
       const paramsObj = (params && typeof params === 'object' ? params : {}) as Record<
         string,
         unknown
       >;
-      const to = readOpenClawStringParam(paramsObj, 'to', { required: true });
       const resolvedAccountId = normalizeAccountId(
         (readOpenClawStringParam(paramsObj, 'accountId') ?? accountId) || '',
       );
+      if (action === 'delete' || action === 'unsend') {
+        const to = readOpenClawStringParam(paramsObj, 'to', { required: true });
+        const messageId =
+          (typeof paramsObj.messageId === 'number'
+            ? String(paramsObj.messageId)
+            : readOpenClawStringParam(paramsObj, 'messageId')) ||
+          readOpenClawStringParam(paramsObj, 'message_id');
+        if (!messageId) {
+          throw new Error(`${action} requires messageId`);
+        }
+
+        const verified = runtime.getToolActionBridge().resolveVerifiedTarget(to, resolvedAccountId);
+        const bridgeResult = await runtime.getBridgeCallBridge().call(
+          'bncr.client.adapters.call',
+          {
+            msgInfo: {
+              groupId: verified.route.groupId || '0',
+              userId: verified.route.userId || '0',
+            },
+            from: verified.route.platform,
+            method: 'delMsg',
+            messageId,
+          },
+          resolvedAccountId,
+        );
+        return runtime.openClawJsonResult({ ok: true, ...bridgeResult });
+      }
+
+      if (action !== 'send') {
+        throw new Error(`Action ${action} is not supported for provider ${runtime.channelId}.`);
+      }
+
+      const bridgeMethod =
+        typeof paramsObj.bridgeMethod === 'string' ? paramsObj.bridgeMethod.trim() : '';
+      if (bridgeMethod) {
+        const rawExtra = paramsObj.extra;
+        const bridgeArgs =
+          rawExtra && typeof rawExtra === 'object' && !Array.isArray(rawExtra)
+            ? { ...(rawExtra as Record<string, unknown>) }
+            : {};
+        if (!('accountId' in bridgeArgs)) {
+          bridgeArgs.accountId = resolvedAccountId || undefined;
+        }
+        const bridgeResult = await runtime.getBridgeCallBridge().call(bridgeMethod, bridgeArgs);
+        return runtime.openClawJsonResult(bridgeResult);
+      }
+
+      const to = readOpenClawStringParam(paramsObj, 'to', { required: true });
       const toolMediaUrl =
         (typeof paramsObj.mediaUrl === 'string' ? paramsObj.mediaUrl : '') ||
         (typeof paramsObj.media === 'string' ? paramsObj.media : '') ||

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

@@ -1,6 +1,7 @@
 import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
 import type { BncrRoute, OutboxEntry } from '../core/types.ts';
 import type { BncrGroupHistoryMap } from '../messaging/inbound/group-history.ts';
+import type { BncrOutboundReplayCache } from '../messaging/inbound/outbound-replay-cache.ts';
 import type { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
 import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
 import type { OutboundReplyTargetPolicy } from '../messaging/outbound/reply-target-policy.ts';
@@ -107,6 +108,7 @@ export function buildBncrInboundSurfaceRuntime(deps: {
   defaultPublicAgentId: () => string;
   sceneRegistry: Map<string, BncrSceneRecord>;
   groupHistories: BncrGroupHistoryMap;
+  outboundReplayCache: BncrOutboundReplayCache;
   prepareInboundAcceptance: (args: {
     parsed: ReturnType<typeof parseBncrInboundParams>;
     canonicalAgentId: string;