sessionKey?: string;

qmdSearchModeOverride?: "query" | "search" | "vsearch";

onDebug?: (debug: MemorySearchRuntimeDebug) => void;

/** When set, only these chunk sources are considered (must be enabled for this manager). */

sources?: MemorySource[];

},

): Promise<MemorySearchResult[]> {

opts?.onDebug?.({ backend: "builtin" });

}

const minScore = opts?.minScore ?? this.settings.query.minScore;

const maxResults = opts?.maxResults ?? this.settings.query.maxResults;

const searchSources =

opts?.sources && opts.sources.length > 0

? [...new Set(opts.sources)].filter((s) => this.sources.has(s))

: undefined;

if (opts?.sources && opts.sources.length > 0 && (!searchSources || searchSources.length === 0)) {

return [];

}

const sourceFilterList = searchSources ?? [...this.sources];

const hybrid = this.settings.query.hybrid;

const candidates = Math.min(

200,

return [];

}

const fullQueryResults = await this.searchKeyword(cleaned, candidates, {

boostFallbackRanking: true,

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

const fullQueryResults = await this.searchKeyword(

cleaned,

candidates,

{

boostFallbackRanking: true,

},

sourceFilterList,

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

const resultSets =

fullQueryResults.length > 0

? [fullQueryResults]

});

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

return searchTerms.map((term) =>

this.searchKeyword(term, candidates, { boostFallbackRanking: true }).catch(

this.searchKeyword(term, candidates, { boostFallbackRanking: true }, sourceFilterList).catch(

() => [],

),

);

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

const keywordResults =

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

? await this.searchKeyword(cleaned, candidates).catch(() => [])

? await this.searchKeyword(cleaned, candidates, undefined, sourceFilterList).catch(() => [])

: [];

const queryVec = await this.embedQueryWithTimeout(cleaned);

const hasVector = queryVec.some((v) => v !== 0);

const vectorResults = hasVector

? await this.searchVector(queryVec, candidates).catch(() => [])

? await this.searchVector(queryVec, candidates, sourceFilterList).catch(() => [])

: [];

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

private async searchVector(

queryVec: number[],

limit: number,

sourceFilterList: MemorySource[],

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

// This method should never be called without a provider

if (!this.provider) {

limit,

snippetMaxChars: SNIPPET_MAX_CHARS,

ensureVectorReady: async (dimensions) => await this.ensureVectorReady(dimensions),

sourceFilterVec: this.buildSourceFilter("c"),

sourceFilterChunks: this.buildSourceFilter(),

sourceFilterVec: this.buildSourceFilter("c", sourceFilterList),

sourceFilterChunks: this.buildSourceFilter(undefined, sourceFilterList),

});

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

}

query: string,

limit: number,

options?: { boostFallbackRanking?: boolean },

sourceFilterList?: MemorySource[],

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

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

return [];

}

const sourceFilter = this.buildSourceFilter();

const sourceFilter = this.buildSourceFilter(undefined, sourceFilterList);

// In FTS-only mode (no provider), search all models; otherwise filter by current provider's model

const providerModel = this.provider?.model;

const results = await searchKeyword({