Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 3 additions & 0 deletions config/scripts/vitest-sqlite-runtime-files.mjs
Original file line number Diff line number Diff line change
Expand Up @@ -126,7 +126,10 @@ export const SQLITE_RUNTIME_INCLUDE = [
'src/main/native-chat/agent-session-wire/structured-agent-session-provider-restore.test.ts',
'src/main/native-chat/agent-session-wire/structured-agent-session-provider-started-catalog.test.ts',
'src/main/native-chat/agent-session-wire/structured-agent-session-provider-started.test.ts',
'src/main/native-chat/agent-session-wire/structured-agent-session-queued-gate.test.ts',
'src/main/native-chat/agent-session-wire/structured-agent-session-queued-newer-orca.test.ts',
'src/main/native-chat/agent-session-wire/structured-agent-session-queued-pause-lift.test.ts',
'src/main/native-chat/agent-session-wire/structured-agent-session-queued-repeat-press.test.ts',
'src/main/native-chat/agent-session-wire/structured-agent-session-read-restore.test.ts',
'src/main/native-chat/agent-session-wire/structured-agent-session-readable-restorer.test.ts',
'src/main/native-chat/agent-session-wire/structured-agent-session-reasoning-sweep.test.ts',
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -25,6 +25,10 @@ export const commandReceiptResultSchema = z.discriminatedUnion('kind', [
epoch: z.string().min(1),
sequence: z.int().positive()
}),
z.strictObject({
kind: z.literal('queued-draft'),
messageId: z.string().min(1)
}),
z.strictObject({
kind: z.literal('no-op'),
outcome: z.discriminatedUnion('kind', [
Expand Down Expand Up @@ -75,7 +79,7 @@ export const commandReceiptSchema = z.discriminatedUnion('status', [

export type CommandReceipt = z.infer<typeof commandReceiptSchema>

/** Additive and inert until cutover; a version bump here would prevent older builds writing. */
/** Additive, so no version bump: one would stop older builds writing this database. */
export function ensureCommandReceiptsTable(db: Database.Database): void {
db.exec(`
CREATE TABLE IF NOT EXISTS agent_session_command_receipts (
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -202,6 +202,14 @@ describe('command receipt identity', () => {
})

describe('command receipt outcomes and lifetime', () => {
it('round trips a queued-draft pointer without retaining its body', () => {
const receipt = commandReceiptFixture({
result: { kind: 'queued-draft', messageId: 'draft-1' }
})
insert(receipt)
expect(read(receipt)).toEqual({ verdict: 'readable', receipt })
})

it.each([
{ kind: 'cancel', cancelled: false, turnId: 'turn-1' },
{ kind: 'cancel', cancelled: false },
Expand Down Expand Up @@ -242,6 +250,7 @@ describe('unreadable command receipts', () => {
['result_json', '{'],
['result_json', '{"kind":"journal-row","epoch":"e1","sequence":0}'],
['result_json', '{"kind":"future-result"}'],
['result_json', '{"kind":"queued-draft","messageId":""}'],
['result_json', null],
['status', 'pending'],
['method', ''],
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -20,7 +20,7 @@ import type { JournalRow } from './journal-row-schema'
import { JournalRowWriter } from './journal-row-writer'
import { JournalWriteQueue } from './journal-write-queue'
import { insertCommandReceiptIfAbsent, readCommandReceipt } from './command-receipt-table'
import { commandReceiptScope, type CommandReceiptResult } from './command-receipt-schema'
import { commandReceiptScope } from './command-receipt-schema'
import {
commandReceiptFixture,
writeCommandReceiptTestRecord
Expand Down Expand Up @@ -95,7 +95,6 @@ describe('command receipt transaction hook', () => {
it('commits through the existing row writer with a pointer to the row it assigned', async () => {
const queue = new JournalWriteQueue(identity.sessionId)
const committed: JournalRow[] = []
let result: CommandReceiptResult = { kind: 'journal-row', epoch: 'epoch-0', sequence: 99 }
const writer = new JournalRowWriter({
sessionId: identity.sessionId,
now: () => 1000,
Expand All @@ -108,10 +107,13 @@ describe('command receipt transaction hook', () => {
})
await writer.enqueue(
epochRow,
(_db, row) => {
result = { kind: 'journal-row', epoch: row.epoch, sequence: row.seq }
},
buildCommandReceiptTransaction(scope, () => ({ ...receipt, result }))
undefined,
buildCommandReceiptTransaction(scope, (row) => {
if (!row) {
throw new Error('expected the committed journal row')
}
return { ...receipt, result: { kind: 'journal-row', epoch: row.epoch, sequence: row.seq } }
})
)
expect(committed).toHaveLength(1)
expect(committed[0]).toEqual(epochRow(7, 1000))
Expand Down
Original file line number Diff line number Diff line change
@@ -1,6 +1,7 @@
import type { CommandReceipt, CommandReceiptScope } from './command-receipt-schema'
import { insertCommandReceiptIfAbsent, type CommandReceiptInsert } from './command-receipt-table'
import type { JournalOperationReceipt } from './journal-row-writer'
import type { JournalRow } from './journal-row-schema'

type CommandReceiptNotInserted = Extract<CommandReceiptInsert, { inserted: false }>

Expand All @@ -14,14 +15,14 @@ export class CommandReceiptExistsError extends Error {

export function buildCommandReceiptTransaction(
scope: CommandReceiptScope,
receipt: CommandReceipt | (() => CommandReceipt)
receipt: CommandReceipt | ((row?: JournalRow) => CommandReceipt)
): JournalOperationReceipt {
return {
write: (db) => {
write: (db, row) => {
const result = insertCommandReceiptIfAbsent(
db,
scope,
typeof receipt === 'function' ? receipt() : receipt
typeof receipt === 'function' ? receipt(row) : receipt
)
if (!result.inserted) {
throw new CommandReceiptExistsError(result)
Expand Down
15 changes: 12 additions & 3 deletions src/main/native-chat/agent-session-journal/journal-row-writer.ts
Original file line number Diff line number Diff line change
Expand Up @@ -11,14 +11,23 @@ import type { JournalWriteBody } from './journal-write-queue'
* nothing can interleave inside the transaction. */
export type JournalRowTransactionHook = (db: Database.Database, row: JournalRow) => void

/** An operation's ledger answer, committed with the journal write that makes it true: `write` runs
/** An operation's receipt, committed with the journal write that makes it true: `write` runs
* inside that transaction on the same connection, `committed` synchronously right after its
* COMMIT and never after a rollback. */
export type JournalOperationReceipt = {
write: (db: Database.Database) => void
write: (db: Database.Database, row?: JournalRow) => void
committed: () => void
}

export function composeJournalOperationReceipts(
...receipts: JournalOperationReceipt[]
): JournalOperationReceipt {
return {
write: (db, row) => receipts.forEach((receipt) => receipt.write(db, row)),
committed: () => receipts.forEach((receipt) => receipt.committed())
}
}

export type JournalRowWriterDeps = {
sessionId: string
now: () => number
Expand Down Expand Up @@ -55,7 +64,7 @@ export class JournalRowWriter {
this.deps.database().transaction((db) => {
insertJournalRow(db, this.deps.sessionId, row)
hook?.(db, row)
receipt?.write(db)
receipt?.write(db, row)
this.runBookkeeping(db, row)
})
} catch (error) {
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -142,3 +142,30 @@ describe('attachments at send admission', () => {
expect(result).toMatchObject({ ok: true, value: { submission: expect.anything() } })
})
})

it.each([undefined, 'queue-if-active'] as const)(
're-evaluates an unaccepted attachment refusal after the file returns (%s)',
async (delivery) => {
if (delivery) {
await rig.workingSend()
}
const body = textWith(storedPath('notes.txt'))
const clientOperationId = hostTestOperationId()
const fields = { body, ...(delivery ? { delivery } : {}) }
const params = {
envelope: rig.envelope(fields, 'agentSession.send', clientOperationId),
...fields,
userSend: true as const
}
expect(await rig.host.send(CALLER, params)).toMatchObject(EXPIRED)
expect(rig.store.readCommandReceipt({ kind: 'global' }, clientOperationId)).toEqual({
verdict: 'absent'
})
expect(
rig.store.listOperationRows().find((row) => row.operationId === clientOperationId)
).toBeUndefined()
await storeUpload('notes.txt')
expect(await rig.host.send(CALLER, params)).toMatchObject({ ok: true, replayed: false })
expect(await clientSend(body, delivery)).toMatchObject({ ok: true, replayed: false })
}
)
Original file line number Diff line number Diff line change
@@ -0,0 +1,181 @@
import { parseAgentSessionOperationTimestamp } from '../../../shared/agent-session-host-authority'
import { agentSessionLedgerRefusal } from '../../../shared/agent-session-mutation-envelope'
import {
agentSessionRefusalFromReference,
isAgentSessionRefusalError
} from '../../../shared/agent-session-wire-refusals'
import type { AgentSessionOperationOutcome } from '../../../shared/agent-session-operation-ledger'
import type { AgentSessionMutationResult } from '../../../shared/agent-session-wire'
import { commandReceiptScope } from '../agent-session-journal/command-receipt-schema'
import type { CommandReceipt } from '../agent-session-journal/command-receipt-schema'
import type { ExistingCommandReceipt } from '../agent-session-journal/command-receipt-table'
import { CommandReceiptExistsError } from '../agent-session-journal/command-receipt-transaction'
import {
AGENT_SESSION_NOT_ATTACHED,
refuseAgentSessionMutation
} from './structured-agent-session-mutation-refusals'
import type { AgentSessionMutationRequest } from './structured-agent-session-mutation-admission'
import { mutationTurnContext } from './structured-agent-session-mutation-turn-context'
import { runCommandReceiptMutation } from './structured-agent-session-command-receipt'
import {
agentSessionOperationOutcomeUnknown,
resolveAgentSessionReplayOutcome
} from './structured-agent-session-replay-outcome'

/** Submission-accepting plans use their effect's receipt, never a ledger reservation. */
export async function admitCommandReceiptMutation<TValue>(
request: AgentSessionMutationRequest<TValue>,
hostFingerprint: string
): Promise<AgentSessionMutationResult<TValue>> {
const { store, envelope, plan, callerKey } = request
if (parseAgentSessionOperationTimestamp(envelope.clientOperationId) === null) {
return refuseAgentSessionMutation(
agentSessionLedgerRefusal(envelope, {
decision: 'refused',
code: 'agent_session_operation_invalid',
details: { reason: 'operationIdInvalid' }
})
)
}
const record = store.getRecord(envelope.sessionId)
if (!record) {
return refuseAgentSessionMutation(AGENT_SESSION_NOT_ATTACHED)
}
let read
try {
read = store.readCommandReceipt(
commandReceiptScope(callerKey, plan.operationIdScope),
envelope.clientOperationId
)
} catch (error) {
request.logger.warn('reading a command receipt failed', {
scope: 'command-receipt-read',
sessionId: envelope.sessionId,
operationId: envelope.clientOperationId,
error
})
return unknown(request)
}
if (read.verdict !== 'absent') {
return answerCommandReceipt(request, hostFingerprint, read)
}
const prepared = await request.prepareSession?.('admit', record)
if (prepared && !prepared.ok) {
return prepared
}
const journal = request.journal()
const current = store.getRecord(envelope.sessionId)
if (!journal || !current) {
return refuseAgentSessionMutation(AGENT_SESSION_NOT_ATTACHED)
}
// These plans write only to the conversation, whose journal enforces the execution-host fence.
const context = mutationTurnContext(request, journal, current)
try {
const outcome = await runCommandReceiptMutation({
store,
operationCallerKey: callerKey,
fingerprint: hostFingerprint,
wakeDelivery: request.wakeDelivery,
envelope,
plan,
context
})
if ('committedReceipt' in outcome) {
return answerCommandReceipt(request, hostFingerprint, {
verdict: 'readable',
receipt: outcome.committedReceipt
})
}
return outcome.ok
? {
ok: true,
replayed: false,
fence: context.fence,
cursor: journal.cursor(),
value: outcome.value
}
: refuseAgentSessionMutation(outcome.refusal)
} catch (error) {
if (error instanceof CommandReceiptExistsError) {
return answerCommandReceipt(request, hostFingerprint, error.result.existing)
}
if (isAgentSessionRefusalError(error)) {
return refuseAgentSessionMutation(error.refusal)
}
throw error
}
}

async function answerCommandReceipt<TValue>(
request: AgentSessionMutationRequest<TValue>,
hostFingerprint: string,
read: ExistingCommandReceipt
): Promise<AgentSessionMutationResult<TValue>> {
const { envelope, plan } = request
if (read.verdict === 'unreadable') {
return unknown(request)
}
const { receipt } = read
if (receipt.fingerprint !== hostFingerprint) {
return refuseAgentSessionMutation(
agentSessionLedgerRefusal(envelope, {
decision: 'refused',
code: 'agent_session_operation_conflict',
details: { reason: 'operationIdReused' }
})
)
}
if (receipt.status === 'rejected') {
return refuseAgentSessionMutation(
agentSessionRefusalFromReference(
receipt.rejection.reference,
receipt.rejection.message ?? 'Operation was already refused.'
)
)
}
const record = request.store.getRecord(envelope.sessionId)
if (!record) {
return unknown(request)
}
const prepared = await request.prepareSession?.('replay', record)
if (prepared && !prepared.ok) {
return prepared
}
const journal = request.journal()
const current = request.store.getRecord(envelope.sessionId)
if (!journal || !current) {
return unknown(request)
}
const context = mutationTurnContext(request, journal, current)
const outcome = commandReceiptOutcome(receipt)
const replay = resolveAgentSessionReplayOutcome({
operationId: envelope.clientOperationId,
outcome,
reconstruct: () => plan.replay(context, outcome),
rerunWhenReplayMissing: plan.rerunWhenReplayMissing?.(context),
recoverUnknownFromDurableState: plan.recoverUnknownFromDurableState
})
// A missing result cannot undo durable acceptance, even if a later plan allows missing replays.
if (replay.decision !== 'replay') {
return replay.decision === 'refuse'
? refuseAgentSessionMutation(replay.refusal)
: unknown(request)
}
return {
ok: true,
replayed: true,
fence: context.fence,
cursor: journal.cursor(),
value: replay.value
}
}

function commandReceiptOutcome(receipt: CommandReceipt): AgentSessionOperationOutcome {
return { status: 'succeeded', sessionId: receipt.sessionId }
}

function unknown<TValue>(request: AgentSessionMutationRequest<TValue>) {
return refuseAgentSessionMutation(
agentSessionOperationOutcomeUnknown(request.envelope.clientOperationId)
)
}
Loading
Loading