@xmoxmo/bncr 0.6.0 → 0.6.1

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',
       {

package/src/plugin/state-store.ts

@@ -3,6 +3,10 @@ import {
   normalizeRegisterDriftSnapshot,
 } from '../core/register-trace.ts';
 import type { BncrRoute, OutboxEntry } from '../core/types.ts';
+import type {
+  BncrOutboundReplayEntry,
+  BncrOutboundReplayStatus,
+} from '../messaging/inbound/outbound-replay-cache.ts';
 import {
   readOpenClawJsonFileWithFallback,
   writeOpenClawJsonFileAtomically,
@@ -14,6 +18,8 @@ import type {
   BncrPersistedGroupHistoryEntry,
   BncrPersistedGroupHistoryMediaEntry,
   BncrPersistedLastSession,
+  BncrPersistedOutboundReplayBucket,
+  BncrPersistedOutboundReplayEntry,
   BncrPersistedSessionRoute,
   PersistedState as BncrPersistedState,
   BncrSceneRecord,
@@ -28,6 +34,9 @@ type BncrPersistedStateStoreInput = {
   sessionRoutes?: unknown;
   sceneRegistry?: unknown;
   groupHistories?: unknown;
+  outboundReplayCache?: unknown;
+  // Legacy persisted key from before the outboundReplayCache rename.
+  messageCache?: unknown;
   lastSessionByAccount?: unknown;
   lastActivityByAccount?: unknown;
   lastInboundByAccount?: unknown;
@@ -41,6 +50,8 @@ type PersistedSessionRouteInput = Partial<BncrPersistedSessionRoute>;
 type PersistedSceneRecordInput = Partial<BncrSceneRecord>;
 type PersistedGroupHistoryBucketInput = Partial<BncrPersistedGroupHistoryBucket>;
 type PersistedGroupHistoryEntryInput = Partial<BncrPersistedGroupHistoryEntry>;
+type PersistedOutboundReplayBucketInput = Partial<BncrPersistedOutboundReplayBucket>;
+type PersistedOutboundReplayEntryInput = Partial<BncrOutboundReplayEntry>;
 
 export function createBncrStateStore(runtime: {
   getStatePath: () => string | null;
@@ -65,6 +76,7 @@ export function createBncrStateStore(runtime: {
   maxAccountActivityEntries: number;
   sceneRegistry: Map<string, BncrSceneRecord>;
   groupHistories: Map<string, BncrPersistedGroupHistoryEntry[]>;
+  outboundReplayCache?: Map<string, BncrPersistedOutboundReplayEntry[]>;
   outbox: Map<string, OutboxEntry>;
   getDeadLetter: () => OutboxEntry[];
   setDeadLetter: (entries: OutboxEntry[]) => void;
@@ -77,6 +89,9 @@ export function createBncrStateStore(runtime: {
   getLastDriftSnapshot: () => BncrPersistedState['lastDriftSnapshot'];
   setLastDriftSnapshot: (value: BncrPersistedState['lastDriftSnapshot']) => void;
 }) {
+  const outboundReplayCache =
+    runtime.outboundReplayCache ?? new Map<string, BncrPersistedOutboundReplayEntry[]>();
+
   function resolvePersistedGroupHistoryLimit(key: string): number {
     const scene = runtime.sceneRegistry.get(key);
     const sceneLimit = scene?.kind === 'group' ? scene.historyLimit : undefined;
@@ -148,8 +163,12 @@ export function createBncrStateStore(runtime: {
     return Array.from(runtime.sceneRegistry.values()).sort((a, b) => a.lastSeenAt - b.lastSeenAt);
   }
 
-  function loadPersistedGroupHistories(persisted: unknown): void {
-    runtime.groupHistories.clear();
+  function loadPersistedHistoryBuckets(
+    persisted: unknown,
+    target: Map<string, BncrPersistedGroupHistoryEntry[]>,
+    resolveLimit: (key: string) => number,
+  ): void {
+    target.clear();
     const buckets = Array.isArray(persisted)
       ? (persisted as PersistedGroupHistoryBucketInput[])
       : [];
@@ -199,15 +218,112 @@ export function createBncrStateStore(runtime: {
         entries.push(normalizedEntry);
       }
       if (entries.length > 0) {
-        runtime.groupHistories.set(key, entries.slice(-resolvePersistedGroupHistoryLimit(key)));
+        const limit = resolveLimit(key);
+        target.set(key, Number.isFinite(limit) ? entries.slice(-limit) : entries);
       }
     }
   }
 
+  function loadPersistedGroupHistories(persisted: unknown): void {
+    loadPersistedHistoryBuckets(persisted, runtime.groupHistories, (key) =>
+      resolvePersistedGroupHistoryLimit(key),
+    );
+  }
+
+  function loadPersistedOutboundReplayCache(persisted: unknown): void {
+    outboundReplayCache.clear();
+    const buckets = Array.isArray(persisted)
+      ? (persisted as PersistedOutboundReplayBucketInput[])
+      : [];
+    for (const bucket of buckets) {
+      const key = runtime.asString(bucket?.key || '').trim();
+      if (!key) continue;
+      const entries: BncrOutboundReplayEntry[] = [];
+      const rawEntries = Array.isArray(bucket?.entries)
+        ? (bucket.entries as PersistedOutboundReplayEntryInput[])
+        : [];
+      for (const entry of rawEntries) {
+        const sender = runtime.asString(entry?.sender || '').trim();
+        const body = runtime.asString(entry?.body || '').trim();
+        if (!sender || !body) continue;
+        const timestamp = runtime.finiteNumberOr(entry?.timestamp, 0);
+        const messageId = runtime.asString(entry?.messageId || '').trim();
+        const accountId = runtime.asString(entry?.accountId || '').trim();
+        const sessionKey = runtime.asString(entry?.sessionKey || '').trim();
+        const type = runtime.asString(entry?.type || '').trim();
+        const mediaUrl = runtime.asString(entry?.mediaUrl || '').trim();
+        const createdAt = runtime.finiteNumberOr(entry?.createdAt, 0);
+        const status = runtime.asString(entry?.status || '').trim();
+        const route =
+          runtime.parseRouteLike(entry?.route) ||
+          runtime.parseRouteLike({
+            platform: entry?.route?.platform,
+            groupId: entry?.route?.groupId,
+            userId: entry?.route?.userId,
+          });
+        const media: BncrPersistedGroupHistoryMediaEntry[] = [];
+        const rawMedia = Array.isArray(entry?.media)
+          ? (entry.media as Partial<BncrPersistedGroupHistoryMediaEntry>[])
+          : [];
+        for (const item of rawMedia) {
+          const path = runtime.asString(item?.path || '').trim();
+          if (!path) continue;
+          const contentType = runtime.asString(item?.contentType || '').trim();
+          const kind = runtime.asString(item?.kind || '').trim();
+          const mediaMessageId = runtime.asString(item?.messageId || '').trim();
+          media.push({
+            path,
+            ...(contentType ? { contentType } : {}),
+            ...(kind ? { kind: kind as BncrPersistedGroupHistoryMediaEntry['kind'] } : {}),
+            ...(mediaMessageId ? { messageId: mediaMessageId } : {}),
+          });
+        }
+        entries.push({
+          sender,
+          ...(runtime.asString(entry?.senderId || '').trim()
+            ? { senderId: runtime.asString(entry?.senderId || '').trim() }
+            : {}),
+          body,
+          ...(timestamp > 0 ? { timestamp } : {}),
+          ...(messageId ? { messageId } : {}),
+          ...(media.length > 0 ? { media } : {}),
+          ...(accountId ? { accountId } : {}),
+          ...(sessionKey ? { sessionKey } : {}),
+          ...(route ? { route } : {}),
+          ...(type ? { type } : {}),
+          ...(mediaUrl ? { mediaUrl } : {}),
+          ...(createdAt > 0 ? { createdAt } : {}),
+          ...(status === 'pushed' || status === 'acked'
+            ? { status: status as BncrOutboundReplayStatus }
+            : {}),
+        });
+      }
+      if (entries.length > 0) {
+        outboundReplayCache.set(key, entries);
+      }
+    }
+  }
+
+  function dumpPersistedHistoryBuckets(
+    source: Map<string, BncrPersistedGroupHistoryEntry[]>,
+    resolveLimit: (key: string) => number,
+  ) {
+    return Array.from(source.entries()).map(([key, entries]) => ({
+      key,
+      entries: Number.isFinite(resolveLimit(key)) ? entries.slice(-resolveLimit(key)) : entries,
+    }));
+  }
+
   function dumpPersistedGroupHistories() {
-    return Array.from(runtime.groupHistories.entries()).map(([key, entries]) => ({
+    return dumpPersistedHistoryBuckets(runtime.groupHistories, (key) =>
+      resolvePersistedGroupHistoryLimit(key),
+    );
+  }
+
+  function dumpPersistedOutboundReplayCache() {
+    return Array.from(outboundReplayCache.entries()).map(([key, entries]) => ({
       key,
-      entries: entries.slice(-resolvePersistedGroupHistoryLimit(key)),
+      entries,
     }));
   }
 
@@ -359,6 +475,7 @@ export function createBncrStateStore(runtime: {
     loadPersistedSessionRoutes(data.sessionRoutes);
     loadPersistedSceneRegistry(data.sceneRegistry);
     loadPersistedGroupHistories(data.groupHistories);
+    loadPersistedOutboundReplayCache(data.outboundReplayCache ?? data.messageCache);
     loadPersistedLastSessionMap(data.lastSessionByAccount);
     loadPersistedAccountTimestampMap(runtime.lastActivityByAccount, data.lastActivityByAccount);
     loadPersistedAccountTimestampMap(runtime.lastInboundByAccount, data.lastInboundByAccount);
@@ -378,6 +495,7 @@ export function createBncrStateStore(runtime: {
       sessionRoutes: dumpPersistedSessionRoutes(),
       sceneRegistry: dumpPersistedSceneRegistry(),
       groupHistories: dumpPersistedGroupHistories(),
+      outboundReplayCache: dumpPersistedOutboundReplayCache(),
       lastSessionByAccount: dumpPersistedLastSessionMap(),
       lastActivityByAccount: dumpPersistedAccountTimestampMap(runtime.lastActivityByAccount),
       lastInboundByAccount: dumpPersistedAccountTimestampMap(runtime.lastInboundByAccount),
@@ -399,6 +517,8 @@ export function createBncrStateStore(runtime: {
     dumpPersistedSceneRegistry,
     loadPersistedGroupHistories,
     dumpPersistedGroupHistories,
+    loadPersistedOutboundReplayCache,
+    dumpPersistedOutboundReplayCache,
     backfillAccountActivityFromSessionRoutes,
     loadState,
     flushState,

package/src/plugin/state-transient-runtime-group.ts

@@ -6,7 +6,11 @@ import type {
   FileSendTransferState,
   OutboxEntry,
 } from '../core/types.ts';
-import type { BncrPersistedGroupHistoryEntry, BncrSceneRecord } from './channel-runtime-types.ts';
+import type {
+  BncrPersistedGroupHistoryEntry,
+  BncrPersistedOutboundReplayEntry,
+  BncrSceneRecord,
+} from './channel-runtime-types.ts';
 import { createBncrStateStore } from './state-store.ts';
 import { createBncrTransientStateRuntime } from './transient-state-runtime.ts';
 
@@ -34,6 +38,7 @@ export function createBncrStateTransientRuntimeGroup(runtime: {
   maxAccountActivityEntries: number;
   sceneRegistry: Map<string, BncrSceneRecord>;
   groupHistories: Map<string, BncrPersistedGroupHistoryEntry[]>;
+  outboundReplayCache?: Map<string, BncrPersistedOutboundReplayEntry[]>;
   outbox: Map<string, OutboxEntry>;
   getDeadLetter: () => OutboxEntry[];
   setDeadLetter: (entries: OutboxEntry[]) => void;
@@ -74,6 +79,8 @@ export function createBncrStateTransientRuntimeGroup(runtime: {
     maxAccountActivityEntries: runtime.maxAccountActivityEntries,
     sceneRegistry: runtime.sceneRegistry,
     groupHistories: runtime.groupHistories,
+    outboundReplayCache:
+      runtime.outboundReplayCache ?? new Map<string, BncrPersistedOutboundReplayEntry[]>(),
     outbox: runtime.outbox,
     getDeadLetter: runtime.getDeadLetter,
     setDeadLetter: runtime.setDeadLetter,