const EMBEDDING_CACHE_TABLE = "embedding_cache";

const MEMORY_INDEX_MANAGER_CACHE_KEY = Symbol.for("openclaw.memoryIndexManagerCache");

export const EMBEDDING_PROBE_CACHE_TTL_MS = 30_000;

const KEYWORD_FALLBACK_SEARCH_TERM_LIMIT = 6;

const log = createSubsystemLogger("memory");

type MemoryIndexManagerPurpose = "default" | "status" | "cli";

type MemoryEmbeddingProviderRequirement = {

expireAtMs: number;

};

type KeywordSearchHit = MemorySearchResult & { id: string; textScore: number };

const EMBEDDING_PROBE_CACHE = new Map<string, EmbeddingProbeCacheEntry>();

export async function closeAllMemoryIndexManagers(): Promise<void> {

return [];

}

const fullQueryResults = await this.searchKeyword(

const keywordResults = await this.searchKeywordWithFallback(

cleaned,

candidates,

{

log.warn(`memory search: FTS keyword query failed: ${formatErrorMessage(err)}`);

return [];

});

const resultSets =

fullQueryResults.length > 0

? [fullQueryResults]

: await Promise.all(

// Fallback: broaden recall for conversational queries when the

// exact AND query is too strict to return any results.

(() => {

const keywords = extractKeywords(cleaned, {

ftsTokenizer: this.settings.store.fts.tokenizer,

});

const searchTerms = keywords.length > 0 ? keywords : [cleaned];

return searchTerms.map((term) =>

this.searchKeyword(

term,

candidates,

{ boostFallbackRanking: true },

sourceFilterList,

).catch((err: unknown) => {

log.warn(

`memory search: FTS per-keyword query failed for "${term}": ${formatErrorMessage(err)}`,

);

return [];

}),

);

})(),

);

// Merge and deduplicate results, keeping highest score for each chunk

const seenIds = new Map<string, (typeof resultSets)[0][0]>();

for (const results of resultSets) {

for (const result of results) {

const existing = seenIds.get(result.id);

if (!existing || result.score > existing.score) {

seenIds.set(result.id, result);

}

}

}

const merged = [...seenIds.values()];

const decayed = await applyTemporalDecayToHybridResults({

results: merged,

results: keywordResults,

temporalDecay: hybrid.temporalDecay,

workspaceDir: this.workspaceDir,

});

// If FTS isn't available, hybrid mode cannot use keyword search; degrade to vector-only.

const loadKeywordResults = async () =>

hybrid.enabled && this.fts.enabled && this.fts.available

? await this.searchKeyword(

? await this.searchKeywordWithFallback(

cleaned,

candidates,

{ boostFallbackRanking: true },

}

// Hybrid defaults can produce keyword-only matches below minScore after

// weighting. If strict vector+keyword results are empty, preserve the FTS

// matches; FTS already established lexical relevance.

// BM25 normalization and textWeight scaling. Preserve FTS-backed lexical

// hits when they are the only relevant results.

const relaxedMinScore = 0;

const keywordKeys = new Set(

keywordResults.map(

limit: number,

options?: { boostFallbackRanking?: boolean },

sourceFilterList?: MemorySource[],

): Promise<Array<MemorySearchResult & { id: string; textScore: number }>> {

): Promise<KeywordSearchHit[]> {

if (!this.fts.enabled || !this.fts.available) {

return [];

}

bm25RankToScore,

boostFallbackRanking: options?.boostFallbackRanking,

});

return results.map((entry) => entry as MemorySearchResult & { id: string; textScore: number });

return results.map((entry) => entry as KeywordSearchHit);

}

private async searchKeywordWithFallback(

query: string,

limit: number,

options: { boostFallbackRanking?: boolean } | undefined,

sourceFilterList: MemorySource[],

): Promise<KeywordSearchHit[]> {

const fullQueryResults = await this.searchKeyword(

query,

limit,

options,

sourceFilterList,

).catch(() => []);

if (fullQueryResults.length > 0) {

return fullQueryResults;

}

// Broaden recall for conversational queries when the exact AND query is too

// strict, but cap the number of extra FTS probes so long prompts cannot fan

// out into unbounded sqlite work.

const fallbackTerms = this.resolveKeywordFallbackTerms(query);

if (fallbackTerms.length === 0) {

return [];

}

const resultSets = await Promise.all(

fallbackTerms.map((term) =>

this.searchKeyword(term, limit, options, sourceFilterList).catch(() => []),

),

);

return this.mergeKeywordSearchHits(resultSets);

}

private resolveKeywordFallbackTerms(query: string): string[] {

const keywords = extractKeywords(query, {

ftsTokenizer: this.settings.store.fts.tokenizer,

}).filter((term) => term !== query);

return keywords.slice(0, KEYWORD_FALLBACK_SEARCH_TERM_LIMIT);

}

private mergeKeywordSearchHits(resultSets: KeywordSearchHit[][]): KeywordSearchHit[] {

const seenIds = new Map<string, KeywordSearchHit>();

for (const results of resultSets) {

for (const result of results) {

const existing = seenIds.get(result.id);

if (

!existing ||

result.textScore > existing.textScore ||

(result.textScore === existing.textScore && result.score > existing.score)

) {

seenIds.set(result.id, result);

}

}

}

return [...seenIds.values()].toSorted((a, b) => b.score - a.score);

}

private mergeHybridResults(params: {