@xmoxmo/bncr 0.6.0 → 0.6.2

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-acceptance.ts

@@ -66,30 +66,12 @@ function shouldDispatchForScene(args: {
 }
 
 function shouldAccumulateForScene(args: {
-  parsed: ReturnType<typeof parseBncrInboundParams>;
+  shouldDispatch: boolean;
   admission: ReturnType<typeof decideSceneAdmission>;
-  cfg: BncrChannelConfigRoot;
 }) {
-  const { parsed, admission, cfg } = args;
-  if (parsed.peer.kind === 'direct') return true;
-  if (!admission.allowed) return false;
-
-  const isBncrNativeCommand =
-    parseBncrNativeCommand(parsed.extracted.text, {
-      allowBareWhoami: parsed.isAdmin !== true,
-    }) !== null;
-  const isAdminOpenClawNativeCommand =
-    parsed.isAdmin === true &&
-    !isBncrNativeCommand &&
-    hasControlCommand(parsed.extracted.text, cfg as Parameters<typeof hasControlCommand>[1]);
-  if (isAdminOpenClawNativeCommand) return true;
-
-  const mode = admission.scene.groupReplyMode || 'admin';
-  // admin and all: no accumulation needed - messages are either dispatched directly or discarded
-  if (mode === 'admin') return false;
-  if (mode === 'all') return false;
-  // mention and hybrid: non-trigger messages accumulate for future context
-  return true;
+  if (args.shouldDispatch) return true;
+  const mode = args.admission.scene.groupReplyMode || 'admin';
+  return mode === 'mention' || mode === 'hybrid';
 }
 
 export async function prepareBncrInboundAcceptance(args: {
@@ -206,6 +188,9 @@ export async function prepareBncrInboundAcceptance(args: {
     resolveAgentRoute: args.resolveAgentRoute,
   });
 
+  const shouldDispatch = shouldDispatchForScene({ parsed, admission, cfg });
+  const shouldAccumulate = shouldAccumulateForScene({ shouldDispatch, admission });
+
   return {
     ok: true as const,
     accountId,
@@ -213,8 +198,8 @@ export async function prepareBncrInboundAcceptance(args: {
     inboundText,
     hasMedia: Boolean(mediaBase64 || mediaPathFromTransfer),
     resolvedAgentId: admission.agentId,
-    shouldDispatch: shouldDispatchForScene({ parsed, admission, cfg }),
-    shouldAccumulate: shouldAccumulateForScene({ parsed, admission, cfg }),
+    shouldDispatch,
+    shouldAccumulate,
     dispatchBy: resolveDispatchBy({ parsed, admission, cfg }),
   };
 }

package/src/plugin/inbound-handlers.ts

@@ -1,7 +1,8 @@
 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 { 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 {
@@ -133,7 +134,8 @@ export type BncrInboundHandlersRuntime = {
   }) => string;
   defaultPublicAgentId: () => string;
   sceneRegistry: Map<string, BncrSceneRecord>;
-  groupHistories: BncrGroupHistoryMap;
+  conversationHistories: BncrConversationHistoryMap;
+  outboundReplayCache: BncrOutboundReplayCache;
   prepareInboundAcceptance: (args: {
     parsed: ParsedInboundParams;
     canonicalAgentId: string;
@@ -163,7 +165,8 @@ export type BncrInboundHandlersRuntime = {
     shouldDispatch: boolean;
     shouldAccumulate: boolean;
     sceneRegistry: Map<string, BncrSceneRecord>;
-    groupHistories: BncrGroupHistoryMap;
+    conversationHistories: BncrConversationHistoryMap;
+    outboundReplayCache: BncrOutboundReplayCache;
     defaultAdminAgentId: string;
     defaultPublicAgentId: string;
     now: () => number;
@@ -332,7 +335,8 @@ export function createBncrInboundHandlers(runtime: Omit<BncrInboundHandlersRunti
           shouldDispatch,
           shouldAccumulate,
           sceneRegistry: runtime.sceneRegistry,
-          groupHistories: runtime.groupHistories,
+          conversationHistories: runtime.conversationHistories,
+          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,
@@ -85,7 +86,10 @@ export function createBncrInboundSurfaceHandlersGroup(runtime: {
     typeof createBncrInboundHandlersComponent
   >[0]['defaultPublicAgentId'];
   sceneRegistry: Parameters<typeof createBncrInboundHandlersComponent>[0]['sceneRegistry'];
-  groupHistories: Parameters<typeof createBncrInboundHandlersComponent>[0]['groupHistories'];
+  conversationHistories: Parameters<
+    typeof createBncrInboundHandlersComponent
+  >[0]['conversationHistories'];
+  outboundReplayCache: BncrOutboundReplayCache;
   prepareInboundAcceptance: Parameters<
     typeof createBncrInboundHandlersComponent
   >[0]['prepareInboundAcceptance'];
@@ -151,7 +155,8 @@ export function createBncrInboundSurfaceHandlersGroup(runtime: {
     defaultAdminAgentId: runtime.defaultAdminAgentId,
     defaultPublicAgentId: runtime.defaultPublicAgentId,
     sceneRegistry: runtime.sceneRegistry,
-    groupHistories: runtime.groupHistories,
+    conversationHistories: runtime.conversationHistories,
+    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/scene-registry.ts

@@ -56,8 +56,8 @@ function buildSceneRecord(args: {
     ...(kind === 'group' && parsed.groupName ? { groupName: parsed.groupName } : {}),
     ...(agentId ? { agentId } : {}),
     ...(kind === 'group' ? { groupReplyMode: defaultGroupReplyMode(kind) } : {}),
-    ...(kind === 'group' ? { historyLimit: 50 } : {}),
-    ...(kind === 'group' ? { historyForce: true } : {}),
+    historyLimit: 50,
+    historyForce: true,
     lastSeenAt,
   };
 }
@@ -90,8 +90,8 @@ export function decideSceneAdmission(args: {
       ...(kind === 'group' && !existing.groupReplyMode
         ? { groupReplyMode: defaultGroupReplyMode(kind) }
         : {}),
-      ...(kind === 'group' && existing.historyLimit === undefined ? { historyLimit: 50 } : {}),
-      ...(kind === 'group' && existing.historyForce === undefined ? { historyForce: true } : {}),
+      ...(existing.historyLimit === undefined ? { historyLimit: 50 } : {}),
+      ...(existing.historyForce === undefined ? { historyForce: true } : {}),
       lastSeenAt: now,
     } satisfies BncrSceneRecord;
 

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,
@@ -10,24 +14,30 @@ import {
 import type {
   BncrGroupReplyMode,
   BncrPersistedAccountTimestamp,
-  BncrPersistedGroupHistoryBucket,
-  BncrPersistedGroupHistoryEntry,
-  BncrPersistedGroupHistoryMediaEntry,
+  BncrPersistedConversationHistoryBucket,
+  BncrPersistedConversationHistoryEntry,
+  BncrPersistedConversationHistoryMediaEntry,
   BncrPersistedLastSession,
+  BncrPersistedOutboundReplayBucket,
+  BncrPersistedOutboundReplayEntry,
   BncrPersistedSessionRoute,
   PersistedState as BncrPersistedState,
   BncrSceneRecord,
 } from './channel-runtime-types.ts';
 
 const GROUP_REPLY_MODES = new Set<BncrGroupReplyMode>(['admin', 'mention', 'hybrid', 'all']);
-const DEFAULT_PERSISTED_GROUP_HISTORY_LIMIT = 50;
+const DEFAULT_PERSISTED_CONVERSATION_HISTORY_LIMIT = 50;
 
 type BncrPersistedStateStoreInput = {
   outbox?: unknown;
   deadLetter?: unknown;
   sessionRoutes?: unknown;
   sceneRegistry?: unknown;
+  conversationHistories?: unknown;
   groupHistories?: unknown;
+  outboundReplayCache?: unknown;
+  // Legacy persisted key from before the outboundReplayCache rename.
+  messageCache?: unknown;
   lastSessionByAccount?: unknown;
   lastActivityByAccount?: unknown;
   lastInboundByAccount?: unknown;
@@ -39,8 +49,10 @@ type PersistedAccountTimestampInput = Partial<BncrPersistedAccountTimestamp>;
 type PersistedLastSessionInput = Partial<BncrPersistedLastSession>;
 type PersistedSessionRouteInput = Partial<BncrPersistedSessionRoute>;
 type PersistedSceneRecordInput = Partial<BncrSceneRecord>;
-type PersistedGroupHistoryBucketInput = Partial<BncrPersistedGroupHistoryBucket>;
-type PersistedGroupHistoryEntryInput = Partial<BncrPersistedGroupHistoryEntry>;
+type PersistedConversationHistoryBucketInput = Partial<BncrPersistedConversationHistoryBucket>;
+type PersistedConversationHistoryEntryInput = Partial<BncrPersistedConversationHistoryEntry>;
+type PersistedOutboundReplayBucketInput = Partial<BncrPersistedOutboundReplayBucket>;
+type PersistedOutboundReplayEntryInput = Partial<BncrOutboundReplayEntry>;
 
 export function createBncrStateStore(runtime: {
   getStatePath: () => string | null;
@@ -64,7 +76,8 @@ export function createBncrStateStore(runtime: {
   maxSessionRouteEntries: number;
   maxAccountActivityEntries: number;
   sceneRegistry: Map<string, BncrSceneRecord>;
-  groupHistories: Map<string, BncrPersistedGroupHistoryEntry[]>;
+  conversationHistories: Map<string, BncrPersistedConversationHistoryEntry[]>;
+  outboundReplayCache?: Map<string, BncrPersistedOutboundReplayEntry[]>;
   outbox: Map<string, OutboxEntry>;
   getDeadLetter: () => OutboxEntry[];
   setDeadLetter: (entries: OutboxEntry[]) => void;
@@ -77,16 +90,19 @@ export function createBncrStateStore(runtime: {
   getLastDriftSnapshot: () => BncrPersistedState['lastDriftSnapshot'];
   setLastDriftSnapshot: (value: BncrPersistedState['lastDriftSnapshot']) => void;
 }) {
-  function resolvePersistedGroupHistoryLimit(key: string): number {
+  const outboundReplayCache =
+    runtime.outboundReplayCache ?? new Map<string, BncrPersistedOutboundReplayEntry[]>();
+
+  function resolvePersistedConversationHistoryLimit(key: string): number {
     const scene = runtime.sceneRegistry.get(key);
-    const sceneLimit = scene?.kind === 'group' ? scene.historyLimit : undefined;
+    const sceneLimit = scene?.historyLimit;
     if (typeof sceneLimit === 'number' && Number.isFinite(sceneLimit) && sceneLimit >= 0) {
       return Math.max(
-        DEFAULT_PERSISTED_GROUP_HISTORY_LIMIT,
+        DEFAULT_PERSISTED_CONVERSATION_HISTORY_LIMIT,
         Math.ceil(Math.floor(sceneLimit) * 1.2),
       );
     }
-    return DEFAULT_PERSISTED_GROUP_HISTORY_LIMIT;
+    return DEFAULT_PERSISTED_CONVERSATION_HISTORY_LIMIT;
   }
 
   function loadPersistedSceneRegistry(persisted: unknown): void {
@@ -148,17 +164,21 @@ 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, BncrPersistedConversationHistoryEntry[]>,
+    resolveLimit: (key: string) => number,
+  ): void {
+    target.clear();
     const buckets = Array.isArray(persisted)
-      ? (persisted as PersistedGroupHistoryBucketInput[])
+      ? (persisted as PersistedConversationHistoryBucketInput[])
       : [];
     for (const bucket of buckets) {
       const key = runtime.asString(bucket?.key || '').trim();
       if (!key) continue;
-      const entries: BncrPersistedGroupHistoryEntry[] = [];
+      const entries: BncrPersistedConversationHistoryEntry[] = [];
       const rawEntries = Array.isArray(bucket?.entries)
-        ? (bucket.entries as PersistedGroupHistoryEntryInput[])
+        ? (bucket.entries as PersistedConversationHistoryEntryInput[])
         : [];
       for (const entry of rawEntries) {
         const sender = runtime.asString(entry?.sender || '').trim();
@@ -167,9 +187,9 @@ export function createBncrStateStore(runtime: {
         const timestamp = runtime.finiteNumberOr(entry?.timestamp, 0);
         const messageId = runtime.asString(entry?.messageId || '').trim();
 
-        const media: BncrPersistedGroupHistoryMediaEntry[] = [];
+        const media: BncrPersistedConversationHistoryMediaEntry[] = [];
         const rawMedia = Array.isArray(entry?.media)
-          ? (entry.media as Partial<BncrPersistedGroupHistoryMediaEntry>[])
+          ? (entry.media as Partial<BncrPersistedConversationHistoryMediaEntry>[])
           : [];
         for (const item of rawMedia) {
           const path = runtime.asString(item?.path || '').trim();
@@ -177,20 +197,23 @@ export function createBncrStateStore(runtime: {
           const contentType = runtime.asString(item?.contentType || '').trim();
           const kind = runtime.asString(item?.kind || '').trim();
           const mediaMessageId = runtime.asString(item?.messageId || '').trim();
-          const normalizedMedia: BncrPersistedGroupHistoryMediaEntry = {
+          const normalizedMedia: BncrPersistedConversationHistoryMediaEntry = {
             path,
             ...(contentType ? { contentType } : {}),
-            ...(kind ? { kind: kind as BncrPersistedGroupHistoryMediaEntry['kind'] } : {}),
+            ...(kind ? { kind: kind as BncrPersistedConversationHistoryMediaEntry['kind'] } : {}),
             ...(mediaMessageId ? { messageId: mediaMessageId } : {}),
           };
           media.push(normalizedMedia);
         }
 
-        const normalizedEntry: BncrPersistedGroupHistoryEntry = {
+        const normalizedEntry: BncrPersistedConversationHistoryEntry = {
           sender,
           ...(runtime.asString(entry?.senderId || '').trim()
             ? { senderId: runtime.asString(entry?.senderId || '').trim() }
             : {}),
+          ...(entry?.role === 'user' || entry?.role === 'assistant' || entry?.role === 'system'
+            ? { role: entry.role }
+            : {}),
           body,
           ...(timestamp > 0 ? { timestamp } : {}),
           ...(messageId ? { messageId } : {}),
@@ -199,15 +222,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 dumpPersistedGroupHistories() {
-    return Array.from(runtime.groupHistories.entries()).map(([key, entries]) => ({
+  function loadPersistedConversationHistories(persisted: unknown): void {
+    loadPersistedHistoryBuckets(persisted, runtime.conversationHistories, (key) =>
+      resolvePersistedConversationHistoryLimit(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: BncrPersistedConversationHistoryMediaEntry[] = [];
+        const rawMedia = Array.isArray(entry?.media)
+          ? (entry.media as Partial<BncrPersistedConversationHistoryMediaEntry>[])
+          : [];
+        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 BncrPersistedConversationHistoryMediaEntry['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, BncrPersistedConversationHistoryEntry[]>,
+    resolveLimit: (key: string) => number,
+  ) {
+    return Array.from(source.entries()).map(([key, entries]) => ({
+      key,
+      entries: Number.isFinite(resolveLimit(key)) ? entries.slice(-resolveLimit(key)) : entries,
+    }));
+  }
+
+  function dumpPersistedConversationHistories() {
+    return dumpPersistedHistoryBuckets(runtime.conversationHistories, (key) =>
+      resolvePersistedConversationHistoryLimit(key),
+    );
+  }
+
+  function dumpPersistedOutboundReplayCache() {
+    return Array.from(outboundReplayCache.entries()).map(([key, entries]) => ({
       key,
-      entries: entries.slice(-resolvePersistedGroupHistoryLimit(key)),
+      entries,
     }));
   }
 
@@ -358,7 +478,8 @@ export function createBncrStateStore(runtime: {
 
     loadPersistedSessionRoutes(data.sessionRoutes);
     loadPersistedSceneRegistry(data.sceneRegistry);
-    loadPersistedGroupHistories(data.groupHistories);
+    loadPersistedConversationHistories(data.conversationHistories ?? data.groupHistories);
+    loadPersistedOutboundReplayCache(data.outboundReplayCache ?? data.messageCache);
     loadPersistedLastSessionMap(data.lastSessionByAccount);
     loadPersistedAccountTimestampMap(runtime.lastActivityByAccount, data.lastActivityByAccount);
     loadPersistedAccountTimestampMap(runtime.lastInboundByAccount, data.lastInboundByAccount);
@@ -377,7 +498,8 @@ export function createBncrStateStore(runtime: {
       deadLetter: runtime.getDeadLetter().slice(-runtime.maxDeadLetterEntries),
       sessionRoutes: dumpPersistedSessionRoutes(),
       sceneRegistry: dumpPersistedSceneRegistry(),
-      groupHistories: dumpPersistedGroupHistories(),
+      conversationHistories: dumpPersistedConversationHistories(),
+      outboundReplayCache: dumpPersistedOutboundReplayCache(),
       lastSessionByAccount: dumpPersistedLastSessionMap(),
       lastActivityByAccount: dumpPersistedAccountTimestampMap(runtime.lastActivityByAccount),
       lastInboundByAccount: dumpPersistedAccountTimestampMap(runtime.lastInboundByAccount),
@@ -397,8 +519,10 @@ export function createBncrStateStore(runtime: {
     dumpPersistedSessionRoutes,
     loadPersistedSceneRegistry,
     dumpPersistedSceneRegistry,
-    loadPersistedGroupHistories,
-    dumpPersistedGroupHistories,
+    loadPersistedConversationHistories,
+    dumpPersistedConversationHistories,
+    loadPersistedOutboundReplayCache,
+    dumpPersistedOutboundReplayCache,
     backfillAccountActivityFromSessionRoutes,
     loadState,
     flushState,