memwarden 0.0.1

package/dist/functions/quantized-vector-index.js

@@ -0,0 +1,275 @@
+//
+// TurboQuant-backed vector index with VectorIndex API parity. Stores packed
+// 2/4-bit codes + a per-vector norm instead of full Float32 embeddings
+// (~8-16x smaller). Search is asymmetric: the query stays full precision.
+// When `rescoreDepth > 0` the full vectors are retained too and the top
+// candidates are re-ranked with exact cosine (best recall, no memory
+// saving); with rescoreDepth 0 only codes are kept (max compression).
+//
+// Drop-in for the VectorIndexLike surface consumed by search.ts and
+// hybrid-search.ts. Default OFF: constructed only when
+// MEMWARDEN_QUANT_VECTOR=true (see makeVectorIndex in search.ts).
+import { TURBOQUANT_VERSION, ROTATION_ROUNDS, nextPow2, seedFromString, mulberry32, buildSignFlips, rotate, lloydMaxLevels, levelTableHash, encodeRotated, asymmetricDot, } from "./turboquant.js";
+// Same byteOffset/byteLength-guarded base64 round-trip as vector-index.ts,
+// duplicated on purpose for Uint8Array: the helpers in vector-index.ts are
+// load-bearing bug fixes (#455/#469/#584/#587) and stay untouched there.
+function uint8ToBase64(arr) {
+    return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).toString("base64");
+}
+function base64ToUint8(b64) {
+    const buf = Buffer.from(b64, "base64");
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+}
+function float32ToBase64(arr) {
+    return Buffer.from(arr.buffer, arr.byteOffset, arr.byteLength).toString("base64");
+}
+function base64ToFloat32(b64) {
+    const buf = Buffer.from(b64, "base64");
+    return new Float32Array(buf.buffer, buf.byteOffset, buf.byteLength / Float32Array.BYTES_PER_ELEMENT);
+}
+function cosineSimilarity(a, b) {
+    if (a.length !== b.length)
+        return 0;
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        const ai = a[i];
+        const bi = b[i];
+        dot += ai * bi;
+        normA += ai * ai;
+        normB += bi * bi;
+    }
+    const denom = Math.sqrt(normA) * Math.sqrt(normB);
+    return denom === 0 ? 0 : dot / denom;
+}
+export class QuantizedVectorIndex {
+    params;
+    vectors = new Map();
+    signFlips;
+    scratch;
+    queryScratch;
+    constructor(opts) {
+        const paddedDims = nextPow2(opts.dims);
+        this.params = {
+            version: TURBOQUANT_VERSION,
+            bits: opts.bits,
+            dims: opts.dims,
+            paddedDims,
+            seed: opts.seed,
+            rounds: ROTATION_ROUNDS,
+            levelHash: levelTableHash(opts.bits),
+            rescoreDepth: Math.max(0, Math.floor(opts.rescoreDepth)),
+        };
+        this.signFlips = buildSignFlips(mulberry32(seedFromString(opts.seed)), paddedDims, ROTATION_ROUNDS);
+        this.scratch = new Float32Array(paddedDims);
+        this.queryScratch = new Float32Array(paddedDims);
+        // Warm the level table so first add/search doesn't pay the Lloyd cost.
+        lloydMaxLevels(opts.bits);
+    }
+    add(obsId, sessionId, embedding) {
+        if (embedding.length !== this.params.dims)
+            return; // soft-skip, guarded upstream
+        const rotated = rotate(embedding, this.params.paddedDims, this.signFlips, this.scratch);
+        const { codes, norm } = encodeRotated(rotated, this.params.paddedDims, this.params.bits);
+        const entry = { codes, norm, sessionId };
+        if (this.params.rescoreDepth > 0) {
+            entry.full = new Float32Array(embedding);
+        }
+        this.vectors.set(obsId, entry);
+    }
+    remove(obsId) {
+        this.vectors.delete(obsId);
+    }
+    has(obsId) {
+        return this.vectors.has(obsId);
+    }
+    ids() {
+        return Array.from(this.vectors.keys());
+    }
+    /**
+     * Aligns the rescore setting with the current configuration after a
+     * restore: the persisted blob carries the rescoreDepth it was built
+     * with, which may no longer match the environment. Lowering to 0 drops
+     * the retained full vectors (reclaiming memory); raising it keeps
+     * working with whatever full vectors the blob had (entries without one
+     * simply keep their asymmetric score — the rescore pass guards on
+     * presence).
+     */
+    reconcileRescoreDepth(depth) {
+        const clamped = Math.max(0, Math.floor(depth));
+        if (clamped === this.params.rescoreDepth)
+            return;
+        this.params.rescoreDepth = clamped;
+        if (clamped === 0) {
+            for (const entry of this.vectors.values()) {
+                delete entry.full;
+            }
+        }
+    }
+    search(query, limit = 20) {
+        if (query.length !== this.params.dims || this.vectors.size === 0) {
+            return [];
+        }
+        const D = this.params.paddedDims;
+        // Dedicated query scratch: search is synchronous, so nothing else can
+        // touch it before the scan below completes; `this.scratch` stays
+        // reserved for add().
+        const rotatedQuery = rotate(query, D, this.signFlips, this.queryScratch);
+        const table = lloydMaxLevels(this.params.bits); // hoisted out of the scan
+        let qNormSq = 0;
+        for (let i = 0; i < D; i++) {
+            const v = rotatedQuery[i];
+            qNormSq += v * v;
+        }
+        const qNorm = Math.sqrt(qNormSq);
+        if (qNorm === 0)
+            return [];
+        const invScale = 1 / (Math.sqrt(D) * qNorm);
+        // First pass: asymmetric scores with the same bounded top-K pattern as
+        // VectorIndex.search. Pool size widens to rescoreDepth when rescoring.
+        const poolSize = Math.max(limit, this.params.rescoreDepth);
+        const results = [];
+        let minScore = -Infinity;
+        for (const [obsId, entry] of this.vectors) {
+            const score = entry.norm === 0
+                ? 0
+                : asymmetricDot(rotatedQuery, entry.codes, D, this.params.bits, table) *
+                    invScale;
+            if (results.length < poolSize) {
+                results.push({ obsId, sessionId: entry.sessionId, score });
+                if (results.length === poolSize) {
+                    results.sort((a, b) => a.score - b.score);
+                    minScore = results[0].score;
+                }
+            }
+            else if (score > minScore) {
+                results[0] = { obsId, sessionId: entry.sessionId, score };
+                results.sort((a, b) => a.score - b.score);
+                minScore = results[0].score;
+            }
+        }
+        // Optional second pass: exact cosine on the retained full vectors.
+        if (this.params.rescoreDepth > 0) {
+            for (const r of results) {
+                const full = this.vectors.get(r.obsId)?.full;
+                if (full)
+                    r.score = cosineSimilarity(query, full);
+            }
+        }
+        results.sort((a, b) => b.score - a.score);
+        return results.slice(0, limit);
+    }
+    get size() {
+        return this.vectors.size;
+    }
+    validateDimensions(expected) {
+        const mismatches = [];
+        const seenDimensions = new Set();
+        if (this.vectors.size > 0) {
+            seenDimensions.add(this.params.dims);
+            if (this.params.dims !== expected) {
+                for (const obsId of this.vectors.keys()) {
+                    mismatches.push({ obsId, dim: this.params.dims });
+                }
+            }
+        }
+        return { mismatches, seenDimensions };
+    }
+    clear() {
+        this.vectors.clear();
+    }
+    restoreFrom(other) {
+        this.vectors = new Map();
+        for (const [obsId, entry] of other.vectors) {
+            const copy = {
+                codes: new Uint8Array(entry.codes),
+                norm: entry.norm,
+                sessionId: entry.sessionId,
+            };
+            if (entry.full)
+                copy.full = new Float32Array(entry.full);
+            this.vectors.set(obsId, copy);
+        }
+    }
+    serialize() {
+        const vectors = [];
+        for (const [obsId, entry] of this.vectors) {
+            const row = {
+                c: uint8ToBase64(entry.codes),
+                n: entry.norm,
+                s: entry.sessionId,
+            };
+            if (entry.full)
+                row.f = float32ToBase64(entry.full);
+            vectors.push([obsId, row]);
+        }
+        return JSON.stringify({ params: this.params, vectors });
+    }
+    /**
+     * Returns null when the payload's params don't reproduce the current
+     * algorithm (version, bits, seed, dims, rounds or level-table hash
+     * mismatch) — the caller is expected to fall back to a full rebuild.
+     */
+    static deserialize(json) {
+        let data;
+        try {
+            data = JSON.parse(json);
+        }
+        catch {
+            return null;
+        }
+        const obj = data;
+        const p = obj?.params;
+        if (!p ||
+            p.version !== TURBOQUANT_VERSION ||
+            (p.bits !== 2 && p.bits !== 4) ||
+            typeof p.dims !== "number" ||
+            typeof p.paddedDims !== "number" ||
+            typeof p.seed !== "string" ||
+            p.rounds !== ROTATION_ROUNDS ||
+            p.paddedDims !== nextPow2(p.dims) ||
+            p.levelHash !== levelTableHash(p.bits)) {
+            return null;
+        }
+        const idx = new QuantizedVectorIndex({
+            dims: p.dims,
+            bits: p.bits,
+            seed: p.seed,
+            rescoreDepth: typeof p.rescoreDepth === "number" ? p.rescoreDepth : 0,
+        });
+        if (!Array.isArray(obj.vectors))
+            return idx;
+        const codesLen = p.bits === 4 ? Math.ceil(p.paddedDims / 2) : Math.ceil(p.paddedDims / 4);
+        for (const row of obj.vectors) {
+            try {
+                if (!Array.isArray(row) || row.length < 2)
+                    continue;
+                const [obsId, entry] = row;
+                if (typeof obsId !== "string" ||
+                    typeof entry?.c !== "string" ||
+                    typeof entry?.n !== "number" ||
+                    typeof entry?.s !== "string")
+                    continue;
+                const codes = base64ToUint8(entry.c);
+                if (codes.length !== codesLen)
+                    continue;
+                const stored = {
+                    codes,
+                    norm: entry.n,
+                    sessionId: entry.s,
+                };
+                if (typeof entry.f === "string") {
+                    const full = base64ToFloat32(entry.f);
+                    if (full.length === p.dims)
+                        stored.full = full;
+                }
+                idx.vectors.set(obsId, stored);
+            }
+            catch {
+                continue;
+            }
+        }
+        return idx;
+    }
+}

