@xmoxmo/bncr 0.6.0 → 0.6.2

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,13 @@ 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 { BncrConversationHistoryMap } from '../messaging/inbound/conversation-history.ts';
+import {
+  type BncrOutboundReplayCache,
+  type BncrOutboundReplayEntry,
+  recordBncrOutboundReplay,
+} from '../messaging/inbound/outbound-replay-cache.ts';
 import {
   buildBncrOutboxFailureEntryPatch,
   buildBncrOutboxPushSuccessEntryPatch,
@@ -36,6 +42,11 @@ export function createBncrBridgeOutboxFacade(runtime: {
   lastPrePushGuardSkipReasonByAccount: Map<string, string>;
   deadLetterSinceStartByAccount: Map<string, number>;
   lastOutboundByAccount: Map<string, number>;
+  outboundReplayCache?: BncrOutboundReplayCache;
+  conversationHistories?: BncrConversationHistoryMap;
+  resolveOutboundHistoryLimit?: (entry: OutboxEntry) => number;
+  resolveOutboundSender?: (entry: OutboxEntry) => { sender: string; senderId?: string };
+  isOutboundAckRequired?: (accountId: string) => boolean;
   scheduleSave: () => void;
   flushPushQueueBestEffort: (args?: {
     accountId?: string;
@@ -48,6 +59,31 @@ 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,
+      ...(runtime.conversationHistories
+        ? { conversationHistories: runtime.conversationHistories }
+        : {}),
+      ...(runtime.resolveOutboundHistoryLimit
+        ? { historyLimit: runtime.resolveOutboundHistoryLimit(entry) }
+        : {}),
+      entry,
+      sender: senderInfo.sender,
+      senderId: senderInfo.senderId,
+      status,
+    });
+  };
+
+  const markRecentOutboundAcked = (entry: OutboxEntry) => {
+    recordOutboundMessage(entry, 'acked');
+  };
+
   const recordOutboxPrePushFailure = (args: {
     entry: OutboxEntry;
     lastError: string;
@@ -120,6 +156,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 +220,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 +264,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

@@ -4,8 +4,9 @@ import { emitBncrLogLine } from '../core/logging.ts';
 import { formatDisplayScope, normalizeStoredSessionKey, parseRouteLike } from '../core/targets.ts';
 import type { BncrRoute } from '../core/types.ts';
 import type { BncrInboundParamsInput } from '../messaging/inbound/contracts.ts';
+import type { BncrConversationHistoryMap } from '../messaging/inbound/conversation-history.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';
@@ -210,7 +211,8 @@ export function createBncrInboundHandlersComponent(runtime: {
   defaultAdminAgentId: Parameters<typeof createBncrInboundHandlers>[0]['defaultAdminAgentId'];
   defaultPublicAgentId: Parameters<typeof createBncrInboundHandlers>[0]['defaultPublicAgentId'];
   sceneRegistry: Parameters<typeof createBncrInboundHandlers>[0]['sceneRegistry'];
-  groupHistories: BncrGroupHistoryMap;
+  conversationHistories: BncrConversationHistoryMap;
+  outboundReplayCache: BncrOutboundReplayCache;
   prepareInboundAcceptance: Parameters<
     typeof createBncrInboundHandlers
   >[0]['prepareInboundAcceptance'];
@@ -255,7 +257,8 @@ export function createBncrInboundHandlersComponent(runtime: {
     defaultAdminAgentId: runtime.defaultAdminAgentId,
     defaultPublicAgentId: runtime.defaultPublicAgentId,
     sceneRegistry: runtime.sceneRegistry,
-    groupHistories: runtime.groupHistories,
+    conversationHistories: runtime.conversationHistories,
+    outboundReplayCache: runtime.outboundReplayCache,
     prepareInboundAcceptance: runtime.prepareInboundAcceptance,
     formatDisplayScope,
     logInboundSummary: runtime.logInboundSummary,
@@ -274,7 +277,8 @@ export function createBncrInboundHandlersComponent(runtime: {
       shouldDispatch,
       shouldAccumulate,
       sceneRegistry,
-      groupHistories,
+      conversationHistories,
+      outboundReplayCache,
       defaultAdminAgentId,
       defaultPublicAgentId,
       now,
@@ -289,7 +293,8 @@ export function createBncrInboundHandlersComponent(runtime: {
         shouldDispatch,
         shouldAccumulate,
         sceneRegistry,
-        groupHistories,
+        conversationHistories,
+        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 { BncrConversationHistoryMap } from '../messaging/inbound/conversation-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';
@@ -106,7 +107,8 @@ export function buildBncrInboundSurfaceRuntime(deps: {
   }) => string;
   defaultPublicAgentId: () => string;
   sceneRegistry: Map<string, BncrSceneRecord>;
-  groupHistories: BncrGroupHistoryMap;
+  conversationHistories: BncrConversationHistoryMap;
+  outboundReplayCache: BncrOutboundReplayCache;
   prepareInboundAcceptance: (args: {
     parsed: ReturnType<typeof parseBncrInboundParams>;
     canonicalAgentId: string;

package/src/plugin/channel-runtime-types.ts

@@ -1,5 +1,11 @@
+import type { TSchema } from 'typebox';
 import type { RegisterDriftSnapshot } from '../core/register-trace.ts';
-import type { BncrDiagnosticsSummary, BncrRoute, OutboxEntry } from '../core/types.ts';
+import type {
+  BncrDiagnosticsSummary,
+  BncrOutboundReplayEntry,
+  BncrRoute,
+  OutboxEntry,
+} from '../core/types.ts';
 import type { OpenClawChannelToolSend, openClawJsonResult } from '../openclaw/sdk-helpers.ts';
 
 type OpenClawJsonResultPayload = ReturnType<typeof openClawJsonResult>;
@@ -67,25 +73,33 @@ export type BncrSceneRecord = {
   lastSeenAt: number;
 };
 
-export type BncrPersistedGroupHistoryEntry = {
+export type BncrPersistedConversationHistoryEntry = {
   sender: string;
   senderId?: string;
+  role?: 'user' | 'assistant' | 'system';
   body: string;
   timestamp?: number;
   messageId?: string;
-  media?: BncrPersistedGroupHistoryMediaEntry[];
+  media?: BncrPersistedConversationHistoryMediaEntry[];
 };
 
-export type BncrPersistedGroupHistoryMediaEntry = {
+export type BncrPersistedConversationHistoryMediaEntry = {
   path?: string;
   contentType?: string;
   kind?: 'image' | 'video' | 'audio' | 'document' | 'unknown';
   messageId?: string;
 };
 
-export type BncrPersistedGroupHistoryBucket = {
+export type BncrPersistedConversationHistoryBucket = {
   key: string;
-  entries: BncrPersistedGroupHistoryEntry[];
+  entries: BncrPersistedConversationHistoryEntry[];
+};
+
+export type BncrPersistedOutboundReplayEntry = BncrOutboundReplayEntry;
+export type BncrPersistedOutboundReplayMediaEntry = BncrPersistedConversationHistoryMediaEntry;
+export type BncrPersistedOutboundReplayBucket = {
+  key: string;
+  entries: BncrPersistedOutboundReplayEntry[];
 };
 
 export type BncrStatusRuntimeSnapshot = {
@@ -143,10 +157,20 @@ export type BncrChannelSendContext = {
   extra?: Record<string, unknown>;
 };
 
+/**
+ * TypeBox schema contribution for the shared `message` tool.
+ * The host wraps each property with Type.Optional before validation.
+ */
+export type BncrMessageToolSchemaContribution = {
+  visibility?: 'current-channel' | 'all-configured';
+  properties: Record<string, TSchema>;
+};
+
 export type ChannelMessageActionAdapter = {
   describeMessageTool: (ctx: { cfg: BncrChannelConfigRoot }) => {
-    actions: readonly ['send'];
+    actions: readonly ('send' | 'delete' | 'unsend')[];
     capabilities: readonly [];
+    schema?: BncrMessageToolSchemaContribution;
   } | null;
   supportsAction: (ctx: { action: string }) => boolean;
   extractToolSend: (ctx: { args: unknown }) => OpenClawChannelToolSend | null;
@@ -163,7 +187,9 @@ export type PersistedState = {
   deadLetter: OutboxEntry[];
   sessionRoutes: BncrPersistedSessionRoute[];
   sceneRegistry?: BncrSceneRecord[];
-  groupHistories?: BncrPersistedGroupHistoryBucket[];
+  conversationHistories?: BncrPersistedConversationHistoryBucket[];
+  groupHistories?: BncrPersistedConversationHistoryBucket[];
+  outboundReplayCache?: BncrPersistedOutboundReplayBucket[];
   lastSessionByAccount?: BncrPersistedLastSession[];
   lastActivityByAccount?: BncrPersistedAccountTimestamp[];
   lastInboundByAccount?: BncrPersistedAccountTimestamp[];