@openviking/openclaw-plugin 2026.6.2 → 2026.6.17-dev.2

package/dist/query-config.js

@@ -0,0 +1,336 @@
+import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { normalizeRecallResourceTypes } from "./registries/recall-resource-types.js";
+const DEFAULT_CANDIDATE_MULTIPLIER = 4;
+const DEFAULT_OV_SEARCH_LIMIT = 10;
+const DEFAULT_RANKING_WEIGHTS = {
+    baseScore: 1,
+    leaf: 0.12,
+    event: 0.1,
+    preference: 0.08,
+    lexicalOverlapMax: 0.2,
+};
+function toNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "string" && value.trim() !== "") {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function clampInteger(value, min, max) {
+    const n = toNumber(value);
+    if (n === undefined)
+        return undefined;
+    return Math.max(min, Math.min(max, Math.floor(n)));
+}
+function clampNumber(value, min, max) {
+    const n = toNumber(value);
+    if (n === undefined)
+        return undefined;
+    return Math.max(min, Math.min(max, n));
+}
+function shallowNumberRecord(value, min, max) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const result = {};
+    for (const [key, raw] of Object.entries(value)) {
+        const n = clampNumber(raw, min, max);
+        if (n !== undefined)
+            result[key] = n;
+    }
+    return result;
+}
+export function normalizeRuntimeQueryParams(value) {
+    const warnings = [];
+    const params = {};
+    const recallLimit = clampInteger(value.recallLimit, 1, 50);
+    if (recallLimit !== undefined)
+        params.recallLimit = recallLimit;
+    const candidateMultiplier = clampInteger(value.candidateMultiplier, 1, 20);
+    if (candidateMultiplier !== undefined)
+        params.candidateMultiplier = candidateMultiplier;
+    const candidateLimit = clampInteger(value.candidateLimit, 1, 200);
+    if (candidateLimit !== undefined)
+        params.candidateLimit = candidateLimit;
+    const scoreThreshold = clampNumber(value.scoreThreshold, 0, 1);
+    if (scoreThreshold !== undefined)
+        params.scoreThreshold = scoreThreshold;
+    const maxInjectedChars = clampInteger(value.maxInjectedChars, 100, 50_000);
+    if (maxInjectedChars !== undefined)
+        params.maxInjectedChars = maxInjectedChars;
+    const ovSearchLimit = clampInteger(value.ovSearchLimit, 1, 100);
+    if (ovSearchLimit !== undefined)
+        params.ovSearchLimit = ovSearchLimit;
+    if (typeof value.recallPreferAbstract === "boolean")
+        params.recallPreferAbstract = value.recallPreferAbstract;
+    if (value.resourceTypes !== undefined)
+        params.resourceTypes = normalizeRecallResourceTypes(value.resourceTypes);
+    if (typeof value.targetUri === "string" && value.targetUri.trim()) {
+        const targetUri = value.targetUri.trim();
+        if (!targetUri.startsWith("viking://"))
+            throw new Error("targetUri must start with viking://");
+        params.targetUri = targetUri;
+    }
+    const rankingWeights = shallowNumberRecord(value.rankingWeights, 0, 2);
+    if (rankingWeights)
+        params.rankingWeights = rankingWeights;
+    const resourceTypeWeights = shallowNumberRecord(value.resourceTypeWeights, -1, 2);
+    if (resourceTypeWeights)
+        params.resourceTypeWeights = resourceTypeWeights;
+    const categoryWeights = shallowNumberRecord(value.categoryWeights, -1, 2);
+    if (categoryWeights)
+        params.categoryWeights = categoryWeights;
+    if (params.candidateLimit !== undefined && params.recallLimit !== undefined && params.candidateLimit < params.recallLimit) {
+        params.candidateLimit = params.recallLimit;
+        warnings.push("candidateLimit was raised to recallLimit");
+    }
+    return { params, warnings };
+}
+export function resolveSessionQueryConfigKey(ctx) {
+    if (ctx.ovSessionId)
+        return `ov:${ctx.ovSessionId}`;
+    if (ctx.sessionId)
+        return `session:${ctx.sessionId}`;
+    if (ctx.sessionKey)
+        return `key:${ctx.sessionKey}`;
+    return undefined;
+}
+function emptyRuntimeFile() {
+    return { schemaVersion: "1.0", updatedAt: Date.now(), claws: {}, sessions: {} };
+}
+function isRuntimeFile(value) {
+    return !!value && typeof value === "object" && !Array.isArray(value) && value.schemaVersion === "1.0";
+}
+export class RuntimeQueryConfigStore {
+    options;
+    data = emptyRuntimeFile();
+    lastMtimeMs = 0;
+    loadPromise;
+    writeQueue = Promise.resolve();
+    static createInMemory(staticConfig) {
+        return new RuntimeQueryConfigStore({ staticConfig });
+    }
+    constructor(options) {
+        this.options = options;
+    }
+    async load() {
+        if (!this.options.path)
+            return;
+        const loadPromise = this.loadFromDisk({ resetOnFailure: true });
+        this.loadPromise = loadPromise;
+        try {
+            await loadPromise;
+        }
+        finally {
+            if (this.loadPromise === loadPromise)
+                this.loadPromise = undefined;
+        }
+    }
+    async loadFromDisk(options) {
+        try {
+            const raw = await readFile(this.options.path, "utf8");
+            const parsed = JSON.parse(raw);
+            if (isRuntimeFile(parsed))
+                this.data = parsed;
+            const s = await stat(this.options.path);
+            this.lastMtimeMs = s.mtimeMs;
+        }
+        catch {
+            if (options?.resetOnFailure)
+                this.data = emptyRuntimeFile();
+        }
+    }
+    async waitForInitialLoad() {
+        if (this.loadPromise)
+            await this.loadPromise;
+    }
+    async reloadIfChanged(options) {
+        if (!this.options.path)
+            return;
+        await this.waitForInitialLoad();
+        try {
+            const s = await stat(this.options.path);
+            if (!options?.force && s.mtimeMs === this.lastMtimeMs)
+                return;
+            const raw = await readFile(this.options.path, "utf8");
+            const parsed = JSON.parse(raw);
+            if (isRuntimeFile(parsed)) {
+                this.data = parsed;
+                this.lastMtimeMs = s.mtimeMs;
+            }
+        }
+        catch {
+            // Keep the last known-good in-memory config.
+        }
+    }
+    async set(scope, ctx, patch) {
+        await this.waitForInitialLoad();
+        const { params, warnings } = normalizeRuntimeQueryParams(patch);
+        const key = this.keyForScope(scope, ctx);
+        const bucket = scope === "claw" ? this.data.claws : this.data.sessions;
+        bucket[key] = { params, updatedAt: Date.now(), updatedBy: "command", peerId: ctx.peerId };
+        this.data.updatedAt = Date.now();
+        await this.persist();
+        return { warnings };
+    }
+    async unset(scope, ctx, fields) {
+        await this.waitForInitialLoad();
+        const key = this.keyForScope(scope, ctx);
+        const bucket = scope === "claw" ? this.data.claws : this.data.sessions;
+        const record = bucket[key];
+        if (!record)
+            return;
+        for (const field of fields) {
+            delete record.params[field];
+        }
+        record.updatedAt = Date.now();
+        this.data.updatedAt = Date.now();
+        await this.persist();
+    }
+    async reset(scope, ctx) {
+        await this.waitForInitialLoad();
+        const key = this.keyForScope(scope, ctx);
+        const bucket = scope === "claw" ? this.data.claws : this.data.sessions;
+        delete bucket[key];
+        this.data.updatedAt = Date.now();
+        await this.persist();
+    }
+    async getEffective(ctx, requestOverrides) {
+        await this.reloadIfChanged();
+        const cfg = this.options.staticConfig;
+        const warnings = [];
+        const effective = {
+            recallLimit: cfg.recallLimit,
+            candidateMultiplier: DEFAULT_CANDIDATE_MULTIPLIER,
+            candidateLimit: Math.max(cfg.recallLimit * DEFAULT_CANDIDATE_MULTIPLIER, 20),
+            scoreThreshold: cfg.recallScoreThreshold,
+            maxInjectedChars: cfg.recallMaxInjectedChars,
+            recallPreferAbstract: cfg.recallPreferAbstract,
+            resourceTypes: normalizeRecallResourceTypes(cfg.recallTargetTypes),
+            ovSearchLimit: DEFAULT_OV_SEARCH_LIMIT,
+            rankingWeights: { ...DEFAULT_RANKING_WEIGHTS },
+            resourceTypeWeights: {},
+            categoryWeights: {},
+            sources: {
+                recallLimit: "static",
+                candidateMultiplier: "default",
+                candidateLimit: "default",
+                scoreThreshold: "static",
+                maxInjectedChars: "static",
+                recallPreferAbstract: "static",
+                resourceTypes: "static",
+                ovSearchLimit: "default",
+                rankingWeights: "default",
+            },
+            warnings,
+        };
+        let candidateLimitExplicit = false;
+        candidateLimitExplicit = this.applyLayer(effective, this.data.claws[ctx.peerId]?.params, "claw", candidateLimitExplicit);
+        const sessionRecord = this.findSessionRecord(ctx);
+        if (sessionRecord)
+            candidateLimitExplicit = this.applyLayer(effective, sessionRecord.params, "session", candidateLimitExplicit);
+        if (requestOverrides) {
+            const normalized = normalizeRuntimeQueryParams(requestOverrides);
+            warnings.push(...normalized.warnings);
+            this.applyLayer(effective, normalized.params, "request", candidateLimitExplicit);
+        }
+        effective.candidateLimit = Math.max(effective.candidateLimit, effective.recallLimit);
+        return effective;
+    }
+    applyLayer(effective, params, source, candidateLimitExplicit) {
+        if (!params)
+            return candidateLimitExplicit;
+        if (params.recallLimit !== undefined) {
+            effective.recallLimit = params.recallLimit;
+            effective.sources.recallLimit = source;
+            if (!candidateLimitExplicit) {
+                effective.candidateLimit = Math.max(effective.recallLimit * effective.candidateMultiplier, 20);
+                effective.sources.candidateLimit = source;
+            }
+        }
+        if (params.candidateMultiplier !== undefined) {
+            effective.candidateMultiplier = params.candidateMultiplier;
+            effective.sources.candidateMultiplier = source;
+            if (!candidateLimitExplicit) {
+                effective.candidateLimit = Math.max(effective.recallLimit * params.candidateMultiplier, 20);
+                effective.sources.candidateLimit = source;
+            }
+        }
+        if (params.candidateLimit !== undefined) {
+            effective.candidateLimit = params.candidateLimit;
+            effective.sources.candidateLimit = source;
+            candidateLimitExplicit = true;
+        }
+        if (params.scoreThreshold !== undefined) {
+            effective.scoreThreshold = params.scoreThreshold;
+            effective.sources.scoreThreshold = source;
+        }
+        if (params.maxInjectedChars !== undefined) {
+            effective.maxInjectedChars = params.maxInjectedChars;
+            effective.sources.maxInjectedChars = source;
+        }
+        if (params.recallPreferAbstract !== undefined) {
+            effective.recallPreferAbstract = params.recallPreferAbstract;
+            effective.sources.recallPreferAbstract = source;
+        }
+        if (params.resourceTypes !== undefined) {
+            effective.resourceTypes = Array.isArray(params.resourceTypes) ? [...params.resourceTypes] : normalizeRecallResourceTypes(params.resourceTypes);
+            effective.sources.resourceTypes = source;
+        }
+        if (params.targetUri !== undefined) {
+            effective.targetUri = params.targetUri;
+            effective.sources.targetUri = source;
+        }
+        if (params.ovSearchLimit !== undefined) {
+            effective.ovSearchLimit = params.ovSearchLimit;
+            effective.sources.ovSearchLimit = source;
+        }
+        if (params.rankingWeights) {
+            effective.rankingWeights = { ...effective.rankingWeights, ...params.rankingWeights };
+            effective.sources.rankingWeights = source;
+        }
+        if (params.resourceTypeWeights)
+            effective.resourceTypeWeights = { ...effective.resourceTypeWeights, ...params.resourceTypeWeights };
+        if (params.categoryWeights)
+            effective.categoryWeights = { ...effective.categoryWeights, ...params.categoryWeights };
+        return candidateLimitExplicit;
+    }
+    keyForScope(scope, ctx) {
+        if (scope === "claw")
+            return ctx.peerId;
+        const key = resolveSessionQueryConfigKey(ctx);
+        if (!key)
+            throw new Error("session scope requires ovSessionId, sessionId, or sessionKey");
+        return key;
+    }
+    findSessionRecord(ctx) {
+        const keys = [
+            ctx.ovSessionId ? `ov:${ctx.ovSessionId}` : undefined,
+            ctx.sessionId ? `session:${ctx.sessionId}` : undefined,
+            ctx.sessionKey ? `key:${ctx.sessionKey}` : undefined,
+        ].filter((key) => Boolean(key));
+        for (const key of keys) {
+            const record = this.data.sessions[key];
+            if (record)
+                return record;
+        }
+        return undefined;
+    }
+    async persist() {
+        if (!this.options.path)
+            return;
+        const operation = this.writeQueue.catch(() => undefined).then(async () => {
+            await mkdir(dirname(this.options.path), { recursive: true });
+            const temp = `${this.options.path}.${process.pid}.${Date.now()}.tmp`;
+            await writeFile(temp, JSON.stringify(this.data, null, 2), "utf8");
+            await rename(temp, this.options.path);
+            const s = await stat(this.options.path);
+            this.lastMtimeMs = s.mtimeMs;
+        });
+        this.writeQueue = operation.catch(() => undefined);
+        await operation;
+    }
+}