package/dist/functions/receipt.d.ts

@@ -0,0 +1,31 @@
+import type { ISdk } from "../kernel/index.js";
+import type { StateKV } from "../state/kv.js";
+interface ChainEntry {
+    id: number;
+    ts: string;
+    op: string;
+    scope: string;
+    key: string;
+    hash: string;
+    prev_hash: string;
+}
+export interface DeleteReceipt {
+    obsId: string;
+    title: string;
+    deletedAt: string;
+    /** The oplog entry that recorded this deletion. */
+    deleteEntry: ChainEntry | null;
+    /** The oplog entry that recorded the original write, when still present. */
+    createEntry: ChainEntry | null;
+    /** Whole-chain verification at receipt time. */
+    chainIntact: boolean;
+    /** SHA-256 over the canonical receipt fields above — offline-checkable. */
+    receiptHash: string;
+}
+export interface ForgetResult {
+    deleted: boolean;
+    reason?: string;
+    receipt?: DeleteReceipt;
+}
+export declare function registerReceiptFunction(sdk: ISdk, kv: StateKV): void;
+export {};

package/dist/functions/receipt.js

@@ -0,0 +1,95 @@
+//
+// mem::forget — user-initiated deletion with a RECEIPT. The pain this
+// answers is real and documented across competitor trackers: deletes that
+// return success while the data stays on disk, with no way to prove
+// otherwise. memwarden's delete is verifiable two ways:
+//
+//   1. The observation is removed from KV and every index in lockstep, and
+//      the response reports what was actually removed (deleted: false when
+//      the id wasn't found — never a fake success).
+//   2. The deletion lands in the hash-chained oplog like every mutation, so
+//      the receipt cites the chain: the entry that recorded the delete, the
+//      entry that recorded the original write, and whether the whole chain
+//      verifies. Anyone with the store can recompute both hashes. Payloads
+//      are never included — a receipt proves the delete without
+//      re-disclosing what was deleted.
+//
+// The receipt's own hash covers its fields, so a receipt file can be
+// checked for integrity on its own, offline.
+import { createHash } from "node:crypto";
+import { KV } from "../state/schema.js";
+import { getSearchIndex, vectorIndexRemove } from "./search.js";
+import { deleteAccessLog } from "./access-tracker.js";
+import { logger } from "./logger.js";
+function receiptHash(fields) {
+    // Stable key order via explicit construction — this is the contract a
+    // receipt verifier recomputes.
+    const canonical = JSON.stringify({
+        obsId: fields.obsId,
+        title: fields.title,
+        deletedAt: fields.deletedAt,
+        deleteEntry: fields.deleteEntry,
+        createEntry: fields.createEntry,
+        chainIntact: fields.chainIntact,
+    });
+    return createHash("sha256").update(canonical).digest("hex");
+}
+export function registerReceiptFunction(sdk, kv) {
+    sdk.registerFunction("mem::forget", async (data) => {
+        const obsId = (data?.observationId ?? "").trim();
+        if (!obsId)
+            return { deleted: false, reason: "observationId is required" };
+        // Find the session holding this observation (ids are globally unique;
+        // storage is scoped per session).
+        let sessions;
+        try {
+            sessions = await kv.list(KV.sessions);
+        }
+        catch {
+            return { deleted: false, reason: "store unavailable" };
+        }
+        let found;
+        for (const session of sessions) {
+            const obs = await kv
+                .get(KV.observations(session.id), obsId)
+                .catch(() => null);
+            if (obs) {
+                found = { sessionId: session.id, obs };
+                break;
+            }
+        }
+        if (!found) {
+            // The honest failure: nothing pretended, nothing "succeeded".
+            return { deleted: false, reason: `no observation with id ${obsId}` };
+        }
+        // Remove from KV and every index in lockstep (same discipline as the
+        // auto-forget sweep).
+        await kv.delete(KV.observations(found.sessionId), obsId);
+        getSearchIndex().remove(obsId);
+        vectorIndexRemove(obsId);
+        await deleteAccessLog(kv, obsId);
+        // Build the receipt from the chain.
+        const { entries } = await sdk.trigger({
+            function_id: "state::oplog-find",
+            payload: { key: obsId },
+        });
+        const deleteEntry = [...entries].reverse().find((e) => e.op === "delete") ?? null;
+        const createEntry = entries.find((e) => e.op !== "delete") ?? null;
+        const verdict = await sdk.trigger({ function_id: "state::verify", payload: {} });
+        const base = {
+            obsId,
+            title: found.obs.title ?? "(untitled)",
+            deletedAt: deleteEntry?.ts ?? new Date().toISOString(),
+            deleteEntry,
+            createEntry,
+            chainIntact: verdict.ok === true,
+        };
+        const receipt = { ...base, receiptHash: receiptHash(base) };
+        logger.info("memory forgotten with receipt", {
+            obsId,
+            oplogDeleteId: deleteEntry?.id,
+            chainIntact: receipt.chainIntact,
+        });
+        return { deleted: true, receipt };
+    });
+}

