mirror of
https://github.com/stablyai/orca.git
synced 2026-11-18 03:45:08 +00:00
Derive chat status from named indexed populations
This commit is contained in:
@@ -7,9 +7,12 @@ import { memoryLatestAcceptedSendUnopened } from './context-epochs/journal-stop-
|
||||
import { readAgentJournalTurn } from '../../../shared/agent-session/lifecycle/agent-session-turn-record'
|
||||
import { compareAgentJournalItems } from '../../../shared/agent-session/journal/agent-session-journal-position'
|
||||
import { journalInputPresentationMember } from './input-order/journal-input-obligations'
|
||||
import { memoryHasStatusRequestItem, memoryFailedStatusItems } from './journal-status-request-items'
|
||||
import { memoryJournalStatusItems } from './journal-status-items'
|
||||
|
||||
export const memoryJournalStateQueries: JournalStateQueries = {
|
||||
hasStatusRequestItem: memoryHasStatusRequestItem,
|
||||
failedStatusItems: memoryFailedStatusItems,
|
||||
statusItems: memoryJournalStatusItems,
|
||||
latestContextClearSequence(state) {
|
||||
return latestAgentSessionContextClearSequence(memoryJournalMap(state.items).values())
|
||||
|
||||
@@ -15,6 +15,7 @@ import type { JournalThreadGoalSource } from './projection/journal-thread-goal-s
|
||||
import { readJournalInput, type JournalInputReader } from './journal-input-reads'
|
||||
import { readJournalUsageLimitCut, readJournalOrcaStopCut } from './journal-status-cuts'
|
||||
import type { NativeChatUsageLimitCut } from '../../../shared/native-chat/native-chat-usage-limit-cut'
|
||||
import { readJournalStatusState, type JournalStatusState } from './journal-status-state'
|
||||
import type { NativeChatOrcaStopCut } from '../../../shared/native-chat/native-chat-orca-stop-cut'
|
||||
|
||||
/** Which items a visit decodes; a database serves only the named kinds, in sequence order. */
|
||||
@@ -24,6 +25,7 @@ export type JournalItemFilter = {
|
||||
|
||||
/** Reads a chat answers from its database; scans are filtered so none decodes the whole chat. */
|
||||
export type AgentSessionJournalReads = {
|
||||
statusState(currentFence?: number | null): Promise<JournalStatusState>
|
||||
input: JournalInputReader
|
||||
usageLimitCut(): Promise<NativeChatUsageLimitCut | null>
|
||||
orcaStopCut(): Promise<NativeChatOrcaStopCut | null>
|
||||
@@ -59,7 +61,7 @@ type FoldedJournalReads = {
|
||||
[
|
||||
K in Exclude<
|
||||
keyof AgentSessionJournalReads,
|
||||
'visitItems' | 'contextFloor' | 'input' | 'usageLimitCut' | 'orcaStopCut'
|
||||
'visitItems' | 'contextFloor' | 'input' | 'usageLimitCut' | 'orcaStopCut' | 'statusState'
|
||||
>
|
||||
]: (
|
||||
...args: Parameters<AgentSessionJournalReads[K]>
|
||||
@@ -85,6 +87,7 @@ export function foldedJournalReads(
|
||||
}
|
||||
}
|
||||
return {
|
||||
statusState: now((fence?: number | null) => readJournalStatusState(state(), fence)),
|
||||
input: async (operation) => readJournalInput(state(), operation),
|
||||
usageLimitCut: now(() => readJournalUsageLimitCut(state())),
|
||||
orcaStopCut: now(() => readJournalOrcaStopCut(state())),
|
||||
|
||||
@@ -21,6 +21,7 @@ import { readJournalSqlInput } from './journal-sql-input-reads'
|
||||
import { JournalSqlReducer } from './journal-sql-reducer'
|
||||
import { readJournalUsageLimitCut, readJournalOrcaStopCut } from './journal-status-cuts'
|
||||
import type { NativeChatUsageLimitCut } from '../../../shared/native-chat/native-chat-usage-limit-cut'
|
||||
import { readJournalStatusState, type JournalStatusState } from './journal-status-state'
|
||||
import type { NativeChatOrcaStopCut } from '../../../shared/native-chat/native-chat-orca-stop-cut'
|
||||
import {
|
||||
readJournalSqlItems,
|
||||
@@ -31,6 +32,7 @@ import {
|
||||
export type JournalSqlPointRead = {
|
||||
sessionId: string
|
||||
operation:
|
||||
| { kind: 'status-state'; currentFence?: number | null }
|
||||
| { kind: 'usage-limit-cut' }
|
||||
| { kind: 'orca-stop-cut' }
|
||||
| { kind: 'input-read'; operation: JournalInputRead }
|
||||
@@ -48,6 +50,7 @@ export type JournalSqlPointRead = {
|
||||
}
|
||||
|
||||
export type JournalSqlPointReadResult =
|
||||
| { kind: 'status-state'; status: JournalStatusState }
|
||||
| { kind: 'usage-limit-cut'; cut: NativeChatUsageLimitCut | null }
|
||||
| { kind: 'orca-stop-cut'; cut: NativeChatOrcaStopCut | null }
|
||||
| { kind: 'input-read'; result: JournalInputReadResult }
|
||||
@@ -99,6 +102,13 @@ function read(
|
||||
)
|
||||
}
|
||||
switch (operation.kind) {
|
||||
case 'status-state': {
|
||||
const { state } = new JournalSqlReducer(scope, scope.epoch)
|
||||
return {
|
||||
kind: 'status-state',
|
||||
status: readJournalStatusState(state, operation.currentFence)
|
||||
}
|
||||
}
|
||||
case 'usage-limit-cut':
|
||||
case 'orca-stop-cut': {
|
||||
const { state } = new JournalSqlReducer(scope, scope.epoch)
|
||||
|
||||
@@ -59,7 +59,8 @@ it('answers every database-shaped read exactly as the in-memory chat does', asyn
|
||||
reads.pendingSubmissions(),
|
||||
reads.newestTurn(),
|
||||
reads.usageLimitCut(),
|
||||
reads.orcaStopCut()
|
||||
reads.orcaStopCut(),
|
||||
reads.statusState(1)
|
||||
])
|
||||
const expected = await answers(memory)
|
||||
// Spans more than one reader page.
|
||||
|
||||
@@ -49,6 +49,8 @@ export function journalSqlReads(
|
||||
const provenance = async (itemId: string) =>
|
||||
(await read({ kind: 'item-provenance', itemId })).provenance
|
||||
return {
|
||||
statusState: async (currentFence) =>
|
||||
(await read({ kind: 'status-state', currentFence })).status,
|
||||
input,
|
||||
usageLimitCut: async () => (await read({ kind: 'usage-limit-cut' })).cut,
|
||||
orcaStopCut: async () => (await read({ kind: 'orca-stop-cut' })).cut,
|
||||
|
||||
@@ -9,6 +9,7 @@ import type { JournalSqlValueContext } from './journal-sql-value-context'
|
||||
import type { JournalSqlQueryFacts } from './journal-sql-query-facts'
|
||||
import { journalSqlOrderedValues } from './journal-sql-keyed-values'
|
||||
import type { QueuedMessageRow } from './queued-messages/queued-message-table'
|
||||
import { sqlHasStatusRequestItem, sqlFailedStatusItems } from './journal-sql-status-request-items'
|
||||
import { sqlJournalStatusItems } from './journal-sql-status-items'
|
||||
|
||||
export function sqlJournalStateQueries(
|
||||
@@ -45,6 +46,18 @@ export function sqlJournalStateQueries(
|
||||
return Number(row?.sequence ?? 0)
|
||||
}
|
||||
return {
|
||||
hasStatusRequestItem() {
|
||||
facts.flush()
|
||||
return sqlHasStatusRequestItem(scope)
|
||||
},
|
||||
failedStatusItems(_state, floor) {
|
||||
facts.flush()
|
||||
return sqlFailedStatusItems(
|
||||
scope,
|
||||
(id) => context.read<AgentJournalRenderItem>('items', JSON.stringify(id)),
|
||||
floor
|
||||
)
|
||||
},
|
||||
statusItems(_state, selection) {
|
||||
facts.flush()
|
||||
return sqlJournalStatusItems(
|
||||
|
||||
@@ -8,6 +8,9 @@ CREATE INDEX IF NOT EXISTS journal_proj_items_visible_clear
|
||||
CREATE INDEX IF NOT EXISTS journal_proj_items_visible_turn
|
||||
ON journal_proj_items(session_id, epoch, root, sequence, sequence_index, ordinal)
|
||||
WHERE hidden=0 AND turn_id IS NOT NULL;
|
||||
CREATE INDEX IF NOT EXISTS journal_proj_items_visible_turn_position
|
||||
ON journal_proj_items(session_id, epoch, sequence, sequence_index, ordinal)
|
||||
WHERE hidden=0 AND turn_id IS NOT NULL;
|
||||
CREATE INDEX IF NOT EXISTS journal_proj_items_user
|
||||
ON journal_proj_items(session_id, epoch, sequence, sequence_index, ordinal)
|
||||
WHERE hidden=0 AND root=1 AND message_role='user' AND command_entry=0;
|
||||
@@ -17,8 +20,8 @@ CREATE INDEX IF NOT EXISTS journal_proj_items_unknown_user
|
||||
CREATE INDEX IF NOT EXISTS journal_proj_items_prose
|
||||
ON journal_proj_items(session_id, epoch, sequence, sequence_index, ordinal)
|
||||
WHERE hidden=0 AND root=1 AND message_role='assistant' AND command_entry=0 AND assistant_prose=1;
|
||||
CREATE INDEX IF NOT EXISTS journal_proj_items_assistant
|
||||
ON journal_proj_items(session_id, epoch) WHERE hidden=0 AND message_role='assistant';
|
||||
CREATE INDEX IF NOT EXISTS journal_proj_items_visible_role
|
||||
ON journal_proj_items(session_id, epoch, message_role, entry_key) WHERE hidden=0;
|
||||
CREATE INDEX IF NOT EXISTS journal_proj_items_pending_prompt
|
||||
ON journal_proj_items(session_id, epoch, sequence, sequence_index, ordinal)
|
||||
WHERE hidden=0 AND kind IN ('approval','question') AND lifecycle_state='pending';
|
||||
|
||||
@@ -17,6 +17,10 @@ export function* sqlJournalStatusItems(
|
||||
let single = false
|
||||
let unordered = false
|
||||
switch (selection.kind) {
|
||||
case 'clear':
|
||||
predicates.push('context_clear=1')
|
||||
single = true
|
||||
break
|
||||
case 'boundary':
|
||||
predicates.push('(turn_id IS NOT NULL OR context_clear=1)')
|
||||
single = true
|
||||
|
||||
@@ -0,0 +1,90 @@
|
||||
import type { JournalSqlScope } from './journal-sql-scope'
|
||||
import type { AgentJournalRenderItem } from '../../../shared/agent-session/journal/agent-session-journal-types'
|
||||
import { compareJournalStatusPositions, type JournalStatusItem } from './journal-status-items'
|
||||
|
||||
const PAGE = 128
|
||||
|
||||
/** Existence needs no payload; count all reached user metadata, including associated rows. */
|
||||
export function sqlHasStatusRequestItem(scope: JournalSqlScope): boolean {
|
||||
for (const predicate of ['turn_id IS NOT NULL', "message_role='assistant'"]) {
|
||||
const found = scope.db
|
||||
.prepare(`SELECT entry_key FROM journal_proj_items
|
||||
WHERE session_id=? AND epoch=? AND hidden=0 AND ${predicate} LIMIT 1`)
|
||||
.get(...scope.prefix)
|
||||
if (found) {
|
||||
scope.examined(found)
|
||||
return true
|
||||
}
|
||||
}
|
||||
let after = ''
|
||||
for (;;) {
|
||||
const rows = scope.db
|
||||
.prepare(`SELECT i.entry_key,
|
||||
EXISTS(SELECT 1 FROM journal_proj_submissions s WHERE s.session_id=i.session_id
|
||||
AND s.epoch=i.epoch AND s.current=1 AND s.item_key=i.entry_key) AS submitted
|
||||
FROM journal_proj_items i WHERE i.session_id=? AND i.epoch=? AND i.hidden=0
|
||||
AND i.message_role='user' AND i.entry_key>? ORDER BY i.entry_key LIMIT ?`)
|
||||
.all(...scope.prefix, after, PAGE)
|
||||
rows.forEach((row) => scope.examined(row))
|
||||
if (rows.some((row) => row.submitted === 0)) {
|
||||
return true
|
||||
}
|
||||
const last = rows.at(-1)
|
||||
if (rows.length < PAGE || !last) {
|
||||
return false
|
||||
}
|
||||
after = String(last.entry_key)
|
||||
}
|
||||
}
|
||||
|
||||
/** Failure evidence drives the join; only candidate metadata is sorted in render order. */
|
||||
export function* sqlFailedStatusItems(
|
||||
scope: JournalSqlScope,
|
||||
item: (id: string) => AgentJournalRenderItem | undefined,
|
||||
floor: number
|
||||
): Iterable<JournalStatusItem> {
|
||||
const candidates: { key: string; position: JournalStatusItem['position'] }[] = []
|
||||
let after = ''
|
||||
for (;;) {
|
||||
const rows = scope.db
|
||||
.prepare(`SELECT p.id, s.accepted_seq, i.entry_key, i.sequence,
|
||||
i.sequence_index, i.ordinal, i.hidden, i.root
|
||||
FROM journal_proj_places p
|
||||
LEFT JOIN journal_proj_submissions s ON s.session_id=p.session_id AND s.epoch=p.epoch
|
||||
AND s.client_message_id=p.id AND s.current=1
|
||||
LEFT JOIN journal_proj_items i ON i.session_id=s.session_id AND i.epoch=s.epoch AND i.entry_key=s.item_key
|
||||
WHERE p.session_id=? AND p.epoch=? AND p.index_id='failed-requests' AND p.id>?
|
||||
ORDER BY p.id LIMIT ?`)
|
||||
.all(...scope.prefix, after, PAGE)
|
||||
for (const row of rows) {
|
||||
scope.examined(row)
|
||||
if (
|
||||
typeof row.entry_key === 'string' &&
|
||||
row.hidden === 0 &&
|
||||
row.root === 1 &&
|
||||
(!floor || (Number(row.accepted_seq ?? 0) > floor && Number(row.sequence) > floor))
|
||||
) {
|
||||
candidates.push({
|
||||
key: row.entry_key,
|
||||
position: {
|
||||
sequence: Number(row.sequence),
|
||||
sequenceIndex: Number(row.sequence_index),
|
||||
ordinal: Number(row.ordinal)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
const last = rows.at(-1)
|
||||
if (rows.length < PAGE || !last) {
|
||||
break
|
||||
}
|
||||
after = String(last.id)
|
||||
}
|
||||
candidates.sort((a, b) => compareJournalStatusPositions(b.position, a.position))
|
||||
for (const candidate of candidates) {
|
||||
const current = item(String(JSON.parse(candidate.key)))
|
||||
if (current) {
|
||||
yield { item: current, position: candidate.position }
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,8 @@ import type { JournalStatusItem, JournalStatusItemSelection } from './journal-st
|
||||
|
||||
/** Each live range query names its population; whole-state restore/export remains memory-only. */
|
||||
export type JournalStateQueries = {
|
||||
hasStatusRequestItem: (state: JournalReducerState) => boolean
|
||||
failedStatusItems: (state: JournalReducerState, floor: number) => Iterable<JournalStatusItem>
|
||||
statusItems: (
|
||||
state: JournalReducerState,
|
||||
selection: JournalStatusItemSelection
|
||||
|
||||
@@ -11,6 +11,7 @@ export type JournalStatusPosition = { sequence: number; sequenceIndex: number; o
|
||||
export type JournalStatusItem = { item: AgentJournalRenderItem; position: JournalStatusPosition }
|
||||
export type JournalStatusItemSelection =
|
||||
| { kind: 'boundary'; raw?: true }
|
||||
| { kind: 'clear' }
|
||||
| { kind: 'turns'; root?: true; floor?: number; direction?: 'asc' | 'desc' }
|
||||
| { kind: 'users'; floor?: number; unknown?: true }
|
||||
| { kind: 'assistant-prose'; floor?: number }
|
||||
@@ -52,6 +53,9 @@ export function* memoryJournalStatusItems(
|
||||
root && body.kind === 'message' && body.role === 'user' && body.command === undefined
|
||||
let matches: boolean
|
||||
switch (selection.kind) {
|
||||
case 'clear':
|
||||
matches = isAgentSessionContextClear(body)
|
||||
break
|
||||
case 'boundary':
|
||||
matches = readAgentJournalTurn(body) !== null || isAgentSessionContextClear(body)
|
||||
break
|
||||
@@ -114,6 +118,7 @@ export function* memoryJournalStatusItems(
|
||||
})
|
||||
const single =
|
||||
selection.kind === 'boundary' ||
|
||||
selection.kind === 'clear' ||
|
||||
selection.kind === 'prompt' ||
|
||||
selection.kind === 'tools' ||
|
||||
selection.kind === 'assistant-exists'
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
import type { JournalReducerState } from './projection/journal-reducer'
|
||||
import { memoryJournalMap } from './journal-memory-collections'
|
||||
import { readAgentJournalTurn } from '../../../shared/agent-session/lifecycle/agent-session-turn-record'
|
||||
import { agentJournalSubmissionKey } from '../../../shared/agent-session/journal/agent-session-journal-item-key'
|
||||
import { journalInputPresentationMember } from './input-order/journal-input-obligations'
|
||||
import { isRootAgentJournalItem } from '../../../shared/agent-session/journal/agent-session-journal-producer'
|
||||
import { classifyDispatchRejection } from '../../../shared/agent-session/requests/structured-agent-session-dispatch-rejection'
|
||||
import { compareJournalStatusPositions, type JournalStatusItem } from './journal-status-items'
|
||||
|
||||
export function memoryHasStatusRequestItem(state: JournalReducerState): boolean {
|
||||
const submitted = new Set(
|
||||
[...memoryJournalMap(state.submissions).keys()].map(agentJournalSubmissionKey)
|
||||
)
|
||||
return [...memoryJournalMap(state.items).values()].some(
|
||||
(item) =>
|
||||
journalInputPresentationMember(state, item.itemId) &&
|
||||
(readAgentJournalTurn(item.body) !== null ||
|
||||
(item.body.kind === 'message' &&
|
||||
(item.body.role === 'assistant' ||
|
||||
(item.body.role === 'user' && !submitted.has(item.itemId)))))
|
||||
)
|
||||
}
|
||||
|
||||
export function memoryFailedStatusItems(
|
||||
state: JournalReducerState,
|
||||
floor: number
|
||||
): Iterable<JournalStatusItem> {
|
||||
const rejected = new Set(
|
||||
[...memoryJournalMap(state.submissions).values()]
|
||||
.filter(
|
||||
(send) =>
|
||||
send.dispatchState === 'rejected' &&
|
||||
(!floor || (send.acceptedSequence ?? 0) > floor) &&
|
||||
classifyDispatchRejection(send).verdict === 'failure'
|
||||
)
|
||||
.map((send) => agentJournalSubmissionKey(send.clientMessageId))
|
||||
)
|
||||
const rows: JournalStatusItem[] = []
|
||||
let ordinal = 0
|
||||
for (const item of memoryJournalMap(state.items).values()) {
|
||||
const position = {
|
||||
sequence: item.sequence,
|
||||
sequenceIndex: item.sequenceIndex ?? 0,
|
||||
ordinal: ordinal++
|
||||
}
|
||||
if (
|
||||
rejected.has(item.itemId) &&
|
||||
(!floor || item.sequence > floor) &&
|
||||
journalInputPresentationMember(state, item.itemId) &&
|
||||
isRootAgentJournalItem(item)
|
||||
) {
|
||||
rows.push({ item, position })
|
||||
}
|
||||
}
|
||||
return rows.sort((a, b) => compareJournalStatusPositions(b.position, a.position))
|
||||
}
|
||||
@@ -0,0 +1,240 @@
|
||||
import { afterEach, expect, it } from 'vitest'
|
||||
import type {
|
||||
AgentJournalRenderItem,
|
||||
AgentJournalSubmission
|
||||
} from '../../../shared/agent-session/journal/agent-session-journal-types'
|
||||
import Database from '../../sqlite/sync-database'
|
||||
import { createJournalReducerState } from './projection/journal-reducer'
|
||||
import { JournalSqlReducer } from './journal-sql-reducer'
|
||||
import { JournalSqlScope } from './journal-sql-scope'
|
||||
import { journalSqlProjectionSchema } from './journal-sql-projection-schema'
|
||||
import { journalInputOrder } from './input-order/journal-input-order'
|
||||
import { journalDispatchRowBuilder } from './writing/journal-row-builders'
|
||||
import { readJournalRequestStatus } from './journal-status-requests'
|
||||
|
||||
const databases: Database.Database[] = []
|
||||
afterEach(() => databases.splice(0).forEach((db) => db.close()))
|
||||
function fixture(backend: 'memory' | 'sql') {
|
||||
if (backend === 'memory') {
|
||||
return createJournalReducerState('session', 'epoch')
|
||||
}
|
||||
const db = new Database(':memory:')
|
||||
databases.push(db)
|
||||
db.exec(journalSqlProjectionSchema())
|
||||
return new JournalSqlReducer(new JournalSqlScope(db, 'session', 'epoch'), 'epoch').state
|
||||
}
|
||||
function row(
|
||||
itemId: string,
|
||||
sequence: number,
|
||||
body: AgentJournalRenderItem['body'],
|
||||
extra: Partial<AgentJournalRenderItem> = {}
|
||||
): AgentJournalRenderItem {
|
||||
return { itemId, sequence, revision: 1, observedAt: 1, body, ...extra }
|
||||
}
|
||||
const message = (role: 'user' | 'assistant', text: string): AgentJournalRenderItem['body'] => ({
|
||||
kind: 'message',
|
||||
role,
|
||||
blocks: [{ type: 'text', text }]
|
||||
})
|
||||
|
||||
it.each(['memory', 'sql'] as const)(
|
||||
'selects request order, command dependencies and assistant barriers in %s',
|
||||
(backend) => {
|
||||
const state = fixture(backend)
|
||||
state.items.set(
|
||||
'done',
|
||||
row(
|
||||
'done',
|
||||
10,
|
||||
{ kind: 'turn', turnId: 'done', state: 'completed', outcome: 'success', completedAt: 100 },
|
||||
{ sequenceIndex: 2 }
|
||||
)
|
||||
)
|
||||
state.items.set(
|
||||
'legacy',
|
||||
row(
|
||||
'legacy',
|
||||
10,
|
||||
{
|
||||
kind: 'status',
|
||||
text: 'Legacy',
|
||||
turnLifecycle: { turnId: 'legacy', state: 'interrupted' }
|
||||
},
|
||||
{ sequenceIndex: 1 }
|
||||
)
|
||||
)
|
||||
const command = {
|
||||
kind: 'message' as const,
|
||||
role: 'assistant' as const,
|
||||
command: { name: 'compact' as const },
|
||||
blocks: []
|
||||
}
|
||||
state.items.set('opener', row('opener', 1, command))
|
||||
state.items.set(
|
||||
'compact',
|
||||
row('compact', 11, {
|
||||
kind: 'turn',
|
||||
turnId: 'compact',
|
||||
state: 'completed',
|
||||
outcome: 'failure',
|
||||
userItemId: 'opener',
|
||||
completedAt: 110
|
||||
})
|
||||
)
|
||||
state.items.set('prose', row('prose', 12, message('assistant', 'Root reply')))
|
||||
state.items.set(
|
||||
'tool-only',
|
||||
row('tool-only', 13, { kind: 'message', role: 'assistant', blocks: [] })
|
||||
)
|
||||
state.items.set(
|
||||
'command-result',
|
||||
row('command-result', 14, message('assistant', 'Command result'), {
|
||||
turnScope: { kind: 'turn', turnItemId: 'compact' }
|
||||
})
|
||||
)
|
||||
state.items.set(
|
||||
'child',
|
||||
row('child', 90, message('assistant', 'Child reply'), { agentId: 'child' })
|
||||
)
|
||||
expect(readJournalRequestStatus(state)).toEqual({
|
||||
hasRequest: true,
|
||||
latestPrompt: '',
|
||||
latestRequest: {
|
||||
kind: 'turn',
|
||||
id: 'done',
|
||||
turnState: 'completed',
|
||||
outcome: 'success',
|
||||
settledAt: 100
|
||||
},
|
||||
lastAssistantMessage: 'Root reply'
|
||||
})
|
||||
state.items.set('opener', row('opener', 1, message('user', 'Ordinary opener')))
|
||||
expect(readJournalRequestStatus(state)).toMatchObject({
|
||||
latestPrompt: 'Ordinary opener',
|
||||
latestRequest: { id: 'compact', outcome: 'failure' },
|
||||
lastAssistantMessage: 'Command result'
|
||||
})
|
||||
state.items.set(
|
||||
'steer',
|
||||
row('steer', 15, message('user', 'Steered prompt'), {
|
||||
turnScope: { kind: 'turn', turnItemId: 'done' }
|
||||
})
|
||||
)
|
||||
expect(readJournalRequestStatus(state)).toEqual({
|
||||
hasRequest: true,
|
||||
latestPrompt: 'Steered prompt',
|
||||
latestRequest: {
|
||||
kind: 'turn',
|
||||
id: 'compact',
|
||||
turnState: 'completed',
|
||||
outcome: 'failure',
|
||||
settledAt: 110
|
||||
}
|
||||
})
|
||||
state.items.set(
|
||||
'barrier',
|
||||
row('barrier', 16, message('user', 'Unknown request'), { turnScope: { kind: 'unknown' } })
|
||||
)
|
||||
expect(readJournalRequestStatus(state).latestRequest).toBeNull()
|
||||
state.items.set(
|
||||
'barrier',
|
||||
row('barrier', 16, message('user', 'Thread request'), { turnScope: { kind: 'thread' } })
|
||||
)
|
||||
expect(readJournalRequestStatus(state).latestRequest?.id).toBe('compact')
|
||||
}
|
||||
)
|
||||
|
||||
it.each(['memory', 'sql'] as const)(
|
||||
'keeps pre-clear existence/prompt, strict acceptance cuts and nonmessage refusals in %s',
|
||||
(backend) => {
|
||||
const state = fixture(backend)
|
||||
expect(readJournalRequestStatus(state)).toEqual({
|
||||
hasRequest: false,
|
||||
latestPrompt: '',
|
||||
latestRequest: null
|
||||
})
|
||||
state.items.set('prompt', row('prompt', 1, message('user', 'Keep the prompt')))
|
||||
state.items.set(
|
||||
'self',
|
||||
row('self', 2, {
|
||||
kind: 'turn',
|
||||
turnId: 'self',
|
||||
state: 'completed',
|
||||
userItemId: 'self',
|
||||
completedAt: 20
|
||||
})
|
||||
)
|
||||
expect(readJournalRequestStatus(state).latestRequest).toMatchObject({
|
||||
id: 'self',
|
||||
selfStarted: true
|
||||
})
|
||||
const refusal: AgentJournalSubmission = {
|
||||
clientMessageId: 'refused',
|
||||
fence: 1,
|
||||
payloadFingerprint: 'fp',
|
||||
dispatchState: 'rejected',
|
||||
providerItemId: null,
|
||||
reason: null,
|
||||
submittedAt: 3,
|
||||
resolvedAt: 30,
|
||||
acceptedSequence: 3,
|
||||
rejection: { kind: 'writeFailed' }
|
||||
}
|
||||
state.submissions.set('refused', refusal)
|
||||
state.items.set('orca:refused', row('orca:refused', 4, { kind: 'status', text: 'Refused' }))
|
||||
const order = journalInputOrder(state)
|
||||
const refresh = () =>
|
||||
order.afterRow(
|
||||
state,
|
||||
journalDispatchRowBuilder(() => state, {
|
||||
clientMessageId: 'refused',
|
||||
state: 'unknown',
|
||||
fence: 1
|
||||
})(4, 4)
|
||||
)
|
||||
refresh()
|
||||
expect(readJournalRequestStatus(state).latestRequest).toEqual({
|
||||
kind: 'refused-send',
|
||||
id: 'orca:refused',
|
||||
turnState: null,
|
||||
outcome: 'failure',
|
||||
settledAt: 30
|
||||
})
|
||||
const clear = {
|
||||
kind: 'status' as const,
|
||||
text: 'Cleared',
|
||||
contextClear: { operationId: 'clear', afterFence: 1, clearedAt: 5 }
|
||||
}
|
||||
state.items.set('clear', row('clear', 5, clear))
|
||||
state.items.set(
|
||||
'orca:refused',
|
||||
row('orca:refused', 6, { kind: 'status', text: 'Refused after clear' })
|
||||
)
|
||||
state.submissions.set('refused', { ...refusal, acceptedSequence: 5 })
|
||||
refresh()
|
||||
expect(readJournalRequestStatus(state)).toEqual({
|
||||
hasRequest: true,
|
||||
latestPrompt: 'Keep the prompt',
|
||||
latestRequest: null
|
||||
})
|
||||
state.submissions.set('refused', { ...refusal, acceptedSequence: 6 })
|
||||
refresh()
|
||||
expect(readJournalRequestStatus(state).latestRequest?.id).toBe('orca:refused')
|
||||
state.items.set('orca:hidden-clear', row('orca:hidden-clear', 7, clear))
|
||||
state.inputs.rejections.set('hidden-clear', { ...refusal, clientMessageId: 'hidden-clear' })
|
||||
expect(readJournalRequestStatus(state).latestRequest?.id).toBe('orca:refused')
|
||||
state.items.delete('prompt')
|
||||
state.items.delete('self')
|
||||
state.items.delete('orca:refused')
|
||||
state.submissions.delete('refused')
|
||||
state.items.set(
|
||||
'child-user',
|
||||
row('child-user', 8, message('user', 'Provider child'), { agentId: 'child' })
|
||||
)
|
||||
expect(readJournalRequestStatus(state)).toEqual({
|
||||
hasRequest: true,
|
||||
latestPrompt: '',
|
||||
latestRequest: null
|
||||
})
|
||||
}
|
||||
)
|
||||
@@ -0,0 +1,125 @@
|
||||
import {
|
||||
hasStructuredAgentSessionRequest,
|
||||
latestStructuredAgentSessionAssistantMessage,
|
||||
latestStructuredAgentSessionPrompt,
|
||||
structuredAgentSessionRequestFromItem,
|
||||
type StructuredAgentSessionLatestRequest
|
||||
} from '../../../shared/agent-session/requests/structured-agent-session-latest-request'
|
||||
import {
|
||||
commandTurnsByBody,
|
||||
isStructuredAgentSessionCommandRow
|
||||
} from '../../../shared/agent-session/structured-agent-session-command-entry'
|
||||
import {
|
||||
AGENT_STATUS_MAX_FIELD_LENGTH,
|
||||
normalizeOptionalField,
|
||||
normalizePromptField
|
||||
} from '../../../shared/agent-status/contracts/agent-status-field-normalization'
|
||||
import type { JournalReducerState } from './projection/journal-reducer'
|
||||
import { renderJournalStatusItem } from './projection/journal-public-read'
|
||||
import { journalInputOrder } from './input-order/journal-input-order'
|
||||
import { compareJournalStatusPositions, type JournalStatusItem } from './journal-status-items'
|
||||
|
||||
export type JournalRequestStatus = {
|
||||
hasRequest: boolean
|
||||
latestPrompt: string
|
||||
latestRequest: StructuredAgentSessionLatestRequest | null
|
||||
lastAssistantMessage?: string
|
||||
}
|
||||
|
||||
function* newestCandidates(
|
||||
...populations: Iterable<JournalStatusItem>[]
|
||||
): Iterable<JournalStatusItem> {
|
||||
const iterators = populations.map((items) => items[Symbol.iterator]())
|
||||
const next = iterators.map((iterator) => iterator.next())
|
||||
for (;;) {
|
||||
let winner = -1
|
||||
next.forEach((candidate, index) => {
|
||||
if (
|
||||
!candidate.done &&
|
||||
(winner === -1 ||
|
||||
compareJournalStatusPositions(candidate.value.position, next[winner]!.value!.position) >
|
||||
0)
|
||||
) {
|
||||
winner = index
|
||||
}
|
||||
})
|
||||
if (winner === -1) {
|
||||
return
|
||||
}
|
||||
yield next[winner]!.value!
|
||||
next[winner] = iterators[winner]!.next()
|
||||
}
|
||||
}
|
||||
|
||||
/** Named populations preserve whole-history existence/prompt and strict current-context verdicts. */
|
||||
export function readJournalRequestStatus(
|
||||
state: JournalReducerState,
|
||||
currentFence?: number | null
|
||||
): JournalRequestStatus {
|
||||
const order = journalInputOrder(state)
|
||||
const selects = (selection: Parameters<typeof state.queries.statusItems>[1]) =>
|
||||
state.queries.statusItems(state, selection)
|
||||
const hasRequest =
|
||||
state.queries.hasStatusRequestItem(state) ||
|
||||
hasStructuredAgentSessionRequest([], order.statusInputs(state, []), currentFence)
|
||||
if (!hasRequest) {
|
||||
return { hasRequest: false, latestPrompt: '', latestRequest: null }
|
||||
}
|
||||
const prompt = selects({ kind: 'prompt' })[Symbol.iterator]().next().value?.item
|
||||
const floor = selects({ kind: 'clear' })[Symbol.iterator]().next().value?.item.sequence ?? 0
|
||||
const bodyOf = (id: string) => {
|
||||
const item = renderJournalStatusItem(state, id)
|
||||
return item && (!floor || item.sequence > floor) ? item.body : null
|
||||
}
|
||||
const commands = commandTurnsByBody(bodyOf)
|
||||
let latestRequest: StructuredAgentSessionLatestRequest | null = null
|
||||
for (const { item } of newestCandidates(
|
||||
selects({ kind: 'turns', root: true, floor }),
|
||||
selects({ kind: 'users', unknown: true, floor }),
|
||||
state.queries.failedStatusItems(state, floor)
|
||||
)) {
|
||||
const submission = order.inputForItem(item.itemId)
|
||||
const current =
|
||||
submission && (!floor || (submission.acceptedSequence ?? 0) > floor) ? submission : undefined
|
||||
const displayed = renderJournalStatusItem(state, item.itemId)
|
||||
if (!displayed) {
|
||||
continue
|
||||
}
|
||||
const candidate = structuredAgentSessionRequestFromItem(
|
||||
displayed,
|
||||
current,
|
||||
(id) =>
|
||||
order
|
||||
.statusInputs(state, [item])
|
||||
.some(
|
||||
(send) =>
|
||||
send.answeredInTurn?.via === 'steer' &&
|
||||
send.answeredInTurn.turnItemId === id &&
|
||||
(!floor || (send.acceptedSequence ?? 0) > floor)
|
||||
),
|
||||
commands
|
||||
)
|
||||
if (candidate !== undefined) {
|
||||
latestRequest = candidate
|
||||
break
|
||||
}
|
||||
}
|
||||
let assistant = ''
|
||||
for (const { item } of newestCandidates(
|
||||
selects({ kind: 'assistant-prose', floor }),
|
||||
selects({ kind: 'users', floor })
|
||||
)) {
|
||||
if (isStructuredAgentSessionCommandRow(item, commands)) {
|
||||
continue
|
||||
}
|
||||
assistant = latestStructuredAgentSessionAssistantMessage([item], bodyOf)
|
||||
break
|
||||
}
|
||||
const lastAssistantMessage = normalizeOptionalField(assistant, AGENT_STATUS_MAX_FIELD_LENGTH)
|
||||
return {
|
||||
hasRequest: true,
|
||||
latestPrompt: normalizePromptField(prompt ? latestStructuredAgentSessionPrompt([prompt]) : ''),
|
||||
latestRequest,
|
||||
...(lastAssistantMessage ? { lastAssistantMessage } : {})
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,177 @@
|
||||
import { afterEach, expect, it } from 'vitest'
|
||||
import type { AgentJournalRenderItem } from '../../../shared/agent-session/journal/agent-session-journal-types'
|
||||
import Database from '../../sqlite/sync-database'
|
||||
import { createJournalReducerState } from './projection/journal-reducer'
|
||||
import { JournalSqlReducer } from './journal-sql-reducer'
|
||||
import { JournalSqlScope } from './journal-sql-scope'
|
||||
import { journalSqlProjectionSchema } from './journal-sql-projection-schema'
|
||||
import { readJournalStatusState } from './journal-status-state'
|
||||
|
||||
const databases: Database.Database[] = []
|
||||
afterEach(() => databases.splice(0).forEach((db) => db.close()))
|
||||
function fixture(backend: 'memory' | 'sql') {
|
||||
if (backend === 'memory') {
|
||||
return createJournalReducerState('session', 'epoch')
|
||||
}
|
||||
const db = new Database(':memory:')
|
||||
databases.push(db)
|
||||
db.exec(journalSqlProjectionSchema())
|
||||
return new JournalSqlReducer(new JournalSqlScope(db, 'session', 'epoch'), 'epoch').state
|
||||
}
|
||||
function row(
|
||||
itemId: string,
|
||||
sequence: number,
|
||||
body: AgentJournalRenderItem['body'],
|
||||
extra: Partial<AgentJournalRenderItem> = {}
|
||||
): AgentJournalRenderItem {
|
||||
return { itemId, sequence, revision: 1, observedAt: sequence * 10, body, ...extra }
|
||||
}
|
||||
|
||||
it.each(['memory', 'sql'] as const)(
|
||||
'uses the current boundary and positional tools, then dates the settled verdict in %s',
|
||||
(backend) => {
|
||||
const state = fixture(backend)
|
||||
state.items.set(
|
||||
'ask',
|
||||
row('ask', 1, { kind: 'message', role: 'user', blocks: [{ type: 'text', text: 'Go' }] })
|
||||
)
|
||||
const running = {
|
||||
kind: 'turn' as const,
|
||||
turnId: 'turn',
|
||||
state: 'running' as const,
|
||||
requestedAt: 100
|
||||
}
|
||||
state.items.set('turn', row('turn', 2, running))
|
||||
state.items.set(
|
||||
'call',
|
||||
row(
|
||||
'call',
|
||||
3,
|
||||
{ kind: 'tool-call', name: 'Read', state: 'running', input: { file_path: 'src/a.ts' } },
|
||||
{ turnScope: { kind: 'turn', turnItemId: 'other-turn' } }
|
||||
)
|
||||
)
|
||||
state.items.set(
|
||||
'diff',
|
||||
row('diff', 4, {
|
||||
kind: 'diff',
|
||||
path: 'src/b.ts',
|
||||
patch: { head: '@@\n+x', byteLength: 5, digest: 'd', truncated: false }
|
||||
})
|
||||
)
|
||||
expect(readJournalStatusState(state)).toEqual({
|
||||
summary: {
|
||||
status: 'working',
|
||||
latestPrompt: 'Go',
|
||||
toolName: 'Read',
|
||||
toolInput: 'src/a.ts',
|
||||
statusStartedAt: 100
|
||||
},
|
||||
latestRequest: {
|
||||
kind: 'turn',
|
||||
id: 'turn',
|
||||
turnState: 'running',
|
||||
outcome: null,
|
||||
settledAt: undefined
|
||||
},
|
||||
owesWork: true,
|
||||
pendingPromptIds: []
|
||||
})
|
||||
state.items.set(
|
||||
'call',
|
||||
row('call', 3, {
|
||||
kind: 'tool-call',
|
||||
name: 'Read',
|
||||
state: 'completed',
|
||||
input: { file_path: 'src/a.ts' }
|
||||
})
|
||||
)
|
||||
expect(readJournalStatusState(state).summary).toMatchObject({
|
||||
toolName: 'Diff',
|
||||
toolInput: 'src/b.ts'
|
||||
})
|
||||
state.items.set(
|
||||
'turn',
|
||||
row('turn', 5, { ...running, state: 'completed', outcome: 'success', completedAt: 500 })
|
||||
)
|
||||
expect(readJournalStatusState(state)).toEqual({
|
||||
summary: { status: 'idle', latestPrompt: 'Go', turnOutcome: 'success', statusStartedAt: 500 },
|
||||
latestRequest: {
|
||||
kind: 'turn',
|
||||
id: 'turn',
|
||||
turnState: 'completed',
|
||||
outcome: 'success',
|
||||
settledAt: 500
|
||||
},
|
||||
owesWork: false,
|
||||
pendingPromptIds: []
|
||||
})
|
||||
state.items.set('turn', row('turn', 5, { ...running, state: 'interrupted', completedAt: 500 }))
|
||||
state.items.set(
|
||||
'quit',
|
||||
row(
|
||||
'quit',
|
||||
6,
|
||||
{ kind: 'status', text: 'Quit', orcaStop: { cause: 'quit' } },
|
||||
{ turnScope: { kind: 'turn', turnItemId: 'turn' }, agentId: 'child' }
|
||||
)
|
||||
)
|
||||
expect(readJournalStatusState(state).summary).toEqual({
|
||||
status: 'idle',
|
||||
latestPrompt: 'Go',
|
||||
turnOutcome: 'cancellation',
|
||||
statusStartedAt: 500
|
||||
})
|
||||
}
|
||||
)
|
||||
|
||||
it.each(['memory', 'sql'] as const)(
|
||||
'keeps pending timestamps independent of scope and rereads row-free live authority in %s',
|
||||
(backend) => {
|
||||
const state = fixture(backend)
|
||||
state.items.set(
|
||||
'turn',
|
||||
row('turn', 1, { kind: 'turn', turnId: 'turn', state: 'running', requestedAt: 100 })
|
||||
)
|
||||
const question = {
|
||||
kind: 'question' as const,
|
||||
question: 'Continue?',
|
||||
options: [],
|
||||
resolution: {
|
||||
state: 'pending' as const,
|
||||
selectedOptionId: null,
|
||||
resolvedBy: null,
|
||||
resolvedAt: null
|
||||
}
|
||||
}
|
||||
state.items.set('root-first', row('root-first', 3, question, { observedAt: 30 }))
|
||||
state.items.set('child', row('child', 4, question, { observedAt: 10, agentId: 'child' }))
|
||||
state.items.set('root-second', row('root-second', 5, question, { observedAt: 20 }))
|
||||
const current = new Set(['child'])
|
||||
const scope = { isCurrentItem: (id: string) => current.has(id), owesSend: () => false }
|
||||
expect(readJournalStatusState(state, 1, scope)).toEqual({
|
||||
summary: { status: 'attention', latestPrompt: '', statusStartedAt: 20 },
|
||||
latestRequest: {
|
||||
kind: 'turn',
|
||||
id: 'turn',
|
||||
turnState: 'running',
|
||||
outcome: null,
|
||||
settledAt: undefined
|
||||
},
|
||||
owesWork: false,
|
||||
pendingPromptIds: ['child']
|
||||
})
|
||||
current.clear()
|
||||
expect(readJournalStatusState(state, 1, scope)).toMatchObject({
|
||||
summary: { status: 'idle' },
|
||||
owesWork: false,
|
||||
pendingPromptIds: []
|
||||
})
|
||||
current.add('turn')
|
||||
expect(readJournalStatusState(state, 1, scope)).toMatchObject({
|
||||
summary: { status: 'working', statusStartedAt: 100 },
|
||||
owesWork: true,
|
||||
pendingPromptIds: []
|
||||
})
|
||||
}
|
||||
)
|
||||
@@ -0,0 +1,123 @@
|
||||
import type { AgentJournalRenderItem } from '../../../shared/agent-session/journal/agent-session-journal-types'
|
||||
import type { StructuredAgentSessionWorkScope } from '../../../shared/agent-session/view/structured-agent-session-main-agent-working'
|
||||
import { isStructuredAgentSessionMainAgentWorking } from '../../../shared/agent-session/view/structured-agent-session-main-agent-working'
|
||||
import { activeStructuredAgentSessionTurnId } from '../../../shared/agent-session/view/structured-agent-session-live-turn'
|
||||
import { readAgentJournalTurn } from '../../../shared/agent-session/lifecycle/agent-session-turn-record'
|
||||
import {
|
||||
isStructuredAgentSessionToolAction,
|
||||
structuredAgentSessionToolCallBlock
|
||||
} from '../../../shared/agent-session/structured-agent-session-tool-call-block'
|
||||
import { nativeChatStatusRequestOutcome } from '../../../shared/native-chat/native-chat-orca-stop-cut'
|
||||
import { structuredAgentSessionStatusStartedAt } from '../../../shared/agent-session/view/structured-agent-session-status-started-at'
|
||||
import type { projectStructuredAgentSessionStatusState } from '../../../shared/agent-session/view/structured-agent-session-projection'
|
||||
import {
|
||||
AGENT_STATUS_TOOL_INPUT_MAX_LENGTH,
|
||||
normalizeOptionalField
|
||||
} from '../../../shared/agent-status/contracts/agent-status-field-normalization'
|
||||
import { AGENT_STATUS_TOOL_NAME_MAX_LENGTH } from '../../../shared/agent-status/contracts/agent-status-types'
|
||||
import { describeToolInput } from '../../../shared/native-chat/tools/native-chat-tool-summary'
|
||||
import type { JournalReducerState } from './projection/journal-reducer'
|
||||
import { journalInputOrder } from './input-order/journal-input-order'
|
||||
import { renderJournalStatusItem } from './projection/journal-public-read'
|
||||
import { readJournalOrcaStopCut } from './journal-status-cuts'
|
||||
import { readJournalRequestStatus } from './journal-status-requests'
|
||||
|
||||
export type JournalStatusState = ReturnType<typeof projectStructuredAgentSessionStatusState>
|
||||
|
||||
/** Compose named facts in one snapshot; scope remains the caller's live execution authority. */
|
||||
export function readJournalStatusState(
|
||||
state: JournalReducerState,
|
||||
currentFence?: number | null,
|
||||
scope?: StructuredAgentSessionWorkScope
|
||||
): JournalStatusState {
|
||||
const requests = readJournalRequestStatus(state, currentFence)
|
||||
if (!requests.hasRequest) {
|
||||
return {
|
||||
summary: { status: null, latestPrompt: '' },
|
||||
latestRequest: null,
|
||||
owesWork: false,
|
||||
pendingPromptIds: []
|
||||
}
|
||||
}
|
||||
const selects = (selection: Parameters<typeof state.queries.statusItems>[1]) =>
|
||||
state.queries.statusItems(state, selection)
|
||||
const floor = selects({ kind: 'clear' })[Symbol.iterator]().next().value?.item.sequence ?? 0
|
||||
const pending = [...selects({ kind: 'pending-prompts', floor })].flatMap(({ item }) => {
|
||||
const displayed = renderJournalStatusItem(state, item.itemId)
|
||||
return displayed ? [displayed] : []
|
||||
})
|
||||
const actionable = pending.filter((item) => !scope || scope.isCurrentItem(item.itemId))
|
||||
const boundary = selects({ kind: 'boundary' })[Symbol.iterator]().next().value
|
||||
const currentBoundary =
|
||||
boundary && (!floor || boundary.item.sequence > floor) ? boundary : undefined
|
||||
const active = activeStructuredAgentSessionTurnId(
|
||||
currentBoundary ? [currentBoundary.item] : [],
|
||||
scope && ((item) => scope.isCurrentItem(item.itemId))
|
||||
)
|
||||
const submissions = journalInputOrder(state)
|
||||
.statusInputs(state, [])
|
||||
.filter((send) => !floor || (send.acceptedSequence ?? 0) > floor)
|
||||
const owesWork = isStructuredAgentSessionMainAgentWorking(
|
||||
active,
|
||||
submissions,
|
||||
currentFence,
|
||||
scope
|
||||
)
|
||||
const status = actionable.length > 0 ? 'attention' : owesWork ? 'working' : 'idle'
|
||||
let tool: AgentJournalRenderItem | null = null
|
||||
if (
|
||||
status === 'working' &&
|
||||
currentBoundary &&
|
||||
readAgentJournalTurn(currentBoundary.item.body)?.state === 'running'
|
||||
) {
|
||||
const selected =
|
||||
selects({ kind: 'tools', after: currentBoundary.position, running: true })
|
||||
[Symbol.iterator]()
|
||||
.next().value ??
|
||||
selects({ kind: 'tools', after: currentBoundary.position })[Symbol.iterator]().next().value
|
||||
tool = selected ? renderJournalStatusItem(state, selected.item.itemId) : null
|
||||
}
|
||||
const block =
|
||||
tool && isStructuredAgentSessionToolAction(tool.body)
|
||||
? structuredAgentSessionToolCallBlock(tool.body, tool.itemId)
|
||||
: null
|
||||
const toolName = block
|
||||
? normalizeOptionalField(block.name, AGENT_STATUS_TOOL_NAME_MAX_LENGTH)
|
||||
: undefined
|
||||
const toolInput = block
|
||||
? normalizeOptionalField(describeToolInput(block.input), AGENT_STATUS_TOOL_INPUT_MAX_LENGTH)
|
||||
: undefined
|
||||
const request = status === 'idle' ? requests.latestRequest : null
|
||||
const turnOutcome = nativeChatStatusRequestOutcome(
|
||||
request,
|
||||
request ? readJournalOrcaStopCut(state, floor) : null
|
||||
)
|
||||
const latestTurn =
|
||||
status === 'working'
|
||||
? selects({ kind: 'turns', floor })[Symbol.iterator]().next().value?.item
|
||||
: undefined
|
||||
const timestampItems = status === 'attention' ? pending : latestTurn ? [latestTurn] : []
|
||||
const statusStartedAt = structuredAgentSessionStatusStartedAt(
|
||||
status,
|
||||
timestampItems,
|
||||
submissions,
|
||||
currentFence,
|
||||
request
|
||||
)
|
||||
return {
|
||||
latestRequest: requests.latestRequest,
|
||||
owesWork: status !== 'idle' && owesWork,
|
||||
pendingPromptIds: status === 'attention' ? actionable.map((item) => item.itemId) : [],
|
||||
summary: {
|
||||
status,
|
||||
latestPrompt: requests.latestPrompt,
|
||||
...(toolName ? { toolName } : {}),
|
||||
...(toolInput ? { toolInput } : {}),
|
||||
...(requests.lastAssistantMessage
|
||||
? { lastAssistantMessage: requests.lastAssistantMessage }
|
||||
: {}),
|
||||
...(turnOutcome ? { turnOutcome } : {}),
|
||||
...(statusStartedAt !== undefined ? { statusStartedAt } : {})
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -61,53 +61,67 @@ export function latestStructuredAgentSessionRequest(
|
||||
const commandTurns = commandTurnsOf(items, bodyOf)
|
||||
for (let index = items.length - 1; index >= 0; index -= 1) {
|
||||
const item = items[index]
|
||||
// Commands retain the last real request’s verdict.
|
||||
if (
|
||||
!item ||
|
||||
!isRootAgentJournalItem(item) ||
|
||||
isStructuredAgentSessionNonRequestRow(item, commandTurns)
|
||||
) {
|
||||
continue
|
||||
}
|
||||
if (
|
||||
item.body.kind === 'message' &&
|
||||
item.body.role === 'user' &&
|
||||
item.turnScope?.kind === 'unknown'
|
||||
) {
|
||||
return null
|
||||
}
|
||||
const turn = readAgentJournalTurn(item.body)
|
||||
if (turn) {
|
||||
return {
|
||||
kind: 'turn',
|
||||
id: turn.turnId,
|
||||
turnState: turn.state,
|
||||
outcome: readAgentJournalTurnOutcome(turn),
|
||||
settledAt: turn.state === 'running' ? undefined : turnEndedAt(item, turn),
|
||||
...(turn.userItemId === item.itemId && !steeredInto(submissions, item.itemId)
|
||||
? { selfStarted: true as const }
|
||||
: {})
|
||||
}
|
||||
}
|
||||
const submission = rejected.get(item.itemId)
|
||||
// Rejection relocates a refused steer to the thread, but its turn remains the request.
|
||||
if (
|
||||
submission &&
|
||||
submission.answeredInTurn?.via !== 'steer' &&
|
||||
classifyDispatchRejection(submission).verdict === 'failure'
|
||||
) {
|
||||
return {
|
||||
kind: 'refused-send',
|
||||
id: item.itemId,
|
||||
turnState: null,
|
||||
outcome: 'failure',
|
||||
settledAt: submission.resolvedAt ?? submission.submittedAt
|
||||
}
|
||||
const request =
|
||||
item &&
|
||||
structuredAgentSessionRequestFromItem(
|
||||
item,
|
||||
rejected.get(item.itemId),
|
||||
(turnItemId) => steeredInto(submissions, turnItemId),
|
||||
commandTurns
|
||||
)
|
||||
if (request !== undefined) {
|
||||
return request
|
||||
}
|
||||
}
|
||||
return null
|
||||
}
|
||||
|
||||
/** Undefined skips a candidate; null is the unknown-user barrier that clears the verdict. */
|
||||
export function structuredAgentSessionRequestFromItem(
|
||||
item: AgentJournalRenderItem,
|
||||
rejected: AgentJournalSubmission | undefined,
|
||||
steered: (turnItemId: string) => boolean,
|
||||
commandTurns: Pick<ReadonlySet<string>, 'has'>
|
||||
): StructuredAgentSessionLatestRequest | null | undefined {
|
||||
if (!isRootAgentJournalItem(item) || isStructuredAgentSessionNonRequestRow(item, commandTurns)) {
|
||||
return undefined
|
||||
}
|
||||
if (
|
||||
item.body.kind === 'message' &&
|
||||
item.body.role === 'user' &&
|
||||
item.turnScope?.kind === 'unknown'
|
||||
) {
|
||||
return null
|
||||
}
|
||||
const turn = readAgentJournalTurn(item.body)
|
||||
if (turn) {
|
||||
return {
|
||||
kind: 'turn',
|
||||
id: turn.turnId,
|
||||
turnState: turn.state,
|
||||
outcome: readAgentJournalTurnOutcome(turn),
|
||||
settledAt: turn.state === 'running' ? undefined : turnEndedAt(item, turn),
|
||||
...(turn.userItemId === item.itemId && !steered(item.itemId)
|
||||
? { selfStarted: true as const }
|
||||
: {})
|
||||
}
|
||||
}
|
||||
if (
|
||||
rejected?.dispatchState === 'rejected' &&
|
||||
rejected.answeredInTurn?.via !== 'steer' &&
|
||||
classifyDispatchRejection(rejected).verdict === 'failure'
|
||||
) {
|
||||
return {
|
||||
kind: 'refused-send',
|
||||
id: item.itemId,
|
||||
turnState: null,
|
||||
outcome: 'failure',
|
||||
settledAt: rejected.resolvedAt ?? rejected.submittedAt
|
||||
}
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
/** A user message steered into a turn the agent started makes it the user's turn too. */
|
||||
function steeredInto(submissions: readonly AgentJournalSubmission[], turnItemId: string): boolean {
|
||||
return submissions.some(
|
||||
|
||||
@@ -121,5 +121,16 @@ export function nativeChatStatusTurnOutcome(
|
||||
: null
|
||||
const stop =
|
||||
verdict === 'interruption' ? latestNativeChatOrcaStopCut(items, submissions, bodyOf) : null
|
||||
return stop && stop.cause !== 'crash' ? 'cancellation' : verdict
|
||||
return nativeChatStatusRequestOutcome(request, stop)
|
||||
}
|
||||
|
||||
/** Named database readers supply the same selected cut without rendering the chat. */
|
||||
export function nativeChatStatusRequestOutcome(
|
||||
request: StructuredAgentSessionLatestRequest | null,
|
||||
stop: NativeChatOrcaStopCut | null
|
||||
): AgentTurnOutcome | null {
|
||||
const verdict = request
|
||||
? agentTurnVerdict({ state: request.turnState, outcome: request.outcome })
|
||||
: null
|
||||
return verdict === 'interruption' && stop && stop.cause !== 'crash' ? 'cancellation' : verdict
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user