feat(session-query): checkpoint build round 1
This commit is contained in:
Hypatia May
704
packages/session-query/session-query/tests/session-query.spec.ts
Normal file
704
packages/session-query/session-query/tests/session-query.spec.ts
Normal file
@@ -0,0 +1,704 @@
|
||||
import { describe, expect, it } from 'vitest'
|
||||
import { Context } from 'cordis'
|
||||
import { CallId } from '@deepseek-ai/dsh-llm'
|
||||
import type { ContentBlock } from '@deepseek-ai/dsh-llm'
|
||||
import SessionStore, { SESSION_FORMAT_VERSION, Session, SessionId } from '@deepseek-ai/dsh-session'
|
||||
import type { SessionEvent, SessionHeader, SessionId as SessionIdType } from '@deepseek-ai/dsh-session'
|
||||
import SessionPersistence from '@deepseek-ai/dsh-session-persistence'
|
||||
import SessionQueryService, {
|
||||
SessionQueryError,
|
||||
filterEventResults,
|
||||
filterSessionResults,
|
||||
} from '@deepseek-ai/dsh-session-query'
|
||||
import type {
|
||||
SessionEventSearchHit,
|
||||
SessionEventSearchRequest,
|
||||
SessionIndexSnapshot,
|
||||
SessionRecord,
|
||||
SessionSearchHit,
|
||||
SessionSearchPage,
|
||||
SessionSearchProvider,
|
||||
SessionSearchProviderStatus,
|
||||
SessionSearchRequest,
|
||||
} from '@deepseek-ai/dsh-session-query'
|
||||
|
||||
declare module '@deepseek-ai/dsh-llm' {
|
||||
interface ContentBlockMap {
|
||||
'test/text': { type: 'test/text'; value: string }
|
||||
}
|
||||
}
|
||||
|
||||
declare module '@deepseek-ai/dsh-session' {
|
||||
interface SessionEventMap {
|
||||
'test/note': { note: string }
|
||||
}
|
||||
}
|
||||
|
||||
function header(id: string, createdAt = 1, extra: Partial<SessionHeader> = {}): SessionHeader {
|
||||
return { version: SESSION_FORMAT_VERSION, id: SessionId(id), createdAt, ...extra }
|
||||
}
|
||||
|
||||
function eventLog(text = 'hello'): SessionEvent[] {
|
||||
return [{
|
||||
type: 'user/message',
|
||||
seq: 0,
|
||||
time: 10,
|
||||
data: { content: [{ type: 'text', text }], source: { kind: 'user' } },
|
||||
surfaceOp: 'append',
|
||||
}]
|
||||
}
|
||||
|
||||
class TestPersistence extends SessionPersistence {
|
||||
static entries = new Map<SessionIdType, { meta: SessionHeader; events: SessionEvent[] }>()
|
||||
static listFailure: unknown
|
||||
static loadFailure: unknown
|
||||
|
||||
static reset(entries: readonly { meta: SessionHeader; events: SessionEvent[] }[] = []): void {
|
||||
this.entries = new Map(entries.map(entry => [entry.meta.id, structuredClone(entry)]))
|
||||
this.listFailure = undefined
|
||||
this.loadFailure = undefined
|
||||
}
|
||||
|
||||
create(meta: SessionHeader): Promise<void> {
|
||||
TestPersistence.entries.set(meta.id, { meta: structuredClone(meta), events: [] })
|
||||
return Promise.resolve()
|
||||
}
|
||||
|
||||
append(id: SessionIdType, events: readonly SessionEvent[]): Promise<void> {
|
||||
const entry = TestPersistence.entries.get(id)
|
||||
if (entry === undefined) throw new Error('missing test session')
|
||||
entry.events.push(...structuredClone(events))
|
||||
return Promise.resolve()
|
||||
}
|
||||
|
||||
load(id: SessionIdType): Promise<{ meta: SessionHeader; events: SessionEvent[] }> {
|
||||
if (TestPersistence.loadFailure !== undefined) return Promise.reject(asError(TestPersistence.loadFailure))
|
||||
const entry = TestPersistence.entries.get(id)
|
||||
if (entry === undefined) return Promise.reject(new Error('missing test session'))
|
||||
return Promise.resolve(structuredClone(entry))
|
||||
}
|
||||
|
||||
list(): Promise<SessionHeader[]> {
|
||||
if (TestPersistence.listFailure !== undefined) return Promise.reject(asError(TestPersistence.listFailure))
|
||||
return Promise.resolve([...TestPersistence.entries.values()].map(entry => structuredClone(entry.meta)))
|
||||
}
|
||||
}
|
||||
|
||||
class FakeProvider implements SessionSearchProvider {
|
||||
readonly id: string
|
||||
statusValue: SessionSearchProviderStatus = { available: true }
|
||||
persisted = new Map<SessionIdType, SessionIndexSnapshot>()
|
||||
live = new Map<SessionIdType, SessionIndexSnapshot>()
|
||||
activeHistory: boolean[] = []
|
||||
removedPersisted: SessionIdType[] = []
|
||||
removedLive: SessionIdType[] = []
|
||||
sessionRequests: SessionSearchRequest[] = []
|
||||
eventRequests: SessionEventSearchRequest[] = []
|
||||
failNextLive = false
|
||||
failNextPersisted = false
|
||||
failNextActive = false
|
||||
sessionPage: SessionSearchPage<SessionSearchHit>
|
||||
eventPage: SessionSearchPage<SessionEventSearchHit>
|
||||
|
||||
constructor(id = 'fake') {
|
||||
this.id = id
|
||||
this.sessionPage = { providerId: id, items: [] }
|
||||
this.eventPage = { providerId: id, items: [] }
|
||||
}
|
||||
|
||||
status(): SessionSearchProviderStatus {
|
||||
return this.statusValue
|
||||
}
|
||||
|
||||
persistedInventory(): Promise<readonly { sessionId: SessionIdType; fingerprint: string }[]> {
|
||||
return Promise.resolve([...this.persisted.values()].map(snapshot => ({
|
||||
sessionId: snapshot.session.header.id,
|
||||
fingerprint: snapshot.fingerprint,
|
||||
})))
|
||||
}
|
||||
|
||||
setPersistedActive(active: boolean): Promise<void> {
|
||||
if (this.failNextActive) {
|
||||
this.failNextActive = false
|
||||
return Promise.reject(new Error('activation failed'))
|
||||
}
|
||||
this.activeHistory.push(active)
|
||||
return Promise.resolve()
|
||||
}
|
||||
|
||||
replacePersisted(snapshot: SessionIndexSnapshot): Promise<void> {
|
||||
if (this.failNextPersisted) {
|
||||
this.failNextPersisted = false
|
||||
return Promise.reject(new Error('persisted index failed'))
|
||||
}
|
||||
this.persisted.set(snapshot.session.header.id, structuredClone(snapshot))
|
||||
return Promise.resolve()
|
||||
}
|
||||
|
||||
removePersisted(sessionId: SessionIdType): Promise<void> {
|
||||
this.removedPersisted.push(sessionId)
|
||||
this.persisted.delete(sessionId)
|
||||
return Promise.resolve()
|
||||
}
|
||||
|
||||
replaceLive(snapshot: SessionIndexSnapshot): Promise<void> {
|
||||
if (this.failNextLive) {
|
||||
this.failNextLive = false
|
||||
return Promise.reject(new Error('live index failed'))
|
||||
}
|
||||
this.live.set(snapshot.session.header.id, structuredClone(snapshot))
|
||||
return Promise.resolve()
|
||||
}
|
||||
|
||||
removeLive(sessionId: SessionIdType): Promise<void> {
|
||||
this.removedLive.push(sessionId)
|
||||
this.live.delete(sessionId)
|
||||
return Promise.resolve()
|
||||
}
|
||||
|
||||
searchSessions(request: SessionSearchRequest): Promise<SessionSearchPage<SessionSearchHit>> {
|
||||
this.sessionRequests.push(structuredClone(request))
|
||||
return Promise.resolve(structuredClone(this.sessionPage))
|
||||
}
|
||||
|
||||
searchEvents(request: SessionEventSearchRequest): Promise<SessionSearchPage<SessionEventSearchHit>> {
|
||||
this.eventRequests.push(structuredClone(request))
|
||||
return Promise.resolve(structuredClone(this.eventPage))
|
||||
}
|
||||
}
|
||||
|
||||
async function liveContext(config: ConstructorParameters<typeof SessionQueryService>[1] = {}): Promise<Context> {
|
||||
const ctx = new Context()
|
||||
await ctx.plugin(SessionStore)
|
||||
await ctx.plugin(SessionQueryService, config)
|
||||
return ctx
|
||||
}
|
||||
|
||||
function expectCode(code: string): Error {
|
||||
return expect.objectContaining({ code }) as Error
|
||||
}
|
||||
|
||||
function asError(value: unknown): Error {
|
||||
return value instanceof Error ? value : new Error(String(value))
|
||||
}
|
||||
|
||||
describe('pure result filters', () => {
|
||||
it('chains session filters as AND while values within one filter are OR', () => {
|
||||
const root: SessionRecord = { header: header('root', 1, { cwd: '/a' }), live: true, persisted: false }
|
||||
const child: SessionRecord = { header: header('child', 2, { cwd: '/b', parentSession: root.header.id }), live: false, persisted: true }
|
||||
const both: SessionRecord = { header: header('both', 3, { cwd: '/a', parentSession: root.header.id }), live: true, persisted: true }
|
||||
const input = [child, root, both]
|
||||
|
||||
const output = filterSessionResults(input, [
|
||||
{ kind: 'cwd', values: ['/a', '/b'] },
|
||||
{ kind: 'created-at', range: { from: 2, to: 3 } },
|
||||
{ kind: 'parent', values: [root.header.id] },
|
||||
{ kind: 'availability', values: ['live', 'persisted'] },
|
||||
{ kind: 'id', values: [child.header.id, both.header.id] },
|
||||
])
|
||||
|
||||
expect(output).toEqual([child, both])
|
||||
expect(output[0]).toBe(child)
|
||||
expect(input).toEqual([child, root, both])
|
||||
expect(filterSessionResults(input, [{ kind: 'cwd', values: [null] }])).toEqual([])
|
||||
})
|
||||
|
||||
it('filters event ranges/types/status without reordering richer records', () => {
|
||||
const events = [
|
||||
{ sessionId: SessionId('s'), seq: 2, type: 'user/message' as const, time: 20, surface: 'current' as const, extra: true },
|
||||
{ sessionId: SessionId('s'), seq: 1, type: 'tool/call' as const, time: 10, surface: 'shadowed' as const, extra: true },
|
||||
{ sessionId: SessionId('s'), seq: 3, type: 'assistant/chunk' as const, time: 30, surface: 'log-only' as const, extra: true },
|
||||
]
|
||||
const output = filterEventResults(events, [
|
||||
{ kind: 'seq', range: { from: 1, to: 2 } },
|
||||
{ kind: 'time', range: { from: 10, to: 20 } },
|
||||
{ kind: 'type', values: ['user/message', 'tool/call'] },
|
||||
{ kind: 'surface', values: ['current', 'shadowed'] },
|
||||
])
|
||||
expect(output).toEqual(events.slice(0, 2))
|
||||
expect(output[0]).toBe(events[0])
|
||||
})
|
||||
|
||||
it('rejects invalid serializable filter values', () => {
|
||||
expect(() => filterSessionResults([], [{ kind: 'created-at', range: { from: 2, to: 1 } }]))
|
||||
.toThrow(expectCode('SESSION_QUERY_INVALID_FILTER'))
|
||||
expect(() => filterEventResults([], [{ kind: 'seq', range: { from: Number.NaN } }]))
|
||||
.toThrow(expectCode('SESSION_QUERY_INVALID_FILTER'))
|
||||
expect(() => filterEventResults([], [{ kind: 'time', range: { to: Number.POSITIVE_INFINITY } }]))
|
||||
.toThrow(expectCode('SESSION_QUERY_INVALID_FILTER'))
|
||||
expect(() => filterEventResults([], [{ kind: 'surface', values: ['other' as never] }]))
|
||||
.toThrow(expectCode('SESSION_QUERY_INVALID_FILTER'))
|
||||
expect(() => filterSessionResults([], [{ kind: 'availability', values: ['other' as never] }]))
|
||||
.toThrow(expectCode('SESSION_QUERY_INVALID_FILTER'))
|
||||
})
|
||||
|
||||
it('handles absent range bounds and root/availability alternatives', () => {
|
||||
const record: SessionRecord = { header: header('root'), live: false, persisted: true }
|
||||
expect(filterSessionResults([record], [
|
||||
{ kind: 'parent', values: [null] },
|
||||
{ kind: 'cwd', values: [null] },
|
||||
{ kind: 'availability', values: ['persisted'] },
|
||||
])).toEqual([record])
|
||||
const event = { sessionId: record.header.id, seq: 2, type: 'user/message' as const, time: 4, surface: 'current' as const }
|
||||
expect(filterEventResults([event], [{ kind: 'seq', range: { to: 2 } }, { kind: 'time', range: { from: 4 } }])).toEqual([event])
|
||||
})
|
||||
})
|
||||
|
||||
describe('logical corpus reads and traces', () => {
|
||||
it('lists, classifies, reads, and traces a live session using detached records', async () => {
|
||||
const ctx = await liveContext({ readWindowMax: 2 })
|
||||
const session = ctx.sessions.create(SessionId('live'), { meta: { createdAt: 20, cwd: '/work' } })
|
||||
const original = session.append('user/message', { content: [{ type: 'text', text: 'original' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
|
||||
const chunk = session.append('assistant/chunk', { turn: 1, step: 1, chunk: { type: 'text-delta', index: 0, text: 'answer' } })
|
||||
const answer = session.append('assistant/message', { turn: 1, step: 1, content: [{ type: 'text', text: 'answer' }] }, { surfaceOp: 'append', sourceEventSeqs: [chunk.seq] })
|
||||
const summary = session.append('assistant/message', { turn: 1, step: 2, content: [{ type: 'text', text: 'summary' }] }, { surfaceOp: { op: 'replace', start: original.seq, end: original.seq }, sourceEventSeqs: [original.seq] })
|
||||
const resummary = session.append('assistant/message', { turn: 1, step: 3, content: [{ type: 'text', text: 'resummary' }] }, { surfaceOp: { op: 'replace', start: summary.seq, end: answer.seq }, sourceEventSeqs: [summary.seq, answer.seq] })
|
||||
|
||||
const listed = await ctx.sessionQuery.listSessions()
|
||||
expect(listed).toEqual([{ header: session.header, live: true, persisted: false }])
|
||||
listed[0]!.header.createdAt = -1
|
||||
expect(session.header.createdAt).toBe(20)
|
||||
expect((await ctx.sessionQuery.listEvents(session.id)).map(event => event.surface))
|
||||
.toEqual(['shadowed', 'log-only', 'shadowed', 'shadowed', 'current'])
|
||||
|
||||
const window = await ctx.sessionQuery.readEvent({ sessionId: session.id, seq: answer.seq, before: 2, after: 2 })
|
||||
expect([window.startSeq, window.endSeq]).toEqual([0, 4])
|
||||
expect(window.target.seq).toBe(answer.seq)
|
||||
if (window.events[0]?.type !== 'user/message') throw new Error('expected user message')
|
||||
window.events[0].data.content = []
|
||||
expect(session.events[0]?.type === 'user/message' && session.events[0].data.content).toHaveLength(1)
|
||||
|
||||
await expect(ctx.sessionQuery.traceEvent(session.id, original.seq)).resolves.toMatchObject({
|
||||
shadowedBy: summary.seq,
|
||||
replacementChain: [summary.seq, resummary.seq],
|
||||
referencedBy: [summary.seq],
|
||||
})
|
||||
await expect(ctx.sessionQuery.traceEvent(session.id, summary.seq)).resolves.toMatchObject({
|
||||
shadows: [original.seq],
|
||||
references: [original.seq],
|
||||
referencedBy: [resummary.seq],
|
||||
})
|
||||
await expect(ctx.sessionQuery.traceEvent(session.id, chunk.seq)).resolves.toMatchObject({ referencedBy: [answer.seq] })
|
||||
await expect(ctx.sessionQuery.readEvent({ sessionId: session.id, seq: 99 })).rejects.toThrow(expectCode('SESSION_QUERY_EVENT_NOT_FOUND'))
|
||||
await expect(ctx.sessionQuery.readEvent({ sessionId: session.id, seq: 0, before: 3 })).rejects.toThrow(expectCode('SESSION_QUERY_INVALID_WINDOW'))
|
||||
await expect(ctx.sessionQuery.traceEvent(session.id, 99)).rejects.toThrow(expectCode('SESSION_QUERY_EVENT_NOT_FOUND'))
|
||||
})
|
||||
|
||||
it('turns malformed replacement logs into typed surface failures', async () => {
|
||||
const ctx = await liveContext()
|
||||
const session = ctx.sessions.create(SessionId('bad-surface'))
|
||||
session.append('assistant/message', { turn: 1, step: 1, content: [] }, {
|
||||
surfaceOp: { op: 'replace', start: 9, end: 9 },
|
||||
sourceEventSeqs: [],
|
||||
})
|
||||
await expect(ctx.sessionQuery.listEvents(session.id)).rejects.toThrow(expectCode('SESSION_QUERY_INVALID_SURFACE'))
|
||||
})
|
||||
|
||||
it('returns complete, partial, deterministic, and cycle-checked lineage', async () => {
|
||||
const ctx = await liveContext()
|
||||
const root = ctx.sessions.create(SessionId('root'), { meta: { createdAt: 1 } })
|
||||
const second = ctx.sessions.create(SessionId('second'), { meta: { createdAt: 2, parentSession: root.id } })
|
||||
const first = ctx.sessions.create(SessionId('first'), { meta: { createdAt: 2, parentSession: root.id } })
|
||||
const grandchild = ctx.sessions.create(SessionId('grandchild'), { meta: { createdAt: 3, parentSession: first.id } })
|
||||
const partial = ctx.sessions.create(SessionId('partial'), { meta: { createdAt: 4, parentSession: SessionId('missing') } })
|
||||
|
||||
const trace = await ctx.sessionQuery.traceSession(grandchild.id)
|
||||
expect(trace.parents.map(record => record.header.id)).toEqual([first.id, root.id])
|
||||
expect(trace.root?.header.id).toBe(root.id)
|
||||
const rootTrace = await ctx.sessionQuery.traceSession(root.id)
|
||||
expect(rootTrace.children.map(node => node.session.header.id)).toEqual([first.id, second.id])
|
||||
expect(rootTrace.children[0]?.children[0]?.session.header.id).toBe(grandchild.id)
|
||||
await expect(ctx.sessionQuery.traceSession(partial.id)).resolves.toMatchObject({ unresolvedParentId: SessionId('missing') })
|
||||
await expect(ctx.sessionQuery.traceSession(SessionId('absent'))).rejects.toThrow(expectCode('SESSION_QUERY_SESSION_NOT_FOUND'))
|
||||
|
||||
const cyclic = await liveContext()
|
||||
const a = new Session(SessionId('a'), [], header('a', 1, { parentSession: SessionId('b') }))
|
||||
const b = new Session(SessionId('b'), [], header('b', 2, { parentSession: SessionId('a') }))
|
||||
cyclic.sessions.enter(a)
|
||||
cyclic.sessions.enter(b)
|
||||
await expect(cyclic.sessionQuery.traceSession(a.id)).rejects.toThrow(expectCode('SESSION_QUERY_INVALID_LINEAGE'))
|
||||
})
|
||||
|
||||
it('uses live content over a matching persisted base and scopes persistence failures', async () => {
|
||||
const common = header('same', 5, { cwd: '/w' })
|
||||
const persistedOnly = header('persisted', 1)
|
||||
TestPersistence.reset([
|
||||
{ meta: common, events: eventLog('persisted version') },
|
||||
{ meta: persistedOnly, events: eventLog('persisted only') },
|
||||
])
|
||||
const ctx = await liveContext()
|
||||
const live = ctx.sessions.create(common.id, { meta: { createdAt: common.createdAt, cwd: '/w' } })
|
||||
live.append('user/message', { content: [{ type: 'text', text: 'live version' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
|
||||
const persistenceFiber = await ctx.plugin(TestPersistence)
|
||||
await expect(ctx.sessionQuery.listEvents(SessionId('not-listed')))
|
||||
.rejects.toThrow(expectCode('SESSION_QUERY_SESSION_NOT_FOUND'))
|
||||
|
||||
const records = await ctx.sessionQuery.listSessions()
|
||||
expect(records.map(record => [record.header.id, record.live, record.persisted])).toEqual([
|
||||
[common.id, true, true],
|
||||
[persistedOnly.id, false, true],
|
||||
])
|
||||
const liveWindow = await ctx.sessionQuery.readEvent({ sessionId: common.id, seq: 0 })
|
||||
expect(liveWindow.target.type === 'user/message' && liveWindow.target.data.content[0]).toMatchObject({ text: 'live version' })
|
||||
await expect(ctx.sessionQuery.readEvent({ sessionId: persistedOnly.id, seq: 0 }))
|
||||
.resolves.toMatchObject({ session: { persisted: true } })
|
||||
|
||||
TestPersistence.listFailure = new Error('list unavailable')
|
||||
await expect(ctx.sessionQuery.listEvents(common.id)).resolves.toHaveLength(1)
|
||||
await expect(ctx.sessionQuery.listSessions()).rejects.toThrow(expectCode('SESSION_QUERY_PERSISTENCE_FAILED'))
|
||||
TestPersistence.listFailure = undefined
|
||||
TestPersistence.loadFailure = new Error('load unavailable')
|
||||
await expect(ctx.sessionQuery.listEvents(persistedOnly.id)).rejects.toThrow(expectCode('SESSION_QUERY_PERSISTENCE_FAILED'))
|
||||
TestPersistence.loadFailure = new SessionQueryError('typed load failure', 'SESSION_QUERY_TEST_FAILURE')
|
||||
await expect(ctx.sessionQuery.listEvents(persistedOnly.id)).rejects.toThrow(expectCode('SESSION_QUERY_TEST_FAILURE'))
|
||||
|
||||
await persistenceFiber.dispose()
|
||||
TestPersistence.loadFailure = undefined
|
||||
await expect(ctx.sessionQuery.listSessions()).resolves.toEqual([{ header: common, live: true, persisted: false }])
|
||||
})
|
||||
|
||||
it('rejects immutable source header conflicts', async () => {
|
||||
TestPersistence.reset([{ meta: header('conflict', 1, { cwd: '/persisted' }), events: eventLog() }])
|
||||
const ctx = await liveContext()
|
||||
ctx.sessions.create(SessionId('conflict'), { meta: { createdAt: 1, cwd: '/live' } })
|
||||
await ctx.plugin(TestPersistence)
|
||||
await expect(ctx.sessionQuery.listSessions()).rejects.toThrow(expectCode('SESSION_QUERY_SOURCE_CONFLICT'))
|
||||
})
|
||||
})
|
||||
|
||||
describe('provider selection and synchronization', () => {
|
||||
it('selects one usable provider, validates requests/pages, and disposes registration', async () => {
|
||||
const ctx = await liveContext({ defaultLimit: 2, maxLimit: 3 })
|
||||
const session = ctx.sessions.create(SessionId('s'))
|
||||
session.append('user/message', { content: [{ type: 'text', text: 'hello' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
|
||||
const provider = new FakeProvider()
|
||||
const dispose = ctx.sessionQuery.registerSearchProvider(provider)
|
||||
const record: SessionRecord = { header: structuredClone(session.header), live: true, persisted: false }
|
||||
const bestMatch = { sessionId: session.id, seq: 0, type: 'user/message' as const, time: session.events[0]!.time, surface: 'current' as const, snippet: 'hello' }
|
||||
provider.sessionPage = { providerId: provider.id, items: [
|
||||
{ ...record, bestMatch }, { ...record, bestMatch }, { ...record, bestMatch },
|
||||
], nextCursor: 'next' }
|
||||
|
||||
const page = await ctx.sessionQuery.searchSessions({ query: ' hello ', sessionFilters: [{ kind: 'availability', values: ['live'] }] })
|
||||
expect(page.items).toHaveLength(2)
|
||||
expect(provider.sessionRequests[0]).toMatchObject({ query: 'hello', limit: 2 })
|
||||
expect(provider.live.get(session.id)?.documents[0]?.text).toBe('hello')
|
||||
await expect(ctx.sessionQuery.searchSessions({ query: ' ' })).rejects.toThrow(expectCode('SESSION_QUERY_INVALID_QUERY'))
|
||||
await expect(ctx.sessionQuery.searchSessions({ query: 'x', limit: 4 })).rejects.toThrow(expectCode('SESSION_QUERY_INVALID_LIMIT'))
|
||||
provider.eventPage = { providerId: 'wrong', items: [] }
|
||||
await expect(ctx.sessionQuery.searchEvents({ sessionId: session.id, query: 'x' })).rejects.toThrow(expectCode('SESSION_QUERY_PROVIDER_ERROR'))
|
||||
|
||||
provider.eventPage = { providerId: provider.id, items: [] }
|
||||
await expect(ctx.sessionQuery.searchEvents({ sessionId: session.id, query: 'x', limit: 1 }, { signal: new AbortController().signal }))
|
||||
.resolves.toMatchObject({ providerId: provider.id })
|
||||
|
||||
dispose()
|
||||
await expect(ctx.sessionQuery.searchSessions({ query: 'x' })).rejects.toThrow(expectCode('SESSION_QUERY_PROVIDER_UNAVAILABLE'))
|
||||
})
|
||||
|
||||
it('coalesces concurrent synchronization and supports cancellation while provider search is pending', async () => {
|
||||
const ctx = await liveContext()
|
||||
const session = ctx.sessions.create(SessionId('coalesce'))
|
||||
session.append('user/message', { content: [{ type: 'text', text: 'x' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
|
||||
const provider = new FakeProvider()
|
||||
ctx.sessionQuery.registerSearchProvider(provider)
|
||||
|
||||
let releaseLive!: () => void
|
||||
const liveBarrier = new Promise<void>((resolve) => { releaseLive = resolve })
|
||||
let replacements = 0
|
||||
provider.replaceLive = async (snapshot) => {
|
||||
replacements += 1
|
||||
await liveBarrier
|
||||
provider.live.set(snapshot.session.header.id, structuredClone(snapshot))
|
||||
}
|
||||
const first = ctx.sessionQuery.searchEvents({ sessionId: session.id, query: 'x' })
|
||||
const second = ctx.sessionQuery.searchEvents({ sessionId: session.id, query: 'x' })
|
||||
await Promise.resolve()
|
||||
releaseLive()
|
||||
await Promise.all([first, second])
|
||||
expect(replacements).toBe(1)
|
||||
|
||||
session.append('user/message', { content: [{ type: 'text', text: 'y' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
|
||||
let releaseCorpus!: () => void
|
||||
const corpusBarrier = new Promise<void>((resolve) => { releaseCorpus = resolve })
|
||||
let corpusReplacements = 0
|
||||
provider.replaceLive = async (snapshot) => {
|
||||
corpusReplacements += 1
|
||||
await corpusBarrier
|
||||
provider.live.set(snapshot.session.header.id, structuredClone(snapshot))
|
||||
}
|
||||
const crossFirst = ctx.sessionQuery.searchSessions({ query: 'x' })
|
||||
const crossSecond = ctx.sessionQuery.searchSessions({ query: 'x' })
|
||||
await Promise.resolve()
|
||||
releaseCorpus()
|
||||
await Promise.all([crossFirst, crossSecond])
|
||||
expect(corpusReplacements).toBe(1)
|
||||
|
||||
let releaseSearch!: () => void
|
||||
const searchBarrier = new Promise<void>((resolve) => { releaseSearch = resolve })
|
||||
provider.searchSessions = async () => {
|
||||
await searchBarrier
|
||||
return { providerId: provider.id, items: [] }
|
||||
}
|
||||
const controller = new AbortController()
|
||||
const pending = ctx.sessionQuery.searchSessions({ query: 'x' }, { signal: controller.signal })
|
||||
await Promise.resolve()
|
||||
await Promise.resolve()
|
||||
controller.abort()
|
||||
await expect(pending).rejects.toThrow(expectCode('SESSION_QUERY_ABORTED'))
|
||||
releaseSearch()
|
||||
await Promise.resolve()
|
||||
|
||||
provider.searchSessions = () => Promise.reject(new Error('search failed'))
|
||||
await expect(ctx.sessionQuery.searchSessions({ query: 'x' }, { signal: new AbortController().signal }))
|
||||
.rejects.toThrow('search failed')
|
||||
})
|
||||
|
||||
it('searches a persisted target after corpus reconciliation', async () => {
|
||||
const persisted = header('event-persisted', 1)
|
||||
TestPersistence.reset([{ meta: persisted, events: eventLog('persisted target') }])
|
||||
const ctx = await liveContext()
|
||||
await ctx.plugin(TestPersistence)
|
||||
const provider = new FakeProvider()
|
||||
ctx.sessionQuery.registerSearchProvider(provider)
|
||||
|
||||
await expect(ctx.sessionQuery.searchEvents({ sessionId: persisted.id, query: 'target' }))
|
||||
.resolves.toMatchObject({ providerId: provider.id })
|
||||
expect(provider.persisted.get(persisted.id)?.documents[0]?.text).toBe('persisted target')
|
||||
})
|
||||
|
||||
it('fails loudly for duplicate, configured, unavailable, and ambiguous providers', async () => {
|
||||
const ctx = await liveContext()
|
||||
const first = new FakeProvider('first')
|
||||
ctx.sessionQuery.registerSearchProvider(first)
|
||||
expect(() => ctx.sessionQuery.registerSearchProvider(new FakeProvider('first'))).toThrow(expectCode('SESSION_QUERY_DUPLICATE_PROVIDER'))
|
||||
const second = new FakeProvider('second')
|
||||
ctx.sessionQuery.registerSearchProvider(second)
|
||||
await expect(ctx.sessionQuery.searchSessions({ query: 'x' })).rejects.toThrow(expectCode('SESSION_QUERY_PROVIDER_AMBIGUOUS'))
|
||||
|
||||
const configured = await liveContext({ searchProvider: 'chosen' })
|
||||
await expect(configured.sessionQuery.searchSessions({ query: 'x' })).rejects.toThrow(expectCode('SESSION_QUERY_PROVIDER_CONFIGURED_MISSING'))
|
||||
const chosen = new FakeProvider('chosen')
|
||||
chosen.statusValue = { available: false, reason: 'unavailable' }
|
||||
configured.sessionQuery.registerSearchProvider(chosen)
|
||||
await expect(configured.sessionQuery.searchSessions({ query: 'x' })).rejects.toThrow(expectCode('SESSION_QUERY_PROVIDER_CONFIGURED_UNAVAILABLE'))
|
||||
chosen.statusValue = { available: true }
|
||||
await expect(configured.sessionQuery.searchSessions({ query: 'x' })).resolves.toMatchObject({ providerId: 'chosen' })
|
||||
})
|
||||
|
||||
it('removes provider registrations with their contributing fiber', async () => {
|
||||
const ctx = await liveContext()
|
||||
const fiber = await ctx.plugin(Object.assign((inner: Context) => {
|
||||
inner.sessionQuery.registerSearchProvider(new FakeProvider('scoped'))
|
||||
}, { inject: ['sessionQuery'] }))
|
||||
await expect(ctx.sessionQuery.searchSessions({ query: 'x' })).resolves.toMatchObject({ providerId: 'scoped' })
|
||||
await fiber.dispose()
|
||||
await expect(ctx.sessionQuery.searchSessions({ query: 'x' })).rejects.toThrow(expectCode('SESSION_QUERY_PROVIDER_UNAVAILABLE'))
|
||||
})
|
||||
|
||||
it('reconciles persisted bases and live overrides, reuses fingerprints, and hides rows on unmount', async () => {
|
||||
const persisted = header('persisted', 1)
|
||||
const overlaid = header('overlaid', 1)
|
||||
TestPersistence.reset([
|
||||
{ meta: persisted, events: eventLog('persisted') },
|
||||
{ meta: overlaid, events: eventLog('base') },
|
||||
])
|
||||
const ctx = await liveContext()
|
||||
const live = ctx.sessions.create(overlaid.id, { meta: { createdAt: overlaid.createdAt } })
|
||||
live.append('user/message', { content: [{ type: 'text', text: 'override' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
|
||||
const persistenceFiber = await ctx.plugin(TestPersistence)
|
||||
const provider = new FakeProvider()
|
||||
provider.failNextActive = true
|
||||
provider.persisted.set(SessionId('stale'), { session: { header: header('stale'), live: false, persisted: true }, fingerprint: 'stale', documents: [] })
|
||||
ctx.sessionQuery.registerSearchProvider(provider)
|
||||
|
||||
await ctx.sessionQuery.searchSessions({ query: 'x' })
|
||||
expect(provider.persisted.get(persisted.id)?.documents[0]?.text).toBe('persisted')
|
||||
expect(provider.live.get(overlaid.id)?.documents[0]?.text).toBe('override')
|
||||
expect(provider.removedPersisted).toEqual([SessionId('stale')])
|
||||
expect(provider.activeHistory.at(-1)).toBe(true)
|
||||
const fingerprint = provider.persisted.get(persisted.id)?.fingerprint
|
||||
await ctx.sessionQuery.searchSessions({ query: 'x' })
|
||||
expect(provider.persisted.get(persisted.id)?.fingerprint).toBe(fingerprint)
|
||||
|
||||
const announced = header('announced', 3)
|
||||
TestPersistence.entries.set(announced.id, { meta: announced, events: eventLog('announced') })
|
||||
await ctx.parallel('session/persisted', announced, { kind: 'append', fromSeq: 0, toSeq: 0 })
|
||||
await ctx.sessionQuery.searchSessions({ query: 'x' })
|
||||
expect(provider.persisted.get(announced.id)?.documents[0]?.text).toBe('announced')
|
||||
|
||||
provider.failNextActive = true
|
||||
await persistenceFiber.dispose()
|
||||
await ctx.sessionQuery.searchSessions({ query: 'x' })
|
||||
expect(provider.activeHistory.at(-1)).toBe(false)
|
||||
expect(provider.persisted.has(persisted.id)).toBe(true)
|
||||
})
|
||||
|
||||
it('synchronizes only a live target for event search and retries dirty failures', async () => {
|
||||
const ctx = await liveContext()
|
||||
const session = ctx.sessions.create(SessionId('target'))
|
||||
session.append('user/message', { content: [{ type: 'text', text: 'one' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
|
||||
const provider = new FakeProvider()
|
||||
ctx.sessionQuery.registerSearchProvider(provider)
|
||||
|
||||
await ctx.sessionQuery.searchEvents({ sessionId: session.id, query: 'one' })
|
||||
expect(provider.live.get(session.id)?.documents[0]?.text).toBe('one')
|
||||
session.append('user/message', { content: [{ type: 'text', text: 'two' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
|
||||
provider.failNextLive = true
|
||||
await expect(ctx.sessionQuery.searchEvents({ sessionId: session.id, query: 'two' })).rejects.toThrow(expectCode('SESSION_QUERY_INDEX_FAILED'))
|
||||
await expect(ctx.sessionQuery.searchEvents({ sessionId: session.id, query: 'two' })).resolves.toMatchObject({ providerId: provider.id })
|
||||
expect(provider.live.get(session.id)?.documents.map(document => document.text)).toEqual(['one', 'two'])
|
||||
|
||||
const controller = new AbortController()
|
||||
controller.abort()
|
||||
await expect(ctx.sessionQuery.searchEvents({ sessionId: session.id, query: 'x' }, { signal: controller.signal }))
|
||||
.rejects.toThrow(expectCode('SESSION_QUERY_ABORTED'))
|
||||
await expect(ctx.sessionQuery.searchEvents({ sessionId: SessionId('missing'), query: 'x' }))
|
||||
.rejects.toThrow(expectCode('SESSION_QUERY_SESSION_NOT_FOUND'))
|
||||
})
|
||||
|
||||
it('removes a disposed live override and reveals the provider base', async () => {
|
||||
const persisted = header('fallback', 1)
|
||||
TestPersistence.reset([{ meta: persisted, events: eventLog('base') }])
|
||||
const ctx = await liveContext()
|
||||
await ctx.plugin(TestPersistence)
|
||||
let session!: Session
|
||||
const liveFiber = await ctx.plugin(Object.assign((inner: Context) => {
|
||||
session = inner.sessions.create(persisted.id, { meta: { createdAt: persisted.createdAt } })
|
||||
session.append('user/message', { content: [{ type: 'text', text: 'live' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
|
||||
}, { inject: ['sessions'] }))
|
||||
const provider = new FakeProvider()
|
||||
ctx.sessionQuery.registerSearchProvider(provider)
|
||||
await ctx.sessionQuery.searchSessions({ query: 'x' })
|
||||
expect(provider.live.has(session.id)).toBe(true)
|
||||
|
||||
await liveFiber.dispose()
|
||||
await Promise.resolve()
|
||||
await ctx.sessionQuery.searchSessions({ query: 'x' })
|
||||
expect(provider.removedLive).toContain(session.id)
|
||||
expect(provider.live.has(session.id)).toBe(false)
|
||||
expect(provider.persisted.get(session.id)?.documents[0]?.text).toBe('base')
|
||||
})
|
||||
|
||||
it('retries failed persisted reconciliation without affecting canonical writes', async () => {
|
||||
const persisted = header('retry', 1)
|
||||
TestPersistence.reset([{ meta: persisted, events: eventLog('retry') }])
|
||||
const ctx = await liveContext()
|
||||
await ctx.plugin(TestPersistence)
|
||||
const provider = new FakeProvider()
|
||||
provider.failNextPersisted = true
|
||||
ctx.sessionQuery.registerSearchProvider(provider)
|
||||
|
||||
await expect(ctx.sessionQuery.searchSessions({ query: 'x' })).rejects.toThrow(expectCode('SESSION_QUERY_INDEX_FAILED'))
|
||||
await expect(ctx.sessionQuery.searchSessions({ query: 'x' })).resolves.toMatchObject({ providerId: provider.id })
|
||||
expect(provider.persisted.get(persisted.id)?.documents[0]?.text).toBe('retry')
|
||||
})
|
||||
})
|
||||
|
||||
describe('semantic text extractors', () => {
|
||||
it('indexes core semantic text and excludes chunks and structural events', async () => {
|
||||
const ctx = await liveContext()
|
||||
const session = ctx.sessions.create(SessionId('semantic'))
|
||||
const nested: ContentBlock[] = [
|
||||
{ type: 'text', text: 'visible' },
|
||||
{ type: 'reasoning', text: 'thinking' },
|
||||
{ type: 'tool-call', id: CallId('block-call'), name: 'block-tool', arguments: '{"x":1}' },
|
||||
{ type: 'tool-result', toolCallId: CallId('block-call'), content: [{ type: 'text', text: 'block-result' }] },
|
||||
]
|
||||
session.append('user/message', { content: nested, source: { kind: 'user' } }, { surfaceOp: 'append' })
|
||||
session.append('prompt/blocked', { content: [{ type: 'text', text: 'blocked prompt' }], source: { kind: 'user' }, reason: 'policy reason' })
|
||||
session.append('tool/call', { turn: 1, step: 1, callId: CallId('c1'), name: 'shell', arguments: '{"cmd":"pwd"}' })
|
||||
session.append('tool/result', { turn: 1, step: 1, callId: CallId('c1'), content: [{ type: 'text', text: 'tool output' }], isError: true, error: { name: 'ToolError', code: 'DENIED' } }, { surfaceOp: 'append' })
|
||||
session.append('todo/write', { todos: [{ content: 'finish tests', status: 'in_progress' }] })
|
||||
session.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, message: 'model failed', code: 'MODEL' } })
|
||||
session.append('turn/end', { turn: 1, reason: { kind: 'error', step: 1, message: 'uncoded failure' } })
|
||||
session.append('turn/end', { turn: 2, reason: { kind: 'aborted' } })
|
||||
session.append('turn/end', { turn: 3, reason: { kind: 'aborted', reason: 'cancelled' } })
|
||||
session.append('turn/end', { turn: 4, reason: { kind: 'rejected', reason: 'rejected detail' } })
|
||||
session.append('turn/end', { turn: 5, reason: { kind: 'disposed' } })
|
||||
session.append('turn/end', { turn: 6, reason: { kind: 'max-tokens' } })
|
||||
session.append('turn/end', { turn: 7, reason: { kind: 'interrupted' } })
|
||||
session.append('turn/end', { turn: 8, reason: { kind: 'completed' } })
|
||||
session.append('tool/result', { turn: 1, step: 2, callId: CallId('c2'), content: [], isError: false }, { surfaceOp: 'append' })
|
||||
session.append('assistant/chunk', { turn: 1, step: 1, chunk: { type: 'text-delta', index: 0, text: 'raw chunk' } })
|
||||
session.append('step/start', { turn: 1, step: 2 })
|
||||
const provider = new FakeProvider()
|
||||
ctx.sessionQuery.registerSearchProvider(provider)
|
||||
|
||||
await ctx.sessionQuery.searchEvents({ sessionId: session.id, query: 'x' })
|
||||
const documents = provider.live.get(session.id)?.documents ?? []
|
||||
expect(documents.map(document => document.seq)).toEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
|
||||
expect(documents.map(document => document.text).join('\n')).toContain('visible\nthinking\nblock-tool\n{"x":1}\nblock-result')
|
||||
expect(documents.map(document => document.text).join('\n')).toContain('blocked prompt\npolicy reason')
|
||||
expect(documents.map(document => document.text).join('\n')).toContain('ToolError\nDENIED')
|
||||
expect(documents.map(document => document.text).join('\n')).toContain('in_progress finish tests')
|
||||
expect(documents.map(document => document.text).join('\n')).toContain('error\nmodel failed\nMODEL')
|
||||
expect(documents.map(document => document.text).join('\n')).toContain('aborted\ncancelled')
|
||||
expect(documents.map(document => document.text).join('\n')).toContain('rejected\nrejected detail')
|
||||
expect(documents.map(document => document.text).join('\n')).toContain('disposed\nmax-tokens\ninterrupted')
|
||||
expect(documents.map(document => document.text).join('\n')).not.toContain('raw chunk')
|
||||
})
|
||||
|
||||
it('supports versioned effect-scoped custom event and content extractors', async () => {
|
||||
const ctx = await liveContext()
|
||||
const session = ctx.sessions.create(SessionId('custom'))
|
||||
session.append('test/note', { note: 'event note' })
|
||||
session.append('user/message', { content: [{ type: 'test/text', value: 'block note' }], source: { kind: 'user' } }, { surfaceOp: 'append' })
|
||||
const provider = new FakeProvider()
|
||||
ctx.sessionQuery.registerSearchProvider(provider)
|
||||
let disposeEvent!: () => void
|
||||
let disposeContent!: () => void
|
||||
const extractorFiber = await ctx.plugin(Object.assign((inner: Context) => {
|
||||
disposeEvent = inner.sessionQuery.registerEventTextExtractor('test/note', { version: 'event-v1', extract: event => [event.data.note] })
|
||||
disposeContent = inner.sessionQuery.registerContentTextExtractor('test/text', { version: 'block-v1', extract: block => [block.value] })
|
||||
}, { inject: ['sessionQuery'] }))
|
||||
|
||||
await ctx.sessionQuery.searchEvents({ sessionId: session.id, query: 'x' })
|
||||
const first = provider.live.get(session.id)
|
||||
expect(first?.documents.map(document => document.text)).toEqual(['event note', 'block note'])
|
||||
expect(() => ctx.sessionQuery.registerEventTextExtractor('test/note', { version: 'v2', extract: () => [] }))
|
||||
.toThrow(expectCode('SESSION_QUERY_DUPLICATE_EXTRACTOR'))
|
||||
expect(() => ctx.sessionQuery.registerContentTextExtractor('test/text', { version: 'block-v2', extract: () => [] }))
|
||||
.toThrow(expectCode('SESSION_QUERY_DUPLICATE_EXTRACTOR'))
|
||||
expect(() => ctx.sessionQuery.registerContentTextExtractor('test/text', { version: ' ', extract: () => [] }))
|
||||
.toThrow(expectCode('SESSION_QUERY_INVALID_EXTRACTOR'))
|
||||
|
||||
disposeEvent()
|
||||
disposeContent()
|
||||
await ctx.sessionQuery.searchEvents({ sessionId: session.id, query: 'x' })
|
||||
const second = provider.live.get(session.id)
|
||||
expect(second?.documents).toEqual([])
|
||||
expect(second?.fingerprint).not.toBe(first?.fingerprint)
|
||||
await extractorFiber.dispose()
|
||||
})
|
||||
})
|
||||
|
||||
describe('configuration', () => {
|
||||
it('rejects an impossible default page size and exposes typed errors', async () => {
|
||||
const ctx = new Context()
|
||||
await ctx.plugin(SessionStore)
|
||||
await expect(ctx.plugin(SessionQueryService, { defaultLimit: 3, maxLimit: 2 }))
|
||||
.rejects.toThrow(expectCode('SESSION_QUERY_INVALID_CONFIG'))
|
||||
const error = new SessionQueryError('test', 'SESSION_QUERY_TEST')
|
||||
expect(error).toMatchObject({ name: 'SessionQueryError', code: 'SESSION_QUERY_TEST' })
|
||||
})
|
||||
|
||||
it('uses constructor defaults and removes the service on plugin disposal', async () => {
|
||||
const ctx = new Context()
|
||||
await ctx.plugin(SessionStore)
|
||||
const fiber = await ctx.plugin(SessionQueryService)
|
||||
const session = ctx.sessions.create(SessionId('defaults'))
|
||||
await expect(ctx.sessionQuery.readEvent({ sessionId: session.id, seq: 0, after: 51 }))
|
||||
.rejects.toThrow(expectCode('SESSION_QUERY_INVALID_WINDOW'))
|
||||
await fiber.dispose()
|
||||
expect(ctx.sessionQuery).toBeUndefined()
|
||||
|
||||
const direct = new Context()
|
||||
await direct.plugin(SessionStore)
|
||||
const service = new SessionQueryService(direct, {})
|
||||
const directSession = direct.sessions.create(SessionId('direct-defaults'))
|
||||
await expect(service.readEvent({ sessionId: directSession.id, seq: 0, before: 51 }))
|
||||
.rejects.toThrow(expectCode('SESSION_QUERY_INVALID_WINDOW'))
|
||||
await direct.fiber.dispose()
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user