package/dist/functions/search-index.d.ts

@@ -0,0 +1,27 @@
+import type { CompressedObservation } from "./types.js";
+export interface Bm25Hit {
+    obsId: string;
+    sessionId: string;
+    score: number;
+}
+export declare class SearchIndex {
+    private docs;
+    private postings;
+    private termFreqs;
+    private totalLength;
+    private sortedTermsCache;
+    add(obs: CompressedObservation): void;
+    has(id: string): boolean;
+    remove(id: string): void;
+    get size(): number;
+    private contribution;
+    search(query: string, limit?: number): Bm25Hit[];
+    clear(): void;
+    restoreFrom(other: SearchIndex): void;
+    serialize(): string;
+    static deserialize(json: string): SearchIndex;
+    private extractTerms;
+    private tokenize;
+    private sortedTerms;
+    private lowerBound;
+}

package/dist/functions/search-index.js

@@ -0,0 +1,217 @@
+//
+// Okapi BM25 inverted index. Pure and engine-independent. BM25 is a published
+// ranking function; the standard constants (k1 = 1.2, b = 0.75) and the
+// idf = log((N - df + 0.5)/(df + 0.5) + 1) form are used as published. On top
+// of exact terms, query terms also match by prefix (binary-searched over the
+// sorted term list, contribution halved) and via synonym expansion (synonym
+// terms enter at weight 0.7).
+import { stem } from "./stemmer.js";
+import { getSynonyms } from "./synonyms.js";
+import { segmentCjk, hasCjk } from "./cjk-segmenter.js";
+const K1 = 1.2;
+const B = 0.75;
+export class SearchIndex {
+    docs = new Map(); // obsId -> entry
+    postings = new Map(); // term -> obsIds
+    termFreqs = new Map(); // obsId -> term -> tf
+    totalLength = 0;
+    sortedTermsCache = null;
+    add(obs) {
+        const terms = this.extractTerms(obs);
+        const tf = new Map();
+        for (const term of terms)
+            tf.set(term, (tf.get(term) ?? 0) + 1);
+        this.docs.set(obs.id, {
+            obsId: obs.id,
+            sessionId: obs.sessionId,
+            termCount: terms.length,
+        });
+        this.termFreqs.set(obs.id, tf);
+        this.totalLength += terms.length;
+        for (const term of tf.keys()) {
+            let posting = this.postings.get(term);
+            if (!posting)
+                this.postings.set(term, (posting = new Set()));
+            posting.add(obs.id);
+        }
+        this.sortedTermsCache = null;
+    }
+    has(id) {
+        return this.docs.has(id);
+    }
+    remove(id) {
+        const entry = this.docs.get(id);
+        if (!entry)
+            return;
+        const tf = this.termFreqs.get(id);
+        if (tf) {
+            for (const term of tf.keys()) {
+                const posting = this.postings.get(term);
+                if (posting) {
+                    posting.delete(id);
+                    if (posting.size === 0)
+                        this.postings.delete(term);
+                }
+            }
+            this.termFreqs.delete(id);
+        }
+        this.totalLength = Math.max(0, this.totalLength - entry.termCount);
+        this.docs.delete(id);
+        this.sortedTermsCache = null;
+    }
+    get size() {
+        return this.docs.size;
+    }
+    // BM25 contribution of a single term to a single document (no query weight).
+    contribution(tf, df, n, docLen, avgLen) {
+        const idf = Math.log((n - df + 0.5) / (df + 0.5) + 1);
+        const num = tf * (K1 + 1);
+        const den = tf + K1 * (1 - B + B * (docLen / avgLen));
+        return idf * (num / den);
+    }
+    search(query, limit = 20) {
+        const rawTerms = this.tokenize(query.toLowerCase());
+        if (rawTerms.length === 0)
+            return [];
+        const n = this.docs.size;
+        if (n === 0)
+            return [];
+        const avgLen = this.totalLength / n;
+        // exact terms at full weight, synonyms at 0.7, de-duplicated
+        const queryTerms = [];
+        const seen = new Set();
+        for (const term of rawTerms) {
+            if (!seen.has(term)) {
+                seen.add(term);
+                queryTerms.push({ term, weight: 1 });
+            }
+            for (const syn of getSynonyms(term)) {
+                if (!seen.has(syn)) {
+                    seen.add(syn);
+                    queryTerms.push({ term: syn, weight: 0.7 });
+                }
+            }
+        }
+        const scores = new Map();
+        const accrue = (term, weight, factor) => {
+            const posting = this.postings.get(term);
+            if (!posting)
+                return;
+            const df = posting.size;
+            for (const obsId of posting) {
+                const doc = this.docs.get(obsId);
+                const tf = this.termFreqs.get(obsId)?.get(term) ?? 0;
+                const add = this.contribution(tf, df, n, doc.termCount, avgLen) * weight * factor;
+                scores.set(obsId, (scores.get(obsId) ?? 0) + add);
+            }
+        };
+        const sorted = this.sortedTerms();
+        for (const { term, weight } of queryTerms) {
+            accrue(term, weight, 1); // exact match
+            // prefix matches (term*) excluding the exact term, contribution halved
+            for (let i = this.lowerBound(sorted, term); i < sorted.length; i++) {
+                const candidate = sorted[i];
+                if (candidate === undefined || !candidate.startsWith(term))
+                    break;
+                if (candidate === term)
+                    continue;
+                accrue(candidate, weight, 0.5);
+            }
+        }
+        return [...scores.entries()]
+            .map(([obsId, score]) => ({
+            obsId,
+            sessionId: this.docs.get(obsId).sessionId,
+            score,
+        }))
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    clear() {
+        this.docs.clear();
+        this.postings.clear();
+        this.termFreqs.clear();
+        this.totalLength = 0;
+        this.sortedTermsCache = null;
+    }
+    restoreFrom(other) {
+        this.docs = new Map([...other.docs].map(([k, v]) => [k, { ...v }]));
+        this.postings = new Map([...other.postings].map(([k, v]) => [k, new Set(v)]));
+        this.termFreqs = new Map([...other.termFreqs].map(([k, v]) => [k, new Map(v)]));
+        this.totalLength = other.totalLength;
+        this.sortedTermsCache = null;
+    }
+    serialize() {
+        return JSON.stringify({
+            v: 2,
+            entries: [...this.docs.entries()],
+            inverted: [...this.postings.entries()].map(([term, ids]) => [term, [...ids]]),
+            docTerms: [...this.termFreqs.entries()].map(([id, counts]) => [id, [...counts.entries()]]),
+            totalDocLength: this.totalLength,
+        });
+    }
+    static deserialize(json) {
+        const idx = new SearchIndex();
+        try {
+            const data = JSON.parse(json);
+            if (!data?.entries || !data?.inverted || !data?.docTerms)
+                return idx;
+            for (const [id, entry] of data.entries)
+                idx.docs.set(id, entry);
+            for (const [term, ids] of data.inverted)
+                idx.postings.set(term, new Set(ids));
+            for (const [id, counts] of data.docTerms)
+                idx.termFreqs.set(id, new Map(counts));
+            const len = Number(data.totalDocLength);
+            idx.totalLength = Number.isFinite(len) && len >= 0 ? Math.floor(len) : 0;
+        }
+        catch {
+            return new SearchIndex();
+        }
+        return idx;
+    }
+    extractTerms(obs) {
+        const parts = [
+            obs.title,
+            obs.subtitle ?? "",
+            obs.narrative,
+            ...obs.facts,
+            ...obs.concepts,
+            ...obs.files,
+            obs.type,
+        ];
+        return this.tokenize(parts.join(" ").toLowerCase());
+    }
+    tokenize(text) {
+        const cleaned = text.replace(/[^\p{L}\p{N}\s/.\\-_]/gu, " ");
+        const tokens = [];
+        for (const word of cleaned.split(/\s+/)) {
+            if (word.length < 2)
+                continue;
+            if (hasCjk(word)) {
+                for (const seg of segmentCjk(word))
+                    if (seg.length >= 1)
+                        tokens.push(seg);
+            }
+            else {
+                tokens.push(stem(word));
+            }
+        }
+        return tokens;
+    }
+    sortedTerms() {
+        return (this.sortedTermsCache ??= [...this.postings.keys()].sort());
+    }
+    lowerBound(arr, target) {
+        let lo = 0;
+        let hi = arr.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if ((arr[mid] ?? "") < target)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        return lo;
+    }
+}

package/dist/functions/search.d.ts

@@ -0,0 +1,25 @@
+import type { ISdk } from "../kernel/index.js";
+import type { EmbeddingProvider, VectorIndexLike } from "./types.js";
+import type { StateKV } from "../state/kv.js";
+import { SearchIndex } from "./search-index.js";
+export declare function getSearchIndex(): SearchIndex;
+export declare function setVectorIndex(idx: VectorIndexLike | null): void;
+export declare function getVectorIndex(): VectorIndexLike | null;
+/**
+ * Constructs the configured vector index: TurboQuant-backed when
+ * MEMWARDEN_QUANT_VECTOR=true, the full-precision VectorIndex otherwise.
+ * `dims` comes from the embedding provider that will feed the index.
+ */
+export declare function makeVectorIndex(dims: number): VectorIndexLike;
+export declare function setEmbeddingProvider(provider: EmbeddingProvider | null): void;
+export declare function getEmbeddingProvider(): EmbeddingProvider | null;
+export declare function vectorIndexRemove(id: string): void;
+export declare function clipEmbedInput(text: string): string;
+export declare function vectorIndexAddGuarded(id: string, sessionId: string, text: string, context: {
+    kind: "memory" | "observation" | "synthetic";
+    logId: string;
+}): Promise<boolean>;
+export declare function rebuildIndex(kv: StateKV, opts?: {
+    preserveVectorIndex?: boolean;
+}): Promise<number>;
+export declare function registerSearchFunction(sdk: ISdk, kv: StateKV): void;