@xdarkicex/openclaw-memory-libravdb 1.5.4 → 1.6.0

package/dist/markdown-ingest.js

@@ -2,14 +2,14 @@ import fs from "node:fs";
 import fsp from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { hashBytes } from "./markdown-hash.js";
 import { formatError } from "./format-error.js";
 import { IngestQueue } from "./ingest-queue.js";
 const DEFAULT_DEBOUNCE_MS = 150;
 const DEFAULT_TOKENIZER_ID = "markdown-ingest:v1";
 const MARKDOWN_INGEST_VERSION = 3;
 const HASH_BACKEND = "wasm-fnv1a64";
-export function createMarkdownIngestionHandle(cfg, getRpc, logger = console, fsApi = createRealFsApi()) {
+const STREAM_CHUNK_BYTES = 64 * 1024;
+export function createMarkdownIngestionHandle(cfg, getClient, logger = console, fsApi = createRealFsApi()) {
     const adapters = [];
     const genericRoots = normalizeMarkdownRoots(cfg.markdownIngestionRoots);
     if (isMarkdownIngestionEnabled(cfg, genericRoots)) {
@@ -19,7 +19,9 @@ export function createMarkdownIngestionHandle(cfg, getRpc, logger = console, fsA
             exclude: cfg.markdownIngestionExclude,
             debounceMs: cfg.markdownIngestionDebounceMs ?? DEFAULT_DEBOUNCE_MS,
             snapshotPath: resolveMarkdownSnapshotPath("generic", cfg.markdownIngestionSnapshotPath),
-        }, getRpc, logger, fsApi));
+            priorityMode: cfg.markdownIngestionPriorityMode,
+            maxTokensPerFile: cfg.markdownIngestionMaxTokensPerFile,
+        }, getClient, logger, fsApi));
     }
     const obsidianRoots = normalizeMarkdownRoots(cfg.markdownIngestionObsidianRoots);
     if (cfg.markdownIngestionObsidianEnabled === true && obsidianRoots.length > 0) {
@@ -29,7 +31,9 @@ export function createMarkdownIngestionHandle(cfg, getRpc, logger = console, fsA
             exclude: cfg.markdownIngestionObsidianExclude,
             debounceMs: cfg.markdownIngestionObsidianDebounceMs ?? cfg.markdownIngestionDebounceMs ?? DEFAULT_DEBOUNCE_MS,
             snapshotPath: resolveMarkdownSnapshotPath("obsidian", cfg.markdownIngestionObsidianSnapshotPath),
-        }, getRpc, logger, fsApi));
+            priorityMode: cfg.markdownIngestionPriorityMode,
+            maxTokensPerFile: cfg.markdownIngestionMaxTokensPerFile,
+        }, getClient, logger, fsApi));
     }
     if (adapters.length === 0) {
         return {
@@ -74,9 +78,11 @@ class DirectoryMarkdownSourceAdapter {
     excludePatterns;
     debounceMs;
     fsApi;
-    getRpc;
+    getClient;
     logger;
     snapshotPath;
+    priorityMode;
+    maxTokensPerFile;
     states = new Map();
     fileStates = new Map();
     activeScans = new Set();
@@ -85,18 +91,31 @@ class DirectoryMarkdownSourceAdapter {
     started = false;
     ingestQueue = null;
     stopping = false;
+    lastAcceptMore = true;
+    lastRetryAfterMs = 0;
+    lastQueueDepth = 0;
+    lastQueueCapacity = 0;
+    lastProcessingTimeUs = 0;
+    lastNodesAccepted = 0;
+    lastNodesRejected = 0;
+    lastTokensIngested = 0;
+    lastTokenBurstLimit = 512;
+    lastWalDepth = 0;
+    lastWalCapacity = 0;
     snapshotLoaded = false;
     snapshotDirty = false;
-    constructor(kind, config, getRpc, logger, fsApi) {
+    constructor(kind, config, getClient, logger, fsApi) {
         this.kind = kind;
         this.roots = config.roots;
         this.includePatterns = config.include?.length ? config.include : [];
         this.excludePatterns = config.exclude?.length ? config.exclude : [];
         this.debounceMs = config.debounceMs ?? DEFAULT_DEBOUNCE_MS;
         this.fsApi = fsApi;
-        this.getRpc = getRpc;
+        this.getClient = getClient;
         this.logger = logger;
         this.snapshotPath = config.snapshotPath ?? resolveMarkdownSnapshotPath(kind);
+        this.priorityMode = config.priorityMode ?? "mtime";
+        this.maxTokensPerFile = Math.max(1, Math.trunc(config.maxTokensPerFile ?? 128_000));
         this.tokenizerId = DEFAULT_TOKENIZER_ID;
         this.coreDoc = true;
     }
@@ -150,6 +169,7 @@ class DirectoryMarkdownSourceAdapter {
                 scanning: false,
                 dirty: false,
                 timer: null,
+                resumeFromPath: null,
             },
             knownFiles: this.snapshotFilesForRoot(resolved),
             directoryWatchers: new Map(),
@@ -167,12 +187,16 @@ class DirectoryMarkdownSourceAdapter {
             return;
         }
         rootState.scanState.scanning = true;
+        this.lastAcceptMore = true;
+        this.lastRetryAfterMs = 0;
         const scan = (async () => {
             const stats = createScanStats();
             const startedAt = Date.now();
             try {
                 const currentFiles = new Set();
-                await this.walkDirectory(rootState, rootState.root, currentFiles, stats);
+                const candidates = [];
+                await this.walkDirectory(rootState, rootState.root, currentFiles, stats, candidates);
+                await this.syncCandidates(rootState, candidates, stats);
                 if (!this.stopping) {
                     await this.pruneDeletedFiles(rootState, currentFiles, stats);
                     rootState.knownFiles = currentFiles;
@@ -198,7 +222,7 @@ class DirectoryMarkdownSourceAdapter {
             this.activeScans.delete(scan);
         }
     }
-    scheduleRootScan(rootState) {
+    scheduleRootScan(rootState, delayMs) {
         if (!this.started || this.stopping) {
             return;
         }
@@ -214,9 +238,9 @@ class DirectoryMarkdownSourceAdapter {
             void this.scanRoot(rootState.root).catch((error) => {
                 this.logger.warn?.(`[markdown-ingest] root scan failed for ${rootState.root}: ${formatError(error)}`);
             });
-        }, this.debounceMs);
+        }, Math.max(this.debounceMs, delayMs ?? 0));
     }
-    async walkDirectory(rootState, dir, currentFiles, stats) {
+    async walkDirectory(rootState, dir, currentFiles, stats, candidates) {
         if (this.shouldPruneDirectory(rootState.root, dir)) {
             stats.directoriesPruned++;
             return;
@@ -240,7 +264,7 @@ class DirectoryMarkdownSourceAdapter {
             }
             const child = path.join(dir, entry.name);
             if (entry.isDirectory()) {
-                await this.walkDirectory(rootState, child, currentFiles, stats);
+                await this.walkDirectory(rootState, child, currentFiles, stats, candidates);
                 continue;
             }
             if (!entry.isFile() || !isMarkdownFile(entry.name)) {
@@ -253,17 +277,74 @@ class DirectoryMarkdownSourceAdapter {
             }
             stats.filesIncluded++;
             currentFiles.add(child);
+            const stat = await this.safeStatWithCtime(child);
+            if (!stat) {
+                continue;
+            }
+            candidates.push({ path: child, size: stat.size, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs, ordinal: candidates.length });
+        }
+    }
+    async syncCandidates(rootState, candidates, stats) {
+        const sorted = sortCandidates(candidates, this.priorityMode);
+        let skipping = false;
+        if (rootState.scanState.resumeFromPath) {
+            const targetExists = sorted.some((c) => c.path === rootState.scanState.resumeFromPath);
+            if (targetExists) {
+                skipping = true;
+                this.lastAcceptMore = true;
+                this.lastRetryAfterMs = 0;
+            }
+            else {
+                rootState.scanState.resumeFromPath = null;
+            }
+        }
+        for (const candidate of sorted) {
+            if (skipping) {
+                if (candidate.path === rootState.scanState.resumeFromPath) {
+                    skipping = false;
+                }
+                else {
+                    continue;
+                }
+            }
+            if (this.stopping) {
+                return;
+            }
+            if (!this.lastAcceptMore) {
+                if (!this.stopping) {
+                    rootState.scanState.resumeFromPath = candidate.path;
+                    this.scheduleRootScan(rootState, this.lastRetryAfterMs);
+                }
+                return;
+            }
+            if (this.lastWalCapacity > 0 && this.lastWalDepth > this.lastWalCapacity * 0.8) {
+                rootState.scanState.resumeFromPath = candidate.path;
+                if (!this.stopping) {
+                    this.scheduleRootScan(rootState, 2000);
+                }
+                return;
+            }
+            const estimatedTokens = estimateTokens(candidate.size);
+            if (estimatedTokens > this.maxTokensPerFile) {
+                stats.filesDeferred++;
+                continue;
+            }
             try {
-                const result = await this.syncMarkdownFile(rootState, child);
+                const result = await this.syncMarkdownFile(rootState, candidate.path, {
+                    size: candidate.size,
+                    mtimeMs: candidate.mtimeMs,
+                    ctimeMs: candidate.ctimeMs,
+                });
                 recordSyncResult(stats, result);
             }
             catch (error) {
                 stats.syncErrors++;
                 if (!this.stopping) {
-                    this.logger.warn?.(`[markdown-ingest] sync failed for ${child}: ${formatError(error)}`);
+                    this.logger.warn?.(`[markdown-ingest] sync failed for ${candidate.path}: ${formatError(error)}`);
                 }
             }
         }
+        rootState.scanState.resumeFromPath = null;
     }
     shouldPruneDirectory(root, dir) {
         const relative = toPosixPath(path.relative(root, dir));
@@ -284,6 +365,11 @@ class DirectoryMarkdownSourceAdapter {
         try {
             const watcher = this.fsApi.watch(dir, () => {
                 if (!this.stopping) {
+                    rootState.scanState.resumeFromPath = null;
+                    if (rootState.scanState.timer) {
+                        clearTimeout(rootState.scanState.timer);
+                        rootState.scanState.timer = null;
+                    }
                     this.scheduleRootScan(rootState);
                 }
             });
@@ -335,10 +421,10 @@ class DirectoryMarkdownSourceAdapter {
             stats.filesDeleted++;
         }
     }
-    async syncMarkdownFile(rootState, filePath) {
+    async syncMarkdownFile(rootState, filePath, initialStat) {
         const sourceDoc = filePath;
         const relativePath = toPosixPath(path.relative(rootState.root, filePath));
-        const stat = await this.safeStat(filePath);
+        const stat = initialStat ?? (await this.safeStatWithCtime(filePath));
         if (!stat) {
             await this.deleteSourceDocument(sourceDoc);
             this.fileStates.delete(sourceDoc);
@@ -349,14 +435,18 @@ class DirectoryMarkdownSourceAdapter {
         if (cached && cached.size === stat.size && cached.mtimeMs === stat.mtimeMs) {
             return "unchanged";
         }
-        const bytes = await this.safeReadFile(filePath);
-        if (!bytes) {
+        const maxBytes = this.maxTokensPerFile * 4 + 3;
+        const streamed = await this.safeReadFileStreamed(filePath, maxBytes);
+        if (streamed === "too_large") {
+            return "skipped";
+        }
+        if (!streamed) {
             await this.deleteSourceDocument(sourceDoc);
             this.fileStates.delete(sourceDoc);
             this.snapshotDirty = true;
             return "deleted";
         }
-        const fileHash = hashBytes(bytes);
+        const { text, fileHash } = streamed;
         if (cached && cached.fileHash === fileHash) {
             this.setFileState(sourceDoc, {
                 root: rootState.root,
@@ -368,14 +458,13 @@ class DirectoryMarkdownSourceAdapter {
             });
             return "unchanged";
         }
-        const text = textDecoder.decode(bytes);
         if (this.kind === "obsidian" && this.includePatterns.length === 0 && !looksLikeObsidianNote(filePath, text)) {
             await this.deleteSourceDocument(sourceDoc);
             this.fileStates.delete(sourceDoc);
             this.snapshotDirty = true;
             return "skipped";
         }
-        await this.ingestMarkdownDocument(sourceDoc, text, rootState.root, relativePath, fileHash, stat.size, stat.mtimeMs);
+        await this.ingestMarkdownDocument(sourceDoc, text, rootState.root, relativePath, fileHash, stat.size, stat.mtimeMs, stat.ctimeMs);
         this.setFileState(sourceDoc, {
             root: rootState.root,
             sourceDoc,
@@ -390,9 +479,9 @@ class DirectoryMarkdownSourceAdapter {
         this.fileStates.set(sourceDoc, state);
         this.snapshotDirty = true;
     }
-    async ingestMarkdownDocument(sourceDoc, text, sourceRoot, sourcePath, fileHash, sourceSize, sourceMtimeMs) {
+    async ingestMarkdownDocument(sourceDoc, text, sourceRoot, sourcePath, fileHash, sourceSize, sourceMtimeMs, sourceCtimeMs) {
         const queue = await this.getIngestQueue();
-        await queue.enqueueIngest(sourceDoc, text, {
+        const feedback = await queue.enqueueIngest(sourceDoc, text, {
             tokenizerId: this.tokenizerId,
             coreDoc: this.coreDoc,
             sourceMeta: {
@@ -402,10 +491,44 @@ class DirectoryMarkdownSourceAdapter {
                 fileHash,
                 sourceSize,
                 sourceMtimeMs: Math.trunc(sourceMtimeMs),
+                sourceCtimeMs: Math.trunc(sourceCtimeMs),
                 ingestVersion: MARKDOWN_INGEST_VERSION,
                 hashBackend: HASH_BACKEND,
             },
-        });
+        }, this.lastTokenBurstLimit);
+        this.applyIngestFeedback(feedback);
+    }
+    applyIngestFeedback(feedback) {
+        if (feedback && typeof feedback.acceptMore === "boolean") {
+            this.lastAcceptMore = feedback.acceptMore;
+            this.lastQueueDepth = feedback.queueDepth ?? 0;
+            this.lastQueueCapacity = feedback.queueCapacity ?? 0;
+            this.lastProcessingTimeUs = feedback.processingTimeUs ?? 0;
+            this.lastNodesAccepted = feedback.nodesAccepted ?? 0;
+            this.lastNodesRejected = feedback.nodesRejected ?? 0;
+            this.lastTokensIngested = feedback.tokensIngested ?? 0;
+            if (feedback.tokenBurstLimit && feedback.tokenBurstLimit > 0) {
+                this.lastTokenBurstLimit = feedback.tokenBurstLimit;
+            }
+            this.lastWalDepth = feedback.walDepth ?? 0;
+            this.lastWalCapacity = feedback.walCapacity ?? 0;
+            if (feedback.acceptMore) {
+                this.lastRetryAfterMs = 0;
+            }
+            else {
+                this.lastRetryAfterMs = feedback.retryAfterMs || 1000;
+            }
+        }
+        else {
+            this.lastAcceptMore = true;
+            this.lastRetryAfterMs = 0;
+            this.lastQueueDepth = 0;
+            this.lastQueueCapacity = 0;
+            this.lastProcessingTimeUs = 0;
+            this.lastNodesAccepted = 0;
+            this.lastNodesRejected = 0;
+            this.lastTokensIngested = 0;
+        }
     }
     async deleteSourceDocument(sourceDoc) {
         const queue = await this.getIngestQueue();
@@ -413,8 +536,42 @@ class DirectoryMarkdownSourceAdapter {
     }
     async getIngestQueue() {
         if (!this.ingestQueue) {
-            const rpc = await this.getRpc();
-            this.ingestQueue = new IngestQueue(rpc.call.bind(rpc), this.logger);
+            const client = await this.getClient();
+            this.ingestQueue = new IngestQueue((params) => client.ingestMarkdownDocument({
+                sourceDoc: params.sourceDoc,
+                text: params.text,
+                tokenizerId: params.tokenizerId,
+                coreDoc: params.coreDoc,
+                mode: params.mode,
+                sourceMeta: params.sourceMeta ? {
+                    sourceRoot: params.sourceMeta.sourceRoot,
+                    sourcePath: params.sourceMeta.sourcePath,
+                    sourceKind: params.sourceMeta.sourceKind,
+                    fileHash: params.sourceMeta.fileHash,
+                    sourceSize: BigInt(params.sourceMeta.sourceSize),
+                    sourceMtimeMs: BigInt(Math.trunc(params.sourceMeta.sourceMtimeMs)),
+                    sourceCtimeMs: BigInt(Math.trunc(params.sourceMeta.sourceCtimeMs)),
+                    ingestVersion: params.sourceMeta.ingestVersion,
+                    hashBackend: params.sourceMeta.hashBackend,
+                } : undefined,
+            }).then((r) => ({
+                ok: r.ok,
+                feedback: r.feedback ? {
+                    queueDepth: r.feedback.queueDepth,
+                    queueCapacity: r.feedback.queueCapacity,
+                    acceptMore: r.feedback.acceptMore,
+                    retryAfterMs: r.feedback.retryAfterMs,
+                    processingTimeUs: Number(r.feedback.processingTimeUs),
+                    nodesAccepted: r.feedback.nodesAccepted,
+                    nodesRejected: r.feedback.nodesRejected,
+                    tokensIngested: r.feedback.tokensIngested,
+                    tokenBurstLimit: r.feedback.tokenBurstLimit,
+                    walDepth: r.feedback.walDepth,
+                    walCapacity: r.feedback.walCapacity,
+                } : undefined,
+            })), (params) => client.deleteAuthoredDocument(params).then(() => undefined), this.logger, {
+                onChunkFeedback: (feedback) => this.applyIngestFeedback(feedback),
+            });
         }
         return this.ingestQueue;
     }
@@ -426,14 +583,51 @@ class DirectoryMarkdownSourceAdapter {
             return null;
         }
     }
-    async safeReadFile(filePath) {
+    async safeStatWithCtime(filePath) {
         try {
-            return await this.fsApi.readFile(filePath);
+            return await this.fsApi.stat(filePath);
         }
         catch {
             return null;
         }
     }
+    async safeReadFileStreamed(filePath, maxBytes) {
+        let stream = null;
+        try {
+            stream = await this.fsApi.openReadStream(filePath);
+            const decoder = new TextDecoder();
+            const chunks = [];
+            let hash = 0xcbf29ce484222325n;
+            let total = 0;
+            const buffer = Buffer.allocUnsafe(STREAM_CHUNK_BYTES);
+            while (true) {
+                const { bytesRead } = await stream.read(buffer);
+                if (bytesRead === 0) {
+                    break;
+                }
+                total += bytesRead;
+                if (total > maxBytes) {
+                    return "too_large";
+                }
+                const chunk = buffer.subarray(0, bytesRead);
+                hash = updateFnv1a64(hash, chunk);
+                chunks.push(decoder.decode(chunk, { stream: true }));
+            }
+            chunks.push(decoder.decode());
+            return {
+                text: chunks.join(""),
+                fileHash: hash.toString(16).padStart(16, "0"),
+            };
+        }
+        catch {
+            return null;
+        }
+        finally {
+            if (stream) {
+                await stream.close().catch(() => { });
+            }
+        }
+    }
     snapshotFilesForRoot(root) {
         const files = new Set();
         for (const state of this.fileStates.values()) {
@@ -497,7 +691,7 @@ class DirectoryMarkdownSourceAdapter {
         }
     }
     logScanStats(root, stats, durationMs) {
-        this.logger.info?.(`[markdown-ingest] ${this.kind} scan complete root=${root} dirs=${stats.directoriesScanned} prunedDirs=${stats.directoriesPruned} markdown=${stats.markdownFilesSeen} included=${stats.filesIncluded} skipped=${stats.filesSkipped} unchanged=${stats.filesUnchanged} ingested=${stats.filesIngested} deleted=${stats.filesDeleted} errors=${stats.syncErrors} durationMs=${durationMs}`);
+        this.logger.info?.(`[markdown-ingest] ${this.kind} scan complete root=${root} dirs=${stats.directoriesScanned} prunedDirs=${stats.directoriesPruned} markdown=${stats.markdownFilesSeen} included=${stats.filesIncluded} skipped=${stats.filesSkipped} unchanged=${stats.filesUnchanged} ingested=${stats.filesIngested} deleted=${stats.filesDeleted} deferred=${stats.filesDeferred} errors=${stats.syncErrors} durationMs=${durationMs}`);
     }
 }
 function createScanStats() {
@@ -511,8 +705,26 @@ function createScanStats() {
         filesIngested: 0,
         filesDeleted: 0,
         syncErrors: 0,
+        filesDeferred: 0,
     };
 }
+function estimateTokens(size) {
+    return Math.max(1, Math.floor(size / 4));
+}
+function sortCandidates(candidates, mode) {
+    return [...candidates].sort((left, right) => {
+        if (mode === "size") {
+            return right.size - left.size || left.ordinal - right.ordinal;
+        }
+        if (mode === "ctime") {
+            return right.ctimeMs - left.ctimeMs || left.ordinal - right.ordinal;
+        }
+        if (mode === "fifo") {
+            return left.ordinal - right.ordinal;
+        }
+        return right.mtimeMs - left.mtimeMs || left.ordinal - right.ordinal;
+    });
+}
 function recordSyncResult(stats, result) {
     if (result === "ingested") {
         stats.filesIngested++;
@@ -530,7 +742,6 @@ function recordSyncResult(stats, result) {
 function toPosixPath(value) {
     return value.split(path.sep).join("/");
 }
-const textDecoder = new TextDecoder();
 function normalizeMarkdownRoots(roots) {
     if (!roots?.length) {
         return [];
@@ -545,6 +756,15 @@ function normalizeMarkdownRoots(roots) {
     }
     return [...resolved];
 }
+function updateFnv1a64(seed, bytes) {
+    let hash = seed;
+    const prime = 0x100000001b3n;
+    for (let i = 0; i < bytes.length; i++) {
+        hash ^= BigInt(bytes[i] ?? 0);
+        hash = BigInt.asUintN(64, hash * prime);
+    }
+    return hash;
+}
 function resolveMarkdownSnapshotPath(kind, configuredPath) {
     const trimmed = configuredPath?.trim();
     if (trimmed) {
@@ -561,10 +781,22 @@ function createRealFsApi() {
         readdir: async (dir) => fsp.readdir(dir, { withFileTypes: true }),
         readFile: async (file) => fsp.readFile(file),
         stat: async (file) => {
-            const stat = await fsp.stat(file);
-            return { size: stat.size, mtimeMs: stat.mtimeMs };
+            const s = await fsp.stat(file);
+            return { size: s.size, mtimeMs: s.mtimeMs, ctimeMs: s.ctimeMs };
         },
         watch: (dir, onChange) => fs.watch(dir, onChange),
+        openReadStream: async (file) => {
+            const handle = await fsp.open(file, "r");
+            return {
+                read: async (buffer) => {
+                    const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+                    return { bytesRead };
+                },
+                close: async () => {
+                    await handle.close();
+                },
+            };
+        },
     };
 }
 function isMarkdownFile(fileName) {

package/dist/memory-provider.d.ts

@@ -1,4 +1,4 @@
 import type { MemoryPromptSectionBuilder } from "openclaw/plugin-sdk/plugin-entry";
 import type { PluginConfig } from "./types.js";
-import type { RpcGetter } from "./plugin-runtime.js";
-export declare function buildMemoryPromptSection(_getRpc: RpcGetter, _cfg: PluginConfig): MemoryPromptSectionBuilder;
+import type { ClientGetter } from "./plugin-runtime.js";
+export declare function buildMemoryPromptSection(_getClient: ClientGetter, _cfg: PluginConfig): MemoryPromptSectionBuilder;

package/dist/memory-provider.js

@@ -4,7 +4,7 @@ const MEMORY_PROMPT_HEADER = [
     "in context via the context-engine assembler when available and relevant.",
     "",
 ];
-export function buildMemoryPromptSection(_getRpc, _cfg) {
+export function buildMemoryPromptSection(_getClient, _cfg) {
     return function memoryPromptSection({ availableTools: _availableTools, citationsMode: _citationsMode, }) {
         // OpenClaw builds the memory prompt section synchronously for embedded runs.
         // Actual retrieval and ranking happen in the context engine during assemble().

package/dist/memory-runtime.d.ts

@@ -1,4 +1,4 @@
-import type { RpcGetter } from "./plugin-runtime.js";
+import type { ClientGetter } from "./plugin-runtime.js";
 import type { PluginConfig } from "./types.js";
 type MemorySearchParams = {
     query?: string;
@@ -30,7 +30,7 @@ type MemoryRuntimeStatus = {
     abstractiveReady?: boolean;
     embeddingProfile?: string;
 };
-export declare function buildMemoryRuntimeBridge(getRpc: RpcGetter, cfg: PluginConfig): {
+export declare function buildMemoryRuntimeBridge(getClient: ClientGetter, cfg: PluginConfig): {
     getMemorySearchManager(params?: {
         agentId?: string;
         purpose?: string;
@@ -53,37 +53,8 @@ export declare function buildMemoryRuntimeBridge(getRpc: RpcGetter, cfg: PluginC
                     id: string;
                     score: number;
                     text: string;
-                    metadata: {
-                        ts?: number;
-                        sessionId?: string;
-                        userId?: string;
-                        role?: string;
-                        source_doc?: string;
-                        node_kind?: string;
-                        ordinal?: number;
-                        position?: number;
-                        tier?: number;
-                        authored?: boolean;
-                        authority?: number;
-                        access_count?: number;
-                        collection?: string;
-                        hop_targets?: string[] | string;
-                        token_estimate?: number;
-                        continuity_tail?: boolean;
-                        continuity_base?: boolean;
-                        continuity_bundle_id?: string;
-                        elevated_guidance?: boolean;
-                        source_turn_id?: string;
-                        source_turn_ts?: number;
-                        provenance_class?: string;
-                        stability_weight?: number;
-                        expanded_from_summary?: boolean;
-                        parent_summary_id?: string;
-                        expansion_depth?: number;
-                        cascade_tier?: number;
-                        [key: string]: unknown;
-                    };
-                    finalScore?: number;
+                    metadataJson: Uint8Array<ArrayBuffer>;
+                    version: bigint;
                 }[];
                 error?: undefined;
             }>;