@xmoxmo/bncr 0.5.9 → 0.6.1

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;

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>;
@@ -88,6 +94,13 @@ export type BncrPersistedGroupHistoryBucket = {
   entries: BncrPersistedGroupHistoryEntry[];
 };
 
+export type BncrPersistedOutboundReplayEntry = BncrOutboundReplayEntry;
+export type BncrPersistedOutboundReplayMediaEntry = BncrPersistedGroupHistoryMediaEntry;
+export type BncrPersistedOutboundReplayBucket = {
+  key: string;
+  entries: BncrPersistedOutboundReplayEntry[];
+};
+
 export type BncrStatusRuntimeSnapshot = {
   connected?: boolean;
   running?: boolean;
@@ -143,10 +156,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;
@@ -164,6 +187,7 @@ export type PersistedState = {
   sessionRoutes: BncrPersistedSessionRoute[];
   sceneRegistry?: BncrSceneRecord[];
   groupHistories?: BncrPersistedGroupHistoryBucket[];
+  outboundReplayCache?: BncrPersistedOutboundReplayBucket[];
   lastSessionByAccount?: BncrPersistedLastSession[];
   lastActivityByAccount?: BncrPersistedAccountTimestamp[];
   lastInboundByAccount?: BncrPersistedAccountTimestamp[];

package/src/plugin/channel-send.ts

@@ -1,4 +1,3 @@
-import { randomUUID } from 'node:crypto';
 import { normalizeAccountId } from '../core/accounts.ts';
 import { buildBncrDebugJsonMessage } from '../core/logging.ts';
 import type { BncrRoute, OutboxEntry } from '../core/types.ts';
@@ -211,28 +210,22 @@ export function createBncrChannelSendRuntime(runtime: BncrChannelSendRuntime) {
     const verified = runtime.resolveVerifiedTarget(to, accountId);
     runtime.rememberSessionRoute(verified.sessionKey, accountId, verified.route);
 
-    await runtime.enqueueFromReply({
-      accountId,
-      sessionKey: verified.sessionKey,
-      route: verified.route,
-      payload: {
-        text: text,
-        mediaUrl: mediaUrl || undefined,
-        mediaUrls: Array.isArray(mediaUrls) && mediaUrls.length ? mediaUrls : undefined,
-        asVoice: asVoice || undefined,
-        audioAsVoice: audioAsVoice || undefined,
-        downloadMedia,
-        type,
-        extra,
-        kind: kind as 'tool' | 'block' | 'final' | undefined,
-        replyToId,
-      },
-      mediaLocalRoots: ctx.mediaLocalRoots,
+    const entry = await enqueueChannelMessageHandoff(runtime, ctx, {
+      text: text,
+      mediaUrl: mediaUrl || undefined,
+      mediaUrls: Array.isArray(mediaUrls) && mediaUrls.length ? mediaUrls : undefined,
+      asVoice: asVoice || undefined,
+      audioAsVoice: audioAsVoice || undefined,
+      downloadMedia,
+      type,
+      extra,
+      kind: kind as 'tool' | 'block' | 'final' | undefined,
+      replyToId,
     });
 
     return {
       channel: runtime.channelId,
-      messageId: randomUUID(),
+      messageId: entry.messageId,
       chatId: verified.sessionKey,
     };
   }

package/src/plugin/client-rpc-runtime.ts

@@ -0,0 +1,129 @@
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+
+export const BNCR_CLIENT_RPC_REQUEST_EVENT = 'plugin.bncr.rpc.request';
+export const BNCR_CLIENT_RPC_RESPONSE_METHOD = 'bncr.rpc.response';
+export const BNCR_CLIENT_RPC_TIMEOUT_MS = 15000;
+
+type BncrClientRpcPending = {
+  method: string;
+  resolve: (result: Record<string, unknown>) => void;
+  reject: (error: Error) => void;
+  timer: NodeJS.Timeout;
+};
+
+export type BncrClientRpcRuntime = {
+  call: (
+    method: string,
+    args: Record<string, unknown>,
+    accountId: string,
+  ) => Promise<Record<string, unknown>>;
+  handleResponse: (ctx: GatewayRequestHandlerOptions) => void;
+  pendingCount: () => number;
+  shutdown: () => void;
+};
+
+export function createBncrClientRpcRuntime(runtime: {
+  resolvePushConnIds: (accountId: string) => ReadonlySet<string>;
+  broadcastToConnIds: (event: string, payload: unknown, connIds: ReadonlySet<string>) => void;
+  now: () => number;
+  logInfo: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  timeoutMs?: number;
+}): BncrClientRpcRuntime {
+  const pending = new Map<string, BncrClientRpcPending>();
+  let requestSeq = 0;
+  const timeoutMs = Math.max(Number(runtime.timeoutMs ?? BNCR_CLIENT_RPC_TIMEOUT_MS), 1);
+
+  const cleanup = (requestId: string) => {
+    const entry = pending.get(requestId);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    pending.delete(requestId);
+  };
+
+  const call = (method: string, args: Record<string, unknown>, accountId: string) => {
+    const normalizedMethod = String(method || '').trim();
+    if (!normalizedMethod) {
+      return Promise.reject(new Error('bncr client RPC requires a method name'));
+    }
+
+    const connIds = runtime.resolvePushConnIds(accountId);
+    if (!connIds.size) {
+      return Promise.reject(new Error(`no active bncr client connection for account ${accountId}`));
+    }
+    const targetConnIds = new Set([Array.from(connIds)[0]]);
+
+    const requestId = `rpc_${runtime.now().toString(36)}_${String(process.pid)}_${++requestSeq}`;
+    return new Promise<Record<string, unknown>>((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup(requestId);
+        reject(
+          new Error(
+            `bncr client RPC timeout method=${normalizedMethod}|accountId=${accountId}|timeoutMs=${timeoutMs}`,
+          ),
+        );
+      }, timeoutMs);
+      pending.set(requestId, {
+        method: normalizedMethod,
+        resolve,
+        reject,
+        timer,
+      });
+      runtime.broadcastToConnIds(
+        BNCR_CLIENT_RPC_REQUEST_EVENT,
+        {
+          requestId,
+          method: normalizedMethod,
+          args: args ?? {},
+        },
+        targetConnIds,
+      );
+    });
+  };
+
+  const handleResponse = (ctx: GatewayRequestHandlerOptions) => {
+    const params =
+      ctx.params && typeof ctx.params === 'object' ? (ctx.params as Record<string, unknown>) : {};
+    const requestId = typeof params.requestId === 'string' ? params.requestId.trim() : '';
+    const entry = requestId ? pending.get(requestId) : undefined;
+    if (!entry) {
+      runtime.logInfo('client-rpc', `rpc response ignored requestId=${requestId || '(missing)'}`, {
+        debugOnly: true,
+      });
+      ctx.respond(true, { ok: true, consumed: false, requestId });
+      return;
+    }
+
+    cleanup(requestId);
+    if (params.ok === true) {
+      const result =
+        params.result && typeof params.result === 'object'
+          ? (params.result as Record<string, unknown>)
+          : { value: params.result };
+      entry.resolve({
+        ok: true,
+        method: entry.method,
+        result,
+      });
+    } else {
+      const message =
+        typeof params.error === 'string'
+          ? params.error
+          : `bncr client RPC failed method=${entry.method}`;
+      entry.reject(new Error(message));
+    }
+    ctx.respond(true, { ok: true, consumed: true, requestId });
+  };
+
+  return {
+    call,
+    handleResponse,
+    pendingCount: () => pending.size,
+    shutdown: () => {
+      for (const [requestId, entry] of pending.entries()) {
+        clearTimeout(entry.timer);
+        entry.reject(new Error(`bncr client RPC cancelled method=${entry.method}`));
+        pending.delete(requestId);
+      }
+    },
+  };
+}

package/src/plugin/gateway-methods.ts

@@ -6,6 +6,7 @@ export const BNCR_GATEWAY_METHODS = [
   'bncr.diagnostics',
   'bncr.deadLetter.inspect',
   'bncr.deadLetter.prune',
+  'bncr.rpc.response',
   'bncr.file.init',
   'bncr.file.chunk',
   'bncr.file.complete',

package/src/plugin/inbound-handlers.ts

@@ -2,6 +2,7 @@ import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
 import { buildCanonicalBncrSessionKey } from '../core/targets.ts';
 import type { BncrConnection, BncrRoute } 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 {
@@ -134,6 +135,7 @@ export type BncrInboundHandlersRuntime = {
   defaultPublicAgentId: () => string;
   sceneRegistry: Map<string, BncrSceneRecord>;
   groupHistories: BncrGroupHistoryMap;
+  outboundReplayCache: BncrOutboundReplayCache;
   prepareInboundAcceptance: (args: {
     parsed: ParsedInboundParams;
     canonicalAgentId: string;
@@ -164,6 +166,7 @@ export type BncrInboundHandlersRuntime = {
     shouldAccumulate: boolean;
     sceneRegistry: Map<string, BncrSceneRecord>;
     groupHistories: BncrGroupHistoryMap;
+    outboundReplayCache: BncrOutboundReplayCache;
     defaultAdminAgentId: string;
     defaultPublicAgentId: string;
     now: () => number;
@@ -333,6 +336,7 @@ export function createBncrInboundHandlers(runtime: Omit<BncrInboundHandlersRunti
           shouldAccumulate,
           sceneRegistry: runtime.sceneRegistry,
           groupHistories: runtime.groupHistories,
+          outboundReplayCache: runtime.outboundReplayCache,
           defaultAdminAgentId,
           defaultPublicAgentId: runtime.defaultPublicAgentId(),
           now: runtime.now,

package/src/plugin/inbound-surface-handlers-group.ts

@@ -1,5 +1,6 @@
 import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
 import type { BncrConnection, BncrRoute } from '../core/types.ts';
+import type { BncrOutboundReplayCache } from '../messaging/inbound/outbound-replay-cache.ts';
 import {
   createBncrFileInboundHandlersComponent,
   createBncrInboundHandlersComponent,
@@ -86,6 +87,7 @@ export function createBncrInboundSurfaceHandlersGroup(runtime: {
   >[0]['defaultPublicAgentId'];
   sceneRegistry: Parameters<typeof createBncrInboundHandlersComponent>[0]['sceneRegistry'];
   groupHistories: Parameters<typeof createBncrInboundHandlersComponent>[0]['groupHistories'];
+  outboundReplayCache: BncrOutboundReplayCache;
   prepareInboundAcceptance: Parameters<
     typeof createBncrInboundHandlersComponent
   >[0]['prepareInboundAcceptance'];
@@ -152,6 +154,7 @@ export function createBncrInboundSurfaceHandlersGroup(runtime: {
     defaultPublicAgentId: runtime.defaultPublicAgentId,
     sceneRegistry: runtime.sceneRegistry,
     groupHistories: runtime.groupHistories,
+    outboundReplayCache: runtime.outboundReplayCache,
     prepareInboundAcceptance: runtime.prepareInboundAcceptance,
     logInboundSummary: runtime.logInboundSummary,
     flushPushQueueBestEffort: runtime.flushPushQueueBestEffort,

package/src/plugin/outbox-ack-outcome.ts

@@ -26,6 +26,7 @@ export type BncrOutboxAckOutcomeRuntime = {
   scheduleSave: () => void;
   resolveMessageAck: (messageId: string, result: 'acked' | 'timeout') => void;
   moveToDeadLetter: (entry: OutboxEntry, reason: string) => void;
+  markRecentOutboundAcked?: (entry: OutboxEntry) => void;
   logOutboxAckSummary: (
     scope: 'outbox ack ok' | 'outbox ack ok late' | 'outbox ack retry' | 'outbox ack fatal',
     args: {
@@ -69,6 +70,7 @@ export function createBncrOutboxAckOutcome(runtime: BncrOutboxAckOutcomeRuntime)
     runtime.deleteOutboxEntry(args.messageId);
     runtime.scheduleSave();
     runtime.resolveMessageAck(args.messageId, 'acked');
+    runtime.markRecentOutboundAcked?.(args.entry);
     runtime.logOutboxAckSummary(
       telemetryPatch.lateAccepted ? 'outbox ack ok late' : 'outbox ack ok',
       {