@namzu/sdk 0.4.2 → 0.4.3

package/src/rag/ingestion.test.ts

@@ -0,0 +1,114 @@
+/**
+ * Current-code invariants asserted (2026-04-21, ses_006 Phase 4):
+ *
+ *   - `DefaultIngestionPipeline.ingest(content, metadata, scope, kbId)`:
+ *     - Generates a fresh `documentId` per call.
+ *     - Chunks via `TextChunker.chunk(content, chunkingConfig)`.
+ *     - Returns zero-chunk result when the chunker emits nothing.
+ *     - Calls `embeddingProvider.embed([...chunkTexts])` exactly once
+ *       with every chunk in order.
+ *     - Each resulting `Chunk` carries:
+ *       - a fresh `id`,
+ *       - the generated `documentId`,
+ *       - the passed `knowledgeBaseId`,
+ *       - `scope.tenantId`,
+ *       - the original `chunkContent` + `chunkIndex` metadata,
+ *       - `tokenCount = Math.ceil(content.length / 4)`.
+ *     - Calls `vectorStore.upsert(chunks)` exactly once.
+ *     - Totals `tokenCount` across chunks and reports `durationMs`.
+ *   - `remove(documentId)` delegates to `vectorStore.deleteByDocument`.
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+import { z } from 'zod'
+
+import type { DocumentId, KnowledgeBaseId, TenantId } from '../types/ids/index.js'
+import type { Chunk, EmbeddingProvider, TenantScope, VectorStore } from '../types/rag/index.js'
+
+import { DefaultIngestionPipeline } from './ingestion.js'
+
+const KB = 'kb_1' as KnowledgeBaseId
+const TENANT = 't_1' as TenantId
+const scope: TenantScope = { tenantId: TENANT }
+
+function makeVectorStore(): VectorStore {
+	return {
+		upsert: vi.fn<(chunks: Chunk[]) => Promise<void>>(),
+		search: vi.fn(),
+		delete: vi.fn(),
+		deleteByDocument: vi.fn(),
+		deleteByKnowledgeBase: vi.fn(),
+	} as unknown as VectorStore
+}
+
+function makeEmbedder(): EmbeddingProvider {
+	return {
+		id: 'mock',
+		model: 'x',
+		dimensions: 3,
+		embed: vi.fn(async (texts: string[]) => texts.map(() => [1, 0, 0])),
+		embedQuery: vi.fn(async () => [1, 0, 0]),
+	}
+}
+
+describe('DefaultIngestionPipeline — ingest', () => {
+	it('returns zero-chunk result when the chunker emits nothing', async () => {
+		const vs = makeVectorStore()
+		const emb = makeEmbedder()
+		// chunkSize 10, no content at all → chunker returns []
+		const pipeline = new DefaultIngestionPipeline(vs, emb, {
+			strategy: 'fixed',
+			chunkSize: 10,
+			chunkOverlap: 0,
+		})
+		const result = await pipeline.ingest('   ', {}, scope, KB)
+		expect(result.chunkCount).toBe(0)
+		expect(result.totalTokens).toBe(0)
+		expect(vs.upsert).not.toHaveBeenCalled()
+	})
+
+	it('chunks content, embeds every chunk once, upserts once', async () => {
+		const vs = makeVectorStore()
+		const emb = makeEmbedder()
+		const pipeline = new DefaultIngestionPipeline(vs, emb, {
+			strategy: 'fixed',
+			chunkSize: 10,
+			chunkOverlap: 0,
+		})
+
+		const result = await pipeline.ingest('a'.repeat(25), { source: 'repo' }, scope, KB)
+
+		expect(emb.embed).toHaveBeenCalledTimes(1)
+		expect(vs.upsert).toHaveBeenCalledTimes(1)
+		expect(result.chunkCount).toBeGreaterThan(1)
+
+		const upsertedChunks = vi.mocked(vs.upsert).mock.calls[0]?.[0] ?? []
+		for (const c of upsertedChunks) {
+			expect(c.documentId).toBe(result.documentId)
+			expect(c.knowledgeBaseId).toBe(KB)
+			expect(c.tenantId).toBe(TENANT)
+			expect(c.metadata.source).toBe('repo')
+			expect(c.metadata.chunkIndex).toBeDefined()
+			expect(c.tokenCount).toBe(Math.ceil(c.content.length / 4))
+		}
+	})
+
+	it('generates a fresh documentId per ingest call', async () => {
+		const pipeline = new DefaultIngestionPipeline(makeVectorStore(), makeEmbedder())
+		const a = await pipeline.ingest('alpha', {}, scope, KB)
+		const b = await pipeline.ingest('beta', {}, scope, KB)
+		expect(a.documentId).not.toBe(b.documentId)
+	})
+})
+
+describe('DefaultIngestionPipeline — remove', () => {
+	it('delegates to vectorStore.deleteByDocument', async () => {
+		const vs = makeVectorStore()
+		const pipeline = new DefaultIngestionPipeline(vs, makeEmbedder())
+		await pipeline.remove('doc_9' as DocumentId)
+		expect(vs.deleteByDocument).toHaveBeenCalledWith('doc_9')
+	})
+})
+
+// Avoid the unused zod import — used in type coverage indirectly.
+void z

package/src/rag/knowledge-base.test.ts

@@ -0,0 +1,106 @@
+/**
+ * Current-code invariants asserted (2026-04-21, ses_006 Phase 4):
+ *
+ *   - `DefaultKnowledgeBase` is a composition layer: it builds an
+ *     ingestion pipeline + a retriever from its config and delegates
+ *     `ingest` / `query` / `remove` / `clear` to them.
+ *   - `id` is set from `config.id` if provided, else generated once
+ *     via `generateKnowledgeBaseId` — never regenerated later.
+ *   - `ingest(content, metadata)` invokes the ingestion pipeline with
+ *     the configured scope + kb id; returns whatever the pipeline
+ *     returns.
+ *   - `query(query)` invokes the retriever with scope + kb id.
+ *   - `clear()` calls `vectorStore.deleteByKnowledgeBase(id, tenantId)`.
+ *   - `remove(documentId)` calls `vectorStore.deleteByDocument`.
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+
+import type { DocumentId, KnowledgeBaseId, TenantId } from '../types/ids/index.js'
+import type { EmbeddingProvider, VectorStore } from '../types/rag/index.js'
+
+import { DefaultKnowledgeBase } from './knowledge-base.js'
+
+const TENANT = 't_1' as TenantId
+
+function makeVectorStore(): VectorStore {
+	return {
+		upsert: vi.fn(),
+		search: vi.fn(async () => []),
+		delete: vi.fn(),
+		deleteByDocument: vi.fn(),
+		deleteByKnowledgeBase: vi.fn(),
+	}
+}
+
+function makeEmbedder(): EmbeddingProvider {
+	return {
+		id: 'mock',
+		model: 'x',
+		dimensions: 3,
+		embed: vi.fn(async (texts: string[]) => texts.map(() => [1, 0, 0])),
+		embedQuery: vi.fn(async () => [1, 0, 0]),
+	}
+}
+
+describe('DefaultKnowledgeBase', () => {
+	it('uses the id provided in config when set', () => {
+		const kb = new DefaultKnowledgeBase(
+			{ id: 'kb_fixed' as KnowledgeBaseId, name: 'kb', tenantId: TENANT },
+			makeVectorStore(),
+			makeEmbedder(),
+		)
+		expect(kb.id).toBe('kb_fixed')
+		expect(kb.config.id).toBe('kb_fixed')
+	})
+
+	it('generates an id when none is provided', () => {
+		const kb = new DefaultKnowledgeBase(
+			{ name: 'kb', tenantId: TENANT },
+			makeVectorStore(),
+			makeEmbedder(),
+		)
+		expect(kb.id).toMatch(/^kb_/)
+	})
+
+	it('ingest delegates to the ingestion pipeline and carries metadata through', async () => {
+		const vs = makeVectorStore()
+		const kb = new DefaultKnowledgeBase(
+			{ id: 'kb_fixed' as KnowledgeBaseId, name: 'kb', tenantId: TENANT },
+			vs,
+			makeEmbedder(),
+		)
+		const result = await kb.ingest('hello world', { source: 'readme' })
+		expect(result.documentId).toMatch(/^doc_/)
+		expect(vs.upsert).toHaveBeenCalled()
+		const chunks = vi.mocked(vs.upsert).mock.calls[0]?.[0] ?? []
+		expect(chunks[0]?.knowledgeBaseId).toBe('kb_fixed')
+		expect(chunks[0]?.tenantId).toBe(TENANT)
+	})
+
+	it('remove delegates to vectorStore.deleteByDocument', async () => {
+		const vs = makeVectorStore()
+		const kb = new DefaultKnowledgeBase({ name: 'kb', tenantId: TENANT }, vs, makeEmbedder())
+		await kb.remove('doc_1' as DocumentId)
+		expect(vs.deleteByDocument).toHaveBeenCalledWith('doc_1')
+	})
+
+	it('clear delegates to vectorStore.deleteByKnowledgeBase with id + tenantId', async () => {
+		const vs = makeVectorStore()
+		const kb = new DefaultKnowledgeBase(
+			{ id: 'kb_fixed' as KnowledgeBaseId, name: 'kb', tenantId: TENANT },
+			vs,
+			makeEmbedder(),
+		)
+		await kb.clear()
+		expect(vs.deleteByKnowledgeBase).toHaveBeenCalledWith('kb_fixed', TENANT)
+	})
+
+	it('query delegates to retriever', async () => {
+		const vs = makeVectorStore()
+		const kb = new DefaultKnowledgeBase({ name: 'kb', tenantId: TENANT }, vs, makeEmbedder())
+		const out = await kb.query({ text: 'hi' })
+		expect(out.mode).toBeDefined()
+		expect(vs.search).toHaveBeenCalled()
+	})
+})

package/src/rag/rag-tool.test.ts

@@ -0,0 +1,167 @@
+/**
+ * Current-code invariants asserted (2026-04-21, ses_006 Phase 4):
+ *
+ *   - `createRAGTool(config)` returns a `defineTool`-wrapped
+ *     `knowledge_search` tool with `category: 'analysis'`,
+ *     `permissions: ['network_access']`, read-only.
+ *   - Knowledge base selection:
+ *     - If `input.knowledge_base_id` is set, looks up by it.
+ *     - Else uses `config.defaultKnowledgeBaseId`.
+ *     - Else picks the first value from
+ *       `config.knowledgeBases.values().next()`.
+ *   - Returns `{success: false, error: ...}` if no knowledge base is
+ *     resolved.
+ *   - When the query returns no chunks, returns the literal
+ *     "No relevant information found..." message.
+ *   - When chunks exist, assembles them via `assembleRAGContext` and
+ *     returns `{success: true, output: content, data: {sources, mode, durationMs}}`.
+ *   - `top_k` override precedence: input > config.topK > 5.
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+
+import type { ChunkId, DocumentId, KnowledgeBaseId, TenantId } from '../types/ids/index.js'
+import type { KnowledgeBase, RetrievalResult, VectorSearchResult } from '../types/rag/index.js'
+import type { ToolContext } from '../types/tool/index.js'
+
+import { createRAGTool } from './rag-tool.js'
+
+const TENANT = 't_1' as TenantId
+const KB_A = 'kb_a' as KnowledgeBaseId
+const KB_B = 'kb_b' as KnowledgeBaseId
+
+function makeKB(retrievalResult: RetrievalResult): KnowledgeBase {
+	const kb = {
+		id: KB_A,
+		config: { id: KB_A, tenantId: TENANT },
+		ingest: vi.fn(),
+		remove: vi.fn(),
+		query: vi.fn(async () => retrievalResult),
+		clear: vi.fn(),
+	} as unknown as KnowledgeBase
+	return kb
+}
+
+function searchResult(content: string): VectorSearchResult {
+	return {
+		chunk: {
+			id: 'c_1' as ChunkId,
+			documentId: 'd_1' as DocumentId,
+			knowledgeBaseId: KB_A,
+			tenantId: TENANT,
+			content,
+			index: 0,
+			tokenCount: 0,
+			metadata: {},
+			createdAt: 0,
+		},
+		score: 0.9,
+	}
+}
+
+const ctx: ToolContext = {} as ToolContext
+
+describe('createRAGTool', () => {
+	it('is named knowledge_search + read-only', () => {
+		const tool = createRAGTool({ knowledgeBases: new Map() })
+		expect(tool.name).toBe('knowledge_search')
+		expect(tool.isReadOnly?.({ query: 'x' })).toBe(true)
+	})
+
+	it('returns an error when no knowledge base is resolved', async () => {
+		const tool = createRAGTool({ knowledgeBases: new Map() })
+		const result = await tool.execute({ query: 'hi' }, ctx)
+		expect(result.success).toBe(false)
+		expect(result.error).toMatch(/Knowledge base not found/)
+	})
+
+	it('picks KB by explicit input.knowledge_base_id when set', async () => {
+		const kbA = makeKB({
+			chunks: [searchResult('from A')],
+			query: 'hi',
+			mode: 'vector',
+			durationMs: 1,
+		})
+		const kbB = makeKB({
+			chunks: [searchResult('from B')],
+			query: 'hi',
+			mode: 'vector',
+			durationMs: 1,
+		})
+		const tool = createRAGTool({
+			knowledgeBases: new Map([
+				[KB_A, kbA],
+				[KB_B, kbB],
+			]),
+		})
+		const out = await tool.execute({ query: 'hi', knowledge_base_id: KB_B }, ctx)
+		expect(out.success).toBe(true)
+		expect(kbB.query).toHaveBeenCalled()
+		expect(kbA.query).not.toHaveBeenCalled()
+	})
+
+	it('falls back to defaultKnowledgeBaseId when input.knowledge_base_id is absent', async () => {
+		const kbA = makeKB({
+			chunks: [searchResult('from A')],
+			query: 'hi',
+			mode: 'vector',
+			durationMs: 1,
+		})
+		const kbB = makeKB({
+			chunks: [],
+			query: 'hi',
+			mode: 'vector',
+			durationMs: 1,
+		})
+		const tool = createRAGTool({
+			knowledgeBases: new Map([
+				[KB_A, kbA],
+				[KB_B, kbB],
+			]),
+			defaultKnowledgeBaseId: KB_B,
+		})
+		await tool.execute({ query: 'hi' }, ctx)
+		expect(kbB.query).toHaveBeenCalled()
+		expect(kbA.query).not.toHaveBeenCalled()
+	})
+
+	it('returns "No relevant information..." when the query returns zero chunks', async () => {
+		const kb = makeKB({ chunks: [], query: 'hi', mode: 'vector', durationMs: 1 })
+		const tool = createRAGTool({ knowledgeBases: new Map([[KB_A, kb]]) })
+		const result = await tool.execute({ query: 'hi' }, ctx)
+		expect(result.success).toBe(true)
+		expect(result.output).toBe(
+			'No relevant information found in the knowledge base for this query.',
+		)
+	})
+
+	it('returns assembled content + metadata on hit', async () => {
+		const kb = makeKB({
+			chunks: [searchResult('answer text')],
+			query: 'hi',
+			mode: 'vector',
+			durationMs: 42,
+		})
+		const tool = createRAGTool({ knowledgeBases: new Map([[KB_A, kb]]) })
+		const result = await tool.execute({ query: 'hi' }, ctx)
+		expect(result.success).toBe(true)
+		expect(result.output).toContain('answer text')
+		expect((result.data as { mode?: string })?.mode).toBe('vector')
+		expect((result.data as { durationMs?: number })?.durationMs).toBe(42)
+	})
+
+	it('top_k override: input > config.topK > 5 default', async () => {
+		const kb = makeKB({
+			chunks: [searchResult('x')],
+			query: 'hi',
+			mode: 'vector',
+			durationMs: 1,
+		})
+		const tool = createRAGTool({
+			knowledgeBases: new Map([[KB_A, kb]]),
+			topK: 8,
+		})
+		await tool.execute({ query: 'hi', top_k: 3 }, ctx)
+		expect(kb.query).toHaveBeenCalledWith(expect.objectContaining({ config: { topK: 3 } }))
+	})
+})

package/src/rag/retriever.test.ts

@@ -0,0 +1,210 @@
+/**
+ * Current-code invariants asserted (2026-04-21, ses_006 Phase 4):
+ *
+ *   - `DefaultRetriever.retrieve(query, scope, kbId)` dispatches by
+ *     `effectiveConfig.mode` (query.config overrides instance config).
+ *   - Query expansion: if `recentMessages` is present and non-empty,
+ *     appends the last 3 messages joined with spaces after a
+ *     `\n\nContext: ` marker. Otherwise passes `query.text` verbatim.
+ *   - `vector` mode: embeds the (expanded) query once, forwards
+ *     `{embedding, topK, tenantId, knowledgeBaseId, minScore}` to the
+ *     store, returns store results unchanged.
+ *   - `keyword` mode: fetches `topK * 2` results from vector search with
+ *     `minScore: 0`, then rescores via BM25 against the query's
+ *     tokenized form. Filters score > 0, sorts desc, slices to topK.
+ *     Tokenization: lowercase, strip non-`\w\s`, split by whitespace,
+ *     drop tokens length ≤ 1.
+ *   - `hybrid` mode: runs vector + keyword in parallel, merges by
+ *     `chunk.id`, weights vector by `alpha` and keyword by `1 - alpha`
+ *     (default alpha = 0.7). Sorts desc, slices to topK.
+ *   - Result shape: `{chunks, query, expandedQuery?, mode, durationMs}`.
+ *     `expandedQuery` is omitted when equal to original `query.text`.
+ *   - Unknown mode would hit the exhaustive throw (unreachable via
+ *     types; not asserted).
+ */
+
+import { describe, expect, it, vi } from 'vitest'
+
+import type { ChunkId, DocumentId, KnowledgeBaseId, TenantId } from '../types/ids/index.js'
+import type {
+	Chunk,
+	EmbeddingProvider,
+	TenantScope,
+	VectorSearchResult,
+	VectorStore,
+} from '../types/rag/index.js'
+
+import { DefaultRetriever } from './retriever.js'
+
+const TENANT = 't_1' as TenantId
+const KB = 'kb_1' as KnowledgeBaseId
+const scope: TenantScope = { tenantId: TENANT }
+
+function chunk(id: string, content: string): Chunk {
+	return {
+		id: id as ChunkId,
+		documentId: 'doc_1' as DocumentId,
+		knowledgeBaseId: KB,
+		tenantId: TENANT,
+		content,
+		index: 0,
+		tokenCount: 0,
+		embedding: [1, 0, 0],
+		metadata: {},
+		createdAt: 0,
+	}
+}
+
+function r(id: string, content: string, score: number): VectorSearchResult {
+	return { chunk: chunk(id, content), score }
+}
+
+function makeStore(searchResults: VectorSearchResult[]): VectorStore {
+	return {
+		search: vi.fn(async () => searchResults),
+		upsert: vi.fn(),
+		delete: vi.fn(),
+		deleteByDocument: vi.fn(),
+		deleteByKnowledgeBase: vi.fn(),
+	}
+}
+
+function makeEmbedder(): EmbeddingProvider {
+	return {
+		id: 'mock',
+		model: 'x',
+		dimensions: 3,
+		embed: vi.fn(async (texts: string[]) => texts.map(() => [1, 0, 0])),
+		embedQuery: vi.fn(async () => [1, 0, 0]),
+	}
+}
+
+describe('DefaultRetriever — vector mode', () => {
+	it('forwards embedded query + topK + tenant + minScore to store', async () => {
+		const store = makeStore([r('a', 'x', 0.9)])
+		const emb = makeEmbedder()
+		const retriever = new DefaultRetriever(store, emb, {
+			mode: 'vector',
+			topK: 3,
+			minScore: 0.2,
+		})
+		await retriever.retrieve({ text: 'hi' }, scope, KB)
+		expect(store.search).toHaveBeenCalledWith(
+			expect.objectContaining({
+				embedding: [1, 0, 0],
+				topK: 3,
+				tenantId: TENANT,
+				knowledgeBaseId: KB,
+				minScore: 0.2,
+			}),
+		)
+	})
+
+	it('returns mode + durationMs + chunks without mutation', async () => {
+		const results = [r('a', 'x', 0.9)]
+		const store = makeStore(results)
+		const retriever = new DefaultRetriever(store, makeEmbedder(), {
+			mode: 'vector',
+			topK: 5,
+		})
+		const out = await retriever.retrieve({ text: 'hi' }, scope)
+		expect(out.mode).toBe('vector')
+		expect(out.chunks).toEqual(results)
+		expect(typeof out.durationMs).toBe('number')
+	})
+})
+
+describe('DefaultRetriever — query expansion', () => {
+	it('when recentMessages exists, appends "Context: " + last 3 joined', async () => {
+		const store = makeStore([])
+		const emb = makeEmbedder()
+		const retriever = new DefaultRetriever(store, emb, { mode: 'vector', topK: 3 })
+
+		const out = await retriever.retrieve(
+			{ text: 'query', recentMessages: ['m1', 'm2', 'm3', 'm4'] },
+			scope,
+		)
+		expect(out.expandedQuery).toBe('query\n\nContext: m2 m3 m4')
+		expect(emb.embedQuery).toHaveBeenCalledWith('query\n\nContext: m2 m3 m4')
+	})
+
+	it('when no recentMessages, expandedQuery is undefined (original == expanded)', async () => {
+		const store = makeStore([])
+		const retriever = new DefaultRetriever(store, makeEmbedder(), {
+			mode: 'vector',
+			topK: 3,
+		})
+		const out = await retriever.retrieve({ text: 'plain' }, scope)
+		expect(out.expandedQuery).toBeUndefined()
+	})
+})
+
+describe('DefaultRetriever — keyword mode', () => {
+	it('fetches 2*topK from store, rescores via BM25, slices to topK', async () => {
+		// 6 candidate chunks (topK * 2 with topK=3) — retriever requests 2*topK with minScore 0.
+		const store = makeStore([
+			r('a', 'apple orange', 0.1),
+			r('b', 'banana apple apple', 0.1),
+			r('c', 'unrelated text', 0.1),
+			r('d', 'apple apple apple', 0.1),
+			r('e', 'nothing here', 0.1),
+			r('f', 'apple', 0.1),
+		])
+		const retriever = new DefaultRetriever(store, makeEmbedder(), {
+			mode: 'keyword',
+			topK: 3,
+		})
+		const out = await retriever.retrieve({ text: 'apple' }, scope)
+		expect(out.chunks.length).toBeLessThanOrEqual(3)
+		expect(out.chunks.every((c) => c.score > 0)).toBe(true)
+		// Tokenization: 'nothing' + 'here' — doesn't contain 'apple' → score 0 → filtered.
+		expect(out.chunks.every((c) => c.chunk.id !== ('e' as ChunkId))).toBe(true)
+	})
+
+	it('query store is called with minScore: 0 + topK*2', async () => {
+		const store = makeStore([r('a', 'apple', 0.5)])
+		const retriever = new DefaultRetriever(store, makeEmbedder(), {
+			mode: 'keyword',
+			topK: 2,
+		})
+		await retriever.retrieve({ text: 'apple' }, scope)
+		expect(store.search).toHaveBeenCalledWith(expect.objectContaining({ topK: 4, minScore: 0 }))
+	})
+})
+
+describe('DefaultRetriever — hybrid mode', () => {
+	it('merges by chunk.id, weighted by alpha (default 0.7)', async () => {
+		const store = makeStore([r('a', 'apple', 1), r('b', 'banana', 0.5)])
+		const retriever = new DefaultRetriever(store, makeEmbedder(), {
+			mode: 'hybrid',
+			topK: 5,
+		})
+		const out = await retriever.retrieve({ text: 'apple' }, scope)
+		// Vector side: a=0.7, b=0.35. Keyword side (BM25): a matches → >0; b=0.
+		// Hybrid: a stays high; b gets only vector weight.
+		expect(out.chunks[0]?.chunk.id).toBe('a')
+	})
+
+	it('chunks in only one side still appear with partial weight', async () => {
+		const store = makeStore([r('a', 'apple', 1)])
+		const retriever = new DefaultRetriever(store, makeEmbedder(), {
+			mode: 'hybrid',
+			topK: 5,
+		})
+		const out = await retriever.retrieve({ text: 'apple' }, scope)
+		expect(out.chunks.length).toBe(1)
+		expect(out.chunks[0]?.score).toBeGreaterThan(0)
+	})
+})
+
+describe('DefaultRetriever — config merge', () => {
+	it('query.config overrides instance config per-call', async () => {
+		const store = makeStore([r('a', 'x', 0.9)])
+		const retriever = new DefaultRetriever(store, makeEmbedder(), {
+			mode: 'vector',
+			topK: 5,
+		})
+		await retriever.retrieve({ text: 'hi', config: { topK: 1 } }, scope)
+		expect(store.search).toHaveBeenCalledWith(expect.objectContaining({ topK: 1 }))
+	})
+})