Files
archived-orca/src/shared/native-chat/transcript/native-chat-turn-grouping.ts
T

174 lines
5.9 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Share desktop/mobile turn ownership, bar placement and row order.
import type { AgentJournalRenderItem } from '../../agent-session/journal/agent-session-journal-types'
import { readAgentJournalTurn } from '../../agent-session/lifecycle/agent-session-turn-record'
import type { NativeChatRole } from '../native-chat-types'
type NativeChatTurnRow = { id: string; role: NativeChatRole }
/** Which rows can open a turn by themselves: in a conversation, its user rows. */
export type NativeChatOpensTurn = (message: NativeChatTurnRow) => boolean
export const nativeChatUserRowOpensTurn: NativeChatOpensTurn = (message) => message.role === 'user'
/** Host turn attribution wins over mid-turn send position. Unmapped rows use preceding-user grouping;
* opensTurn restricts which unmapped rows can anchor turns in interleaved streams. */
export function nativeChatRowTurnKeys(
messages: readonly NativeChatTurnRow[],
turnKeysByItemId?: ReadonlyMap<string, string> | null,
opensTurn: NativeChatOpensTurn = nativeChatUserRowOpensTurn
): (string | undefined)[] {
let currentTurnKey: string | undefined
return messages.map((message) => {
const owned = turnKeysByItemId?.get(message.id)
if (owned !== undefined) {
currentTurnKey = owned
return owned
}
if (opensTurn(message)) {
currentTurnKey = message.id
}
return currentTurnKey
})
}
/** Legacy unscoped hosts assign rows between root records to that turn’s mapped opener. Openers key themselves;
* steers inherit only after later turn content proves continuation, so fresh tail sends keep waiting. Rows before the first record remain unmapped. */
export function nativeChatJournalOrderTurnKeys(
items: readonly AgentJournalRenderItem[],
recordKeys: ReadonlyMap<string, string | null>
): ReadonlyMap<string, string> {
const openers = new Set([...recordKeys.values()].filter((key) => key !== null))
const keys = new Map<string, string>()
let currentKey: string | null = null
// User items folded into the current turn, held until a later row proves the turn continued.
let pendingUserItemIds: string[] = []
for (const item of items) {
if (recordKeys.has(item.itemId)) {
currentKey = recordKeys.get(item.itemId) ?? null
pendingUserItemIds = []
continue
}
if (readAgentJournalTurn(item.body)) {
continue
}
if (item.body.kind === 'message' && item.body.role === 'user') {
if (openers.has(item.itemId)) {
keys.set(item.itemId, item.itemId)
} else if (currentKey !== null) {
pendingUserItemIds.push(item.itemId)
}
continue
}
if (currentKey !== null) {
for (const userItemId of pendingUserItemIds) {
keys.set(userItemId, currentKey)
}
pendingUserItemIds = []
keys.set(item.itemId, currentKey)
}
}
return keys
}
/** Place each turn bar at its first row; use an above-row bar when the provider opened it or its user opener is unloaded. */
export function nativeChatTurnBarRows(
messages: readonly { id: string }[],
turnKeys: readonly (string | undefined)[]
): ReadonlyMap<string, { index: number; above: boolean }> {
const bars = new Map<string, { index: number; above: boolean }>()
turnKeys.forEach((turnKey, index) => {
if (turnKey !== undefined && !bars.has(turnKey)) {
bars.set(turnKey, { index, above: messages[index]?.id !== turnKey })
}
})
return bars
}
/** Return draw indexes or null for journal order. Provider-queued sends are written mid-turn but open only after earlier work ends;
* draw each opener after that prior work and just before its own turn’s rows. */
export function nativeChatTurnDrawOrder(
messages: readonly NativeChatTurnRow[],
turnKeys: readonly (string | undefined)[],
openers: ReadonlySet<string>
): number[] | null {
const opensTurn = (index: number): boolean =>
messages[index]?.role === 'user' &&
turnKeys[index] === messages[index].id &&
openers.has(messages[index].id)
const firstRow = new Map<string, number>()
turnKeys.forEach((turnKey, index) => {
if (turnKey !== undefined && !firstRow.has(turnKey)) {
firstRow.set(turnKey, index)
}
})
const moved = new Map<number, number>()
const waiting = new Set<number>()
const waitingByTurn = new Map<string, number[]>()
let lastContentRow = -1
const finish = (index: number): void => {
if (waiting.delete(index) && lastContentRow > index) {
moved.set(index, lastContentRow)
}
}
for (const [index, message] of messages.entries()) {
if (opensTurn(index)) {
waiting.add(index)
const turn = waitingByTurn.get(message.id)
if (turn) {
turn.push(index)
} else {
waitingByTurn.set(message.id, [index])
}
continue
}
const turnKey = turnKeys[index]
if (turnKey === undefined) {
continue
}
const first = firstRow.get(turnKey) ?? index
for (const openerIndex of waiting) {
if (openerIndex >= first) {
break
}
finish(openerIndex)
}
for (const openerIndex of waitingByTurn.get(turnKey) ?? []) {
finish(openerIndex)
}
waitingByTurn.delete(turnKey)
lastContentRow = index
}
for (const index of waiting) {
finish(index)
}
if (moved.size === 0) {
return null
}
const movedAfter = new Map<number, number[]>()
for (let index = 0; index < messages.length; index += 1) {
const after = moved.get(index)
if (after === undefined) {
continue
}
const indexes = movedAfter.get(after)
if (indexes) {
indexes.push(index)
} else {
movedAfter.set(after, [index])
}
}
return messages.flatMap((_, index) => [
...(moved.has(index) ? [] : [index]),
...(movedAfter.get(index) ?? [])
])
}
/** `rows` in the transcript's draw order. */
export function nativeChatRowsInDrawOrder<T>(
rows: readonly T[],
drawOrder: readonly number[] | null
): readonly T[] {
return drawOrder === null ? rows : drawOrder.map((index) => rows[index]!)
}