@xdarkicex/openclaw-memory-libravdb 1.5.5 → 1.6.1

package/dist/ingest-queue.d.ts

@@ -41,13 +41,20 @@ interface IngestFeedback {
     walDepth?: number;
     walCapacity?: number;
 }
+interface IngestMarkdownDocumentResponse {
+    ok: boolean;
+    feedback?: IngestFeedback;
+}
 export declare class IngestQueue {
     private readonly queue;
-    private readonly rpcCall;
+    private readonly ingestDocument;
+    private readonly deleteDocument;
     private readonly logger;
     private readonly options;
     private running;
-    constructor(rpcCall: <T>(method: string, params: unknown) => Promise<T>, logger: LoggerLike, options?: Partial<IngestQueueOptions>);
+    constructor(ingestDocument: (params: IngestMarkdownDocumentParams) => Promise<IngestMarkdownDocumentResponse>, deleteDocument: (params: {
+        sourceDoc: string;
+    }) => Promise<unknown>, logger: LoggerLike, options?: Partial<IngestQueueOptions>);
     enqueueIngest(sourceDoc: string, text: string, baseParams: Omit<IngestMarkdownDocumentParams, "sourceDoc" | "text" | "mode">, maxChunkTokens?: number): Promise<IngestFeedback | undefined>;
     private ingestWithRetry;
     enqueueDelete(sourceDoc: string): Promise<void>;

package/dist/ingest-queue.js

@@ -6,12 +6,14 @@ const DEFAULT_OPTIONS = {
 };
 export class IngestQueue {
     queue = [];
-    rpcCall;
+    ingestDocument;
+    deleteDocument;
     logger;
     options;
     running = false;
-    constructor(rpcCall, logger, options = {}) {
-        this.rpcCall = rpcCall;
+    constructor(ingestDocument, deleteDocument, logger, options = {}) {
+        this.ingestDocument = ingestDocument;
+        this.deleteDocument = deleteDocument;
         this.logger = logger;
         this.options = { ...DEFAULT_OPTIONS, ...options };
         if (!(this.options.chunkTokens > 0)) {
@@ -71,10 +73,16 @@ export class IngestQueue {
         return lastFeedback;
     }
     async ingestWithRetry(params) {
-        return withRetry(() => this.rpcCall("ingest_markdown_document", params), this.options.maxRetries, this.options.retryBaseDelayMs, this.logger, `ingest_markdown_document(${params.sourceDoc})`);
+        return withRetry(async () => {
+            const resp = await this.ingestDocument(params);
+            if (!resp.ok) {
+                throw new Error(`ingest_markdown_document(${params.sourceDoc}) mode=${params.mode} returned ok=false`);
+            }
+            return resp;
+        }, this.options.maxRetries, this.options.retryBaseDelayMs, this.logger, `ingest_markdown_document(${params.sourceDoc})`);
     }
     async enqueueDelete(sourceDoc) {
-        await withRetry(() => this.rpcCall("delete_authored_document", { sourceDoc }), this.options.maxRetries, this.options.retryBaseDelayMs, this.logger, `delete_authored_document(${sourceDoc})`);
+        await withRetry(() => this.deleteDocument({ sourceDoc }), this.options.maxRetries, this.options.retryBaseDelayMs, this.logger, `delete_authored_document(${sourceDoc})`);
     }
 }
 function splitIntoChunks(text, maxTokens) {

package/dist/libravdb-client.d.ts

@@ -0,0 +1,59 @@
+import type { Interceptor } from "@connectrpc/connect";
+import type { PartialMessage } from "@bufbuild/protobuf";
+import type { AfterTurnKernelRequest, AfterTurnKernelResponse, AssembleContextInternalRequest, AssembleContextInternalResponse, BootstrapSessionKernelRequest, BootstrapSessionKernelResponse, CompactSessionRequest, CompactSessionResponse, DeleteAuthoredDocumentRequest, DeleteAuthoredDocumentResponse, DreamPromotionResponse, ExportMemoryRequest, ExportMemoryResponse, FlushNamespaceRequest, FlushNamespaceResponse, FlushRequest, FlushResponse, HealthRequest, HealthResponse, IngestMarkdownDocumentRequest, IngestMarkdownDocumentResponse, IngestMessageKernelRequest, IngestMessageKernelResponse, ListCollectionRequest, ListCollectionResponse, ListLifecycleJournalRequest, ListLifecycleJournalResponse, MarkMemorySupersededRequest, MarkMemorySupersededResponse, MemoryStatusRequest, MemoryStatusResponse, PromoteDreamEntriesRequest, RankCandidatesRequest, RankCandidatesResponse, RebuildIndexRequest, RebuildIndexResponse, ReindexAuthoredDocumentRequest, ReindexAuthoredDocumentResponse, SearchTextCollectionsRequest, SearchTextRequest, SearchTextResponse, SessionLifecycleHintRequest, SessionLifecycleHintResponse } from "@xdarkicex/libravdb-contracts";
+export interface LibravDBClientOptions {
+    endpoint?: string;
+    secret?: string;
+    timeoutMs?: number;
+    tlsCaPath?: string;
+    tlsMode?: "auto" | "tls" | "insecure";
+    tlsClientCertPath?: string;
+    tlsClientKeyPath?: string;
+}
+export declare function resolveClientEndpoint(configuredEndpoint?: string): string;
+interface RpcMutex {
+    current: Promise<void>;
+    lock(): Promise<() => void>;
+}
+export interface AuthInterceptorState {
+    readonly secret: string | undefined;
+    nonceHex: string | undefined;
+    bootstrap(): Promise<void>;
+    readonly rpcMutex: RpcMutex;
+}
+export declare function createAuthInterceptor(state: AuthInterceptorState): Interceptor;
+export declare class LibravDBClient {
+    private client;
+    private readonly secret;
+    private nonceHex;
+    private closed;
+    constructor(options?: LibravDBClientOptions);
+    bootstrapHandshake(): Promise<void>;
+    private guardOpen;
+    health(req?: PartialMessage<HealthRequest>): Promise<HealthResponse>;
+    status(req?: PartialMessage<MemoryStatusRequest>): Promise<MemoryStatusResponse>;
+    flush(req?: PartialMessage<FlushRequest>): Promise<FlushResponse>;
+    sessionLifecycleHint(req: PartialMessage<SessionLifecycleHintRequest>): Promise<SessionLifecycleHintResponse>;
+    listLifecycleJournal(req: PartialMessage<ListLifecycleJournalRequest>): Promise<ListLifecycleJournalResponse>;
+    ingestMarkdownDocument(req: PartialMessage<IngestMarkdownDocumentRequest>): Promise<IngestMarkdownDocumentResponse>;
+    promoteDreamEntries(req: PartialMessage<PromoteDreamEntriesRequest>): Promise<DreamPromotionResponse>;
+    reindexAuthoredDocument(req: PartialMessage<ReindexAuthoredDocumentRequest>): Promise<ReindexAuthoredDocumentResponse>;
+    deleteAuthoredDocument(req: PartialMessage<DeleteAuthoredDocumentRequest>): Promise<DeleteAuthoredDocumentResponse>;
+    markMemorySuperseded(req: PartialMessage<MarkMemorySupersededRequest>): Promise<MarkMemorySupersededResponse>;
+    searchText(req: PartialMessage<SearchTextRequest>): Promise<SearchTextResponse>;
+    searchTextCollections(req: PartialMessage<SearchTextCollectionsRequest>): Promise<SearchTextResponse>;
+    listCollection(req: PartialMessage<ListCollectionRequest>): Promise<ListCollectionResponse>;
+    exportMemory(req: PartialMessage<ExportMemoryRequest>): Promise<ExportMemoryResponse>;
+    flushNamespace(req: PartialMessage<FlushNamespaceRequest>): Promise<FlushNamespaceResponse>;
+    rebuildIndex(req: PartialMessage<RebuildIndexRequest>, opts?: {
+        timeoutMs?: number;
+    }): Promise<RebuildIndexResponse>;
+    bootstrapSessionKernel(req: PartialMessage<BootstrapSessionKernelRequest>): Promise<BootstrapSessionKernelResponse>;
+    ingestMessageKernel(req: PartialMessage<IngestMessageKernelRequest>): Promise<IngestMessageKernelResponse>;
+    afterTurnKernel(req: PartialMessage<AfterTurnKernelRequest>): Promise<AfterTurnKernelResponse>;
+    assembleContextInternal(req: PartialMessage<AssembleContextInternalRequest>): Promise<AssembleContextInternalResponse>;
+    compactSession(req: PartialMessage<CompactSessionRequest>): Promise<CompactSessionResponse>;
+    rankCandidates(req: PartialMessage<RankCandidatesRequest>): Promise<RankCandidatesResponse>;
+    close(): void;
+}
+export {};

package/dist/libravdb-client.js

@@ -0,0 +1,296 @@
+import { createPromiseClient } from "@connectrpc/connect";
+import { createGrpcTransport } from "@connectrpc/connect-node";
+import { LibravDB } from "@xdarkicex/libravdb-contracts/client";
+import { createHmac } from "node:crypto";
+import fs from "node:fs";
+import net from "node:net";
+import os from "node:os";
+import path from "node:path";
+export function resolveClientEndpoint(configuredEndpoint) {
+    if (configuredEndpoint && configuredEndpoint !== "auto")
+        return configuredEndpoint;
+    if (process.env.LIBRAVDB_GRPC_ENDPOINT)
+        return process.env.LIBRAVDB_GRPC_ENDPOINT;
+    if (process.platform === "win32")
+        return "tcp:127.0.0.1:37421";
+    const sockName = "libravdb.sock";
+    const candidateDirs = [
+        path.join(os.homedir(), ".libravdbd", "run"),
+        "/opt/homebrew/var/libravdbd/run",
+        "/usr/local/var/libravdbd/run",
+    ];
+    for (const dir of candidateDirs) {
+        const fullPath = path.join(dir, sockName);
+        if (fs.existsSync(fullPath))
+            return `unix:${fullPath}`;
+    }
+    return `unix:${path.join(os.homedir(), ".libravdbd", "run", sockName)}`;
+}
+function createRpcMutex() {
+    return {
+        current: Promise.resolve(),
+        async lock() {
+            let release;
+            const p = new Promise(r => release = r);
+            const prev = this.current;
+            this.current = prev.then(() => p);
+            await prev;
+            return release;
+        }
+    };
+}
+export function createAuthInterceptor(state) {
+    return (next) => async (req) => {
+        // Health does not participate in the nonce chain — bypass the
+        // mutex entirely so recovery can call Health without deadlocking.
+        if (req.method.name === "Health") {
+            return next(req);
+        }
+        const release = await state.rpcMutex.lock();
+        try {
+            // Lost the nonce? Recover inside the lock so queued requests
+            // wait for the chain to be restored instead of failing spuriously.
+            if (state.secret && !state.nonceHex) {
+                await state.bootstrap();
+                if (!state.nonceHex) {
+                    throw new Error("LibraVDB: bootstrap handshake did not return a nonce");
+                }
+            }
+            if (state.secret && state.nonceHex) {
+                const hmac = createHmac("sha256", state.secret);
+                hmac.update(state.nonceHex);
+                req.header.set("x-libravdb-nonce", state.nonceHex);
+                req.header.set("x-libravdb-auth", hmac.digest("hex"));
+            }
+            let res;
+            try {
+                res = await next(req);
+            }
+            catch (error) {
+                if (state.secret && state.nonceHex) {
+                    state.nonceHex = undefined;
+                }
+                throw error;
+            }
+            if (state.secret) {
+                const nextNonce = res.header.get("x-libravdb-nonce") || res.trailer.get("x-libravdb-nonce");
+                if (nextNonce) {
+                    state.nonceHex = nextNonce;
+                }
+                else {
+                    state.nonceHex = undefined;
+                }
+            }
+            return res;
+        }
+        finally {
+            release();
+        }
+    };
+}
+export class LibravDBClient {
+    client;
+    secret;
+    nonceHex;
+    closed = false;
+    constructor(options = {}) {
+        this.secret = options.secret ?? loadSecretFromEnv();
+        const rawEndpoint = resolveClientEndpoint(options.endpoint);
+        const isUnix = rawEndpoint.startsWith("unix:");
+        const socketPath = isUnix ? rawEndpoint.slice(5) : undefined;
+        const credMode = resolveCredentialMode(rawEndpoint, options.tlsMode);
+        const isInsecure = isUnix || credMode === "insecure";
+        const targetUrl = isUnix
+            ? "http://localhost"
+            : rawEndpoint.replace(/^tcp:/, isInsecure ? "http://" : "https://");
+        let rootCerts = null;
+        let clientKey = null;
+        let clientCert = null;
+        if (!isInsecure && options.tlsCaPath) {
+            rootCerts = fs.readFileSync(options.tlsCaPath);
+        }
+        if (options.tlsClientCertPath && options.tlsClientKeyPath) {
+            clientCert = fs.readFileSync(options.tlsClientCertPath);
+            clientKey = fs.readFileSync(options.tlsClientKeyPath);
+        }
+        const rpcMutex = createRpcMutex();
+        const self = this;
+        const authInterceptor = createAuthInterceptor({
+            secret: this.secret,
+            get nonceHex() { return self.nonceHex; },
+            set nonceHex(v) { self.nonceHex = v; },
+            bootstrap: () => self.bootstrapHandshake(),
+            rpcMutex,
+        });
+        const transport = createGrpcTransport({
+            baseUrl: targetUrl,
+            httpVersion: "2",
+            nodeOptions: isUnix
+                ? { createConnection: () => net.connect(socketPath) }
+                : {
+                    ...(rootCerts ? { ca: rootCerts } : {}),
+                    ...(clientKey ? { key: clientKey } : {}),
+                    ...(clientCert ? { cert: clientCert } : {}),
+                    ...(isInsecure ? { rejectUnauthorized: false } : {}),
+                },
+            defaultTimeoutMs: options.timeoutMs ?? 30000,
+            interceptors: [authInterceptor],
+        });
+        this.client = createPromiseClient(LibravDB, transport);
+    }
+    async bootstrapHandshake() {
+        this.guardOpen();
+        try {
+            await this.client.health({ service: "" }, {
+                onHeader: (headers) => {
+                    const nonce = headers.get("x-libravdb-nonce");
+                    if (nonce)
+                        this.nonceHex = nonce;
+                },
+            });
+        }
+        catch (error) {
+            throw new Error(`LibraVDB: failed to handshake with daemon: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    guardOpen() {
+        if (this.closed) {
+            throw new Error("LibravDB client is closed");
+        }
+    }
+    // ── Session lifecycle ────────────────────────────────────────────
+    async health(req = {}) {
+        this.guardOpen();
+        return this.client.health(req);
+    }
+    async status(req = {}) {
+        this.guardOpen();
+        return this.client.status(req);
+    }
+    async flush(req = {}) {
+        this.guardOpen();
+        return this.client.flush(req);
+    }
+    async sessionLifecycleHint(req) {
+        this.guardOpen();
+        return this.client.sessionLifecycleHint(req);
+    }
+    async listLifecycleJournal(req) {
+        this.guardOpen();
+        return this.client.listLifecycleJournal(req);
+    }
+    // ── Ingest ───────────────────────────────────────────────────────
+    async ingestMarkdownDocument(req) {
+        this.guardOpen();
+        return this.client.ingestMarkdownDocument(req);
+    }
+    async promoteDreamEntries(req) {
+        this.guardOpen();
+        return this.client.promoteDreamEntries(req);
+    }
+    async reindexAuthoredDocument(req) {
+        this.guardOpen();
+        return this.client.reindexAuthoredDocument(req);
+    }
+    async deleteAuthoredDocument(req) {
+        this.guardOpen();
+        return this.client.deleteAuthoredDocument(req);
+    }
+    async markMemorySuperseded(req) {
+        this.guardOpen();
+        return this.client.markMemorySuperseded(req);
+    }
+    // ── Search / query ───────────────────────────────────────────────
+    async searchText(req) {
+        this.guardOpen();
+        return this.client.searchText(req);
+    }
+    async searchTextCollections(req) {
+        this.guardOpen();
+        return this.client.searchTextCollections(req);
+    }
+    async listCollection(req) {
+        this.guardOpen();
+        return this.client.listCollection(req);
+    }
+    // ── Memory ───────────────────────────────────────────────────────
+    async exportMemory(req) {
+        this.guardOpen();
+        return this.client.exportMemory(req);
+    }
+    async flushNamespace(req) {
+        this.guardOpen();
+        return this.client.flushNamespace(req);
+    }
+    // ── Index ────────────────────────────────────────────────────────
+    async rebuildIndex(req, opts) {
+        this.guardOpen();
+        return this.client.rebuildIndex(req, opts);
+    }
+    // ── Kernel ───────────────────────────────────────────────────────
+    async bootstrapSessionKernel(req) {
+        this.guardOpen();
+        return this.client.bootstrapSessionKernel(req);
+    }
+    async ingestMessageKernel(req) {
+        this.guardOpen();
+        return this.client.ingestMessageKernel(req);
+    }
+    async afterTurnKernel(req) {
+        this.guardOpen();
+        return this.client.afterTurnKernel(req);
+    }
+    async assembleContextInternal(req) {
+        this.guardOpen();
+        return this.client.assembleContextInternal(req);
+    }
+    async compactSession(req) {
+        this.guardOpen();
+        return this.client.compactSession(req);
+    }
+    async rankCandidates(req) {
+        this.guardOpen();
+        return this.client.rankCandidates(req);
+    }
+    close() {
+        this.closed = true;
+    }
+}
+function resolveCredentialMode(endpoint, tlsMode) {
+    if (tlsMode === "tls")
+        return "tls";
+    if (tlsMode === "insecure")
+        return "insecure";
+    const target = endpoint.startsWith("tcp:") ? endpoint.slice(4) : endpoint;
+    if (target.startsWith("unix:"))
+        return "insecure";
+    const host = extractHost(target);
+    const normalized = host.toLowerCase();
+    return normalized === "localhost" || normalized === "127.0.0.1" || normalized === "::1"
+        ? "insecure"
+        : "tls";
+}
+function extractHost(target) {
+    const withoutDns = target.startsWith("dns:///") ? target.slice("dns:///".length) : target;
+    if (withoutDns.startsWith("[")) {
+        const close = withoutDns.indexOf("]");
+        return close > 0 ? withoutDns.slice(1, close) : withoutDns;
+    }
+    const sep = withoutDns.lastIndexOf(":");
+    return sep > 0 ? withoutDns.slice(0, sep) : withoutDns;
+}
+function loadSecretFromEnv() {
+    const secret = process.env.LIBRAVDB_AUTH_SECRET;
+    if (secret)
+        return secret;
+    const secretPath = process.env.LIBRAVDB_AUTH_SECRET_FILE;
+    if (secretPath) {
+        try {
+            return fs.readFileSync(secretPath, "utf8").trim();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}

package/dist/markdown-ingest.d.ts

@@ -1,11 +1,8 @@
 import type { LoggerLike, PluginConfig } from "./types.js";
+import type { ClientGetter } from "./plugin-runtime.js";
 type Disposable = {
     close(): void;
 };
-interface RpcLike {
-    call<T>(method: string, params: unknown): Promise<T>;
-}
-type RpcGetterLike = () => Promise<RpcLike>;
 interface FsDirentLike {
     name: string;
     isDirectory(): boolean;
@@ -47,5 +44,5 @@ export interface MarkdownIngestionSnapshot {
     size: number;
     mtimeMs: number;
 }
-export declare function createMarkdownIngestionHandle(cfg: PluginConfig, getRpc: RpcGetterLike, logger?: LoggerLike, fsApi?: FsApi): MarkdownIngestionHandle;
+export declare function createMarkdownIngestionHandle(cfg: PluginConfig, getClient: ClientGetter, logger?: LoggerLike, fsApi?: FsApi): MarkdownIngestionHandle;
 export {};

package/dist/markdown-ingest.js

@@ -9,7 +9,7 @@ const DEFAULT_TOKENIZER_ID = "markdown-ingest:v1";
 const MARKDOWN_INGEST_VERSION = 3;
 const HASH_BACKEND = "wasm-fnv1a64";
 const STREAM_CHUNK_BYTES = 64 * 1024;
-export function createMarkdownIngestionHandle(cfg, getRpc, logger = console, fsApi = createRealFsApi()) {
+export function createMarkdownIngestionHandle(cfg, getClient, logger = console, fsApi = createRealFsApi()) {
     const adapters = [];
     const genericRoots = normalizeMarkdownRoots(cfg.markdownIngestionRoots);
     if (isMarkdownIngestionEnabled(cfg, genericRoots)) {
@@ -21,7 +21,7 @@ export function createMarkdownIngestionHandle(cfg, getRpc, logger = console, fsA
             snapshotPath: resolveMarkdownSnapshotPath("generic", cfg.markdownIngestionSnapshotPath),
             priorityMode: cfg.markdownIngestionPriorityMode,
             maxTokensPerFile: cfg.markdownIngestionMaxTokensPerFile,
-        }, getRpc, logger, fsApi));
+        }, getClient, logger, fsApi));
     }
     const obsidianRoots = normalizeMarkdownRoots(cfg.markdownIngestionObsidianRoots);
     if (cfg.markdownIngestionObsidianEnabled === true && obsidianRoots.length > 0) {
@@ -33,7 +33,7 @@ export function createMarkdownIngestionHandle(cfg, getRpc, logger = console, fsA
             snapshotPath: resolveMarkdownSnapshotPath("obsidian", cfg.markdownIngestionObsidianSnapshotPath),
             priorityMode: cfg.markdownIngestionPriorityMode,
             maxTokensPerFile: cfg.markdownIngestionMaxTokensPerFile,
-        }, getRpc, logger, fsApi));
+        }, getClient, logger, fsApi));
     }
     if (adapters.length === 0) {
         return {
@@ -78,7 +78,7 @@ class DirectoryMarkdownSourceAdapter {
     excludePatterns;
     debounceMs;
     fsApi;
-    getRpc;
+    getClient;
     logger;
     snapshotPath;
     priorityMode;
@@ -104,14 +104,14 @@ class DirectoryMarkdownSourceAdapter {
     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";
@@ -536,8 +536,40 @@ 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),
             });
         }

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;
             }>;