package/dist/recall-trace.js

@@ -0,0 +1,309 @@
+import { appendFile, mkdir, readFile, readdir, unlink } from "node:fs/promises";
+import { join } from "node:path";
+const ALLOWED_RESOURCE_TYPES = ["resource", "user", "agent"];
+const DEFAULT_RESOURCE_TYPES = ["user", "agent"];
+function toResourceTypeEntries(value) {
+    if (Array.isArray(value)) {
+        return value
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+    if (typeof value === "string") {
+        return value
+            .split(/[,\n]/)
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+    return [];
+}
+export function normalizeResourceTypes(value) {
+    const entries = toResourceTypeEntries(value);
+    if (entries.length === 0) {
+        return [...DEFAULT_RESOURCE_TYPES];
+    }
+    const seen = new Set();
+    const normalized = [];
+    const invalid = [];
+    for (const entry of entries) {
+        if (ALLOWED_RESOURCE_TYPES.includes(entry)) {
+            const typed = entry;
+            if (!seen.has(typed)) {
+                seen.add(typed);
+                normalized.push(typed);
+            }
+        }
+        else {
+            invalid.push(entry);
+        }
+    }
+    if (invalid.length > 0) {
+        throw new Error(`invalid resourceTypes: ${invalid.join(", ")}`);
+    }
+    return normalized.length > 0 ? normalized : [...DEFAULT_RESOURCE_TYPES];
+}
+export function resolveRecallSearchPlan(resourceTypes, _ctx) {
+    const normalized = normalizeResourceTypes(resourceTypes);
+    const searches = [];
+    const skipped = [];
+    let addedMemorySearch = false;
+    for (const resourceType of normalized) {
+        if (resourceType === "resource") {
+            searches.push({ resourceType, contextType: "resource" });
+        }
+        else if ((resourceType === "user" || resourceType === "agent") && !addedMemorySearch) {
+            searches.push({ resourceType: "user", contextType: "memory" });
+            addedMemorySearch = true;
+        }
+    }
+    return { resourceTypes: normalized, searches, skipped };
+}
+export class RecallTraceMemoryStore {
+    maxEntries;
+    entries = [];
+    constructor(maxEntries) {
+        this.maxEntries = Math.max(1, Math.floor(maxEntries));
+    }
+    record(entry) {
+        this.entries.push(entry);
+        while (this.entries.length > this.maxEntries) {
+            this.entries.shift();
+        }
+    }
+    query(query) {
+        const limit = Math.max(1, Math.floor(query.limit ?? 20));
+        const turn = query.turn ?? "latest";
+        const resourceTypes = query.resourceTypes && query.resourceTypes.length > 0
+            ? new Set(query.resourceTypes)
+            : undefined;
+        const filtered = this.entries
+            .filter((entry) => {
+            if (query.traceId && entry.traceId !== query.traceId)
+                return false;
+            if (query.source && entry.source !== query.source)
+                return false;
+            if (query.sessionId && entry.sessionId !== query.sessionId)
+                return false;
+            if (query.sessionKey && entry.sessionKey !== query.sessionKey)
+                return false;
+            if (query.ovSessionId && entry.ovSessionId !== query.ovSessionId)
+                return false;
+            if (typeof query.since === "number" && entry.ts < query.since)
+                return false;
+            if (typeof query.until === "number" && entry.ts > query.until)
+                return false;
+            if (resourceTypes && !entry.resourceTypes.some((resourceType) => resourceTypes.has(resourceType))) {
+                return false;
+            }
+            return true;
+        })
+            .sort((a, b) => b.ts - a.ts);
+        return { entries: filtered.slice(0, turn === "latest" ? 1 : limit), lookupLayer: "memory", warnings: [] };
+    }
+}
+function jsonlFileNameForTimestamp(ts) {
+    return `${new Date(ts).toISOString().slice(0, 10)}.jsonl`;
+}
+function startOfUtcDay(ts) {
+    const d = new Date(ts);
+    return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate());
+}
+function timestampFromJsonlFileName(name) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})\.jsonl$/.exec(name);
+    if (!match) {
+        return undefined;
+    }
+    const ts = Date.UTC(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+    return Number.isFinite(ts) ? ts : undefined;
+}
+function fileMayOverlapQueryWindow(name, since, until) {
+    const dayStart = timestampFromJsonlFileName(name);
+    if (dayStart === undefined) {
+        return true;
+    }
+    const dayEnd = dayStart + 86_400_000 - 1;
+    return dayEnd >= since && dayStart <= until;
+}
+function isRecallTraceEntry(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return candidate.schemaVersion === "1.0" &&
+        typeof candidate.traceId === "string" &&
+        typeof candidate.ts === "number" &&
+        typeof candidate.source === "string" &&
+        typeof candidate.operationType === "string" &&
+        Array.isArray(candidate.resourceTypes) &&
+        !!candidate.trigger &&
+        typeof candidate.trigger.query === "string";
+}
+export class RecallTraceJsonlStore {
+    dir;
+    includeRawUserPreview;
+    retentionDays;
+    queryMaxDays;
+    pending = [];
+    warnings = [];
+    constructor(options) {
+        this.dir = options.dir;
+        this.includeRawUserPreview = options.includeRawUserPreview === true;
+        this.retentionDays = Math.max(1, Math.floor(options.retentionDays ?? 14));
+        this.queryMaxDays = Math.max(1, Math.floor(options.queryMaxDays ?? 14));
+    }
+    entryForPersistence(entry) {
+        if (this.includeRawUserPreview || entry.trigger.rawUserTextPreview === undefined) {
+            return entry;
+        }
+        return {
+            ...entry,
+            trigger: {
+                ...entry.trigger,
+                rawUserTextPreview: undefined,
+            },
+        };
+    }
+    append(entry) {
+        const write = (async () => {
+            await mkdir(this.dir, { recursive: true });
+            await this.pruneExpiredFiles(entry.ts);
+            await appendFile(join(this.dir, jsonlFileNameForTimestamp(entry.ts)), `${JSON.stringify(this.entryForPersistence(entry))}\n`, "utf8");
+        })().catch((err) => {
+            this.warnings.push(`Failed to append recall trace JSONL: ${err instanceof Error ? err.message : String(err)}`);
+        });
+        this.pending.push(write);
+        return write;
+    }
+    async pruneExpiredFiles(nowTs) {
+        const cutoff = startOfUtcDay(nowTs - this.retentionDays * 86_400_000);
+        let files;
+        try {
+            files = await readdir(this.dir);
+        }
+        catch {
+            return;
+        }
+        await Promise.all(files
+            .filter((name) => name.endsWith(".jsonl"))
+            .filter((name) => {
+            const ts = timestampFromJsonlFileName(name);
+            return ts !== undefined && ts < cutoff;
+        })
+            .map(async (name) => {
+            try {
+                await unlink(join(this.dir, name));
+            }
+            catch (err) {
+                this.warnings.push(`Failed to prune recall trace file ${name}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }));
+    }
+    async flush() {
+        const pending = this.pending.splice(0);
+        await Promise.all(pending);
+        return { warnings: [...this.warnings] };
+    }
+    async query(query) {
+        await this.flush();
+        const warnings = [...this.warnings];
+        const entries = [];
+        let files;
+        try {
+            files = await readdir(this.dir);
+        }
+        catch (err) {
+            const code = typeof err === "object" && err !== null && "code" in err ? String(err.code) : "";
+            if (code === "ENOENT") {
+                return { entries: [], lookupLayer: "persistent", warnings };
+            }
+            return {
+                entries: [],
+                lookupLayer: "persistent",
+                warnings: [...warnings, `Failed to read recall trace directory: ${err instanceof Error ? err.message : String(err)}`],
+            };
+        }
+        const queryStart = typeof query.since === "number"
+            ? query.since
+            : Date.now() - this.queryMaxDays * 86_400_000;
+        const queryEnd = typeof query.until === "number" ? query.until : Date.now();
+        for (const file of files
+            .filter((name) => name.endsWith(".jsonl"))
+            .filter((name) => fileMayOverlapQueryWindow(name, queryStart, queryEnd))
+            .sort()) {
+            const path = join(this.dir, file);
+            let content;
+            try {
+                content = await readFile(path, "utf8");
+            }
+            catch (err) {
+                warnings.push(`Failed to read recall trace file ${file}: ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
+            const lines = content.split("\n");
+            for (let index = 0; index < lines.length; index++) {
+                const line = lines[index].trim();
+                if (!line) {
+                    continue;
+                }
+                try {
+                    const parsed = JSON.parse(line);
+                    if (isRecallTraceEntry(parsed)) {
+                        entries.push(parsed);
+                    }
+                    else {
+                        warnings.push(`Skipping corrupted recall trace line ${file}:${index + 1}`);
+                    }
+                }
+                catch {
+                    warnings.push(`Skipping corrupted recall trace line ${file}:${index + 1}`);
+                }
+            }
+        }
+        const memory = new RecallTraceMemoryStore(Math.max(1, entries.length));
+        for (const entry of entries) {
+            memory.record(entry);
+        }
+        const filtered = memory.query(query);
+        return { entries: filtered.entries, lookupLayer: "persistent", warnings };
+    }
+}
+export class RecallTraceRecorder {
+    memory;
+    persistent;
+    constructor(options) {
+        this.memory = new RecallTraceMemoryStore(options.memoryMaxEntries);
+        this.persistent = options.persist ? new RecallTraceJsonlStore({
+            dir: options.traceDir,
+            includeRawUserPreview: options.includeRawUserPreview,
+            retentionDays: options.retentionDays,
+            queryMaxDays: options.queryMaxDays,
+        }) : undefined;
+    }
+    record(entry) {
+        this.memory.record(entry);
+        void this.persistent?.append(entry);
+    }
+    async recordAndFlush(entry) {
+        this.memory.record(entry);
+        await this.persistent?.append(entry);
+        return this.flush();
+    }
+    query(query) {
+        return this.memory.query(query);
+    }
+    async queryWithFallback(query) {
+        const memoryResult = this.memory.query(query);
+        if (memoryResult.entries.length > 0 || !this.persistent) {
+            return memoryResult;
+        }
+        const persistentResult = await this.persistent.query(query);
+        return {
+            entries: persistentResult.entries,
+            lookupLayer: "persistent",
+            warnings: [...memoryResult.warnings, ...persistentResult.warnings],
+        };
+    }
+    async flush() {
+        return this.persistent ? this.persistent.flush() : { warnings: [] };
+    }
+}

package/dist/registries/recall-resource-types.js

@@ -0,0 +1,58 @@
+export const ALLOWED_RECALL_RESOURCE_TYPES = ["resource", "user", "agent"];
+export const DEFAULT_RECALL_RESOURCE_TYPES = ["user", "agent"];
+function toResourceTypeEntries(value) {
+    if (Array.isArray(value)) {
+        return value
+            .filter((entry) => typeof entry === "string")
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+    if (typeof value === "string") {
+        return value
+            .split(/[,\n]/)
+            .map((entry) => entry.trim())
+            .filter(Boolean);
+    }
+    return [];
+}
+export function normalizeRecallResourceTypes(value) {
+    const entries = toResourceTypeEntries(value);
+    if (entries.length === 0) {
+        return [...DEFAULT_RECALL_RESOURCE_TYPES];
+    }
+    const seen = new Set();
+    const normalized = [];
+    const invalid = [];
+    for (const entry of entries) {
+        if (ALLOWED_RECALL_RESOURCE_TYPES.includes(entry)) {
+            const typed = entry;
+            if (!seen.has(typed)) {
+                seen.add(typed);
+                normalized.push(typed);
+            }
+        }
+        else {
+            invalid.push(entry);
+        }
+    }
+    if (invalid.length > 0) {
+        throw new Error(`invalid resourceTypes: ${invalid.join(", ")}`);
+    }
+    return normalized.length > 0 ? normalized : [...DEFAULT_RECALL_RESOURCE_TYPES];
+}
+export function resolveRecallSearchPlan(resourceTypes, _ctx) {
+    const normalized = normalizeRecallResourceTypes(resourceTypes);
+    const searches = [];
+    const skipped = [];
+    let addedMemorySearch = false;
+    for (const resourceType of normalized) {
+        if (resourceType === "resource") {
+            searches.push({ resourceType, contextType: "resource" });
+        }
+        else if ((resourceType === "user" || resourceType === "agent") && !addedMemorySearch) {
+            searches.push({ resourceType: "user", contextType: "memory" });
+            addedMemorySearch = true;
+        }
+    }
+    return { resourceTypes: normalized, searches, skipped };
+}