Tianyi Cui
2093a8898b
The loop is now transmission-stateless; a request is a pure function of (session log, this step's rendered assembly, current AgentOptions): - The reconstruction boundary is step/start: the messages snapshot is taken in the same synchronous frame immediately before the step/start append, so the request's messages are exactly the derivation over events[0..stepStartSeq) — an inject() from an agent/request listener (or any concurrent task) lands after the boundary and joins the NEXT request. This changes behavior for a synchronous step/start session/event listener that appends content (master derived after the append, so such a listener could reach the current request): agent/pre-step is the sanctioned seam for current-request content. - agent/request is re-typed to config-only: (agent, turn, step, config: LlmCallConfig, next) → LlmCallConfig. The frozen seed comes from AgentOptions on a loop instance's first request (explicit options beat the logged baseline — fork overrides and resume reconfiguration stay correct) and from the log's folded header afterwards; listeners return a replacement to switch. Content shaping through the request is no longer expressible — model-visible content flows through the log channels. - recordRequestHeader appends whatever header event the request owes the log before dispatch: an 'initial'/'resume' snapshot anchoring each loop instance, a round-trip-verified delta on change, a 'fallback' snapshot when the encoding cannot express it. Session.requestHeader() is the log's incrementally-folded baseline. - Requests are deep-frozen before dispatch (deepFreeze exempts the AbortSignal — freezing one breaks AbortController.abort() outright); frozen + sessionId is the loop-built marker the dev invariant keys on. Ported from #162 and re-anchored on the log: the append-extension / frozen-end-to-end / compaction-resend / prompt-change property tests, plus new specs for the boundary semantics, resume anchoring, and the end-to-end theorem (every recorded request rebuilds byte-equal from the log alone). Live cache-hit e2e (request-cache.e2e.ts) verified against the real DeepSeek API. Snapshot goldens intentionally stale until the single re-record after the compact/summary envelope lands.
86 lines
3.9 KiB
TypeScript
86 lines
3.9 KiB
TypeScript
/**
|
|
* recordRequestHeader unit tests: exactly one of four things per request —
|
|
* an 'initial' snapshot (log has no header yet), a 'resume' snapshot (fresh
|
|
* loop instance over a log that has one), nothing (header unchanged), a
|
|
* round-tripping delta, or a 'fallback' snapshot when the delta encoding
|
|
* cannot express the change (pure tool reordering).
|
|
*/
|
|
|
|
import { describe, expect, it } from 'vitest'
|
|
import { Session, SessionId, canonicalHeader } from '@deepseek-ai/dsh-session'
|
|
import type { SessionEvent } from '@deepseek-ai/dsh-session'
|
|
import type { ToolSchema } from '@deepseek-ai/dsh-llm'
|
|
import { createTransmissionLog, recordRequestHeader } from '../src/request-log.ts'
|
|
|
|
function tool(name: string, description = 'd'): ToolSchema {
|
|
return { name, description, parameters: { type: 'object' } }
|
|
}
|
|
|
|
function openSession(id: string): Session {
|
|
const session = new Session(SessionId(id))
|
|
session.append('turn/start', { turn: 1, trigger: { kind: 'message', source: { kind: 'user' } } })
|
|
return session
|
|
}
|
|
|
|
function headerEvents(session: Session): SessionEvent[] {
|
|
return session.events.filter(e => e.type === 'request/header' || e.type === 'request/header-delta')
|
|
}
|
|
|
|
describe('recordRequestHeader', () => {
|
|
it("anchors a new conversation with an 'initial' snapshot, then logs nothing while unchanged", () => {
|
|
const session = openSession('rl-initial')
|
|
const state = createTransmissionLog()
|
|
const header = canonicalHeader({ config: { model: 'm' }, system: 's', tools: [tool('t')] })
|
|
|
|
recordRequestHeader(session, state, header)
|
|
const [first] = headerEvents(session)
|
|
expect(first?.type === 'request/header' && first.data.reason).toBe('initial')
|
|
|
|
recordRequestHeader(session, state, header)
|
|
expect(headerEvents(session)).toHaveLength(1)
|
|
})
|
|
|
|
it("anchors a fresh loop instance over an anchored log with a 'resume' snapshot, even unchanged", () => {
|
|
const session = openSession('rl-resume')
|
|
const header = canonicalHeader({ config: { model: 'm' }, system: 's' })
|
|
recordRequestHeader(session, createTransmissionLog(), header)
|
|
|
|
// A second instance (process restart / fork): the boundary itself is a
|
|
// recorded fact — snapshot appended even though the header is identical.
|
|
recordRequestHeader(session, createTransmissionLog(), header)
|
|
const events = headerEvents(session)
|
|
expect(events).toHaveLength(2)
|
|
expect(events[1]?.type === 'request/header' && events[1].data.reason).toBe('resume')
|
|
})
|
|
|
|
it('logs a round-tripping delta for a mid-run change, and the fold reproduces the header', () => {
|
|
const session = openSession('rl-delta')
|
|
const state = createTransmissionLog()
|
|
const first = canonicalHeader({ config: { model: 'm' }, system: 'a\nb', tools: [tool('t')] })
|
|
recordRequestHeader(session, state, first)
|
|
|
|
const second = canonicalHeader({ config: { model: 'm' }, system: 'a\nc', tools: [tool('t'), tool('u')] })
|
|
recordRequestHeader(session, state, second)
|
|
const events = headerEvents(session)
|
|
expect(events).toHaveLength(2)
|
|
expect(events[1]?.type).toBe('request/header-delta')
|
|
expect(session.requestHeader()).toEqual(second)
|
|
})
|
|
|
|
it("records a change the delta cannot express (pure reordering) as a 'fallback' snapshot", () => {
|
|
const session = openSession('rl-fallback')
|
|
const state = createTransmissionLog()
|
|
const first = canonicalHeader({ config: { model: 'm' }, tools: [tool('a'), tool('b')] })
|
|
recordRequestHeader(session, state, first)
|
|
|
|
const reordered = canonicalHeader({ config: { model: 'm' }, tools: [tool('b'), tool('a')] })
|
|
recordRequestHeader(session, state, reordered)
|
|
const events = headerEvents(session)
|
|
expect(events).toHaveLength(2)
|
|
expect(events[1]?.type === 'request/header' && events[1].data.reason).toBe('fallback')
|
|
// The fold still lands on the exact header — deltas are an encoding
|
|
// optimization, never a correctness dependency.
|
|
expect(session.requestHeader()).toEqual(reordered)
|
|
})
|
|
})
|