ds-harness-remote-fast/packages/plugin/src/codex/virtual-history.ts

654 lines
24 KiB
TypeScript

import { projectCodexModel, projectCodexThread } from '@dsh-remote/client-core'
import type { CodexPermissionSnapshot } from '@dsh-remote/protocol'
import type { HarnessSessionGeneration } from '../harness-version.js'
import { contentBlocks, toolOutputImageBlocks } from './codex-image-codec.js'
import type { CodexModelSelection } from './virtual-catalog.js'
import { modelSelection } from './virtual-catalog.js'
import { turnEndReason } from './turn-end-reason.js'
import type { JsonRecord } from './virtual-values.js'
import { array, CODEX_SESSION_PREFIX, hashString, integer, normalizeTime, record, string } from './virtual-values.js'
const MAX_LIVE_TOOL_OUTPUT = 128 * 1024
const DEFAULT_HISTORY_MESSAGES = 50
export interface NativeEvent {
type: string
seq: number
time: number
data: unknown
sourceEventSeqs?: number[]
surfaceOp?: 'append'
| { op: 'replace'; start: number; end: number }
| { op: 'replace'; startSeq: number; endSeq: number }
}
export interface CodexNativeHistory {
header: {
version: number
id: string
createdAt: number
cwd?: string
model?: string
reasoningEffort?: string
isSeeded?: boolean
}
entries: Array<{ type: 'event'; event: NativeEvent; view?: ToolEventView }>
lastSeq: number
nextTurn: number
activeTurnId?: string
}
export interface CodexNativeHistoryPage extends CodexPermissionSnapshot {
header: CodexNativeHistory['header']
cursor: number
nextTurn: number
records: CodexNativeHistory['entries']
hasMore: boolean
activeTurnId?: string
}
export interface ToolEventView {
for: 'call' | 'result'
view: JsonRecord
}
export interface ProjectedNativeEvent {
type: string
data: unknown
view?: ToolEventView
}
export function projectCodexNativeHistory(
thread: JsonRecord,
sessionId: string,
sessionGeneration: HarnessSessionGeneration = 'legacy',
): CodexNativeHistory {
const entries: CodexNativeHistory['entries'] = []
let seq = 0
let turnNumber = 0
const active = activeTurnId(thread.turns)
const threadModel = projectCodexModel(thread)
const fallbackSelection: CodexModelSelection = threadModel.model === undefined
? modelSelection()
: {
provider: 'codex',
model: threadModel.model,
...(threadModel.reasoningEffort === undefined ? {} : { reasoningEffort: threadModel.reasoningEffort }),
}
const append = (
type: string,
data: unknown,
time = Date.now(),
view?: ToolEventView,
sourceEventSeqs?: number[],
): number => {
const eventSeq = seq++
entries.push({
type: 'event',
event: {
type,
seq: eventSeq,
time,
data: adaptEventData(type, data, sessionGeneration),
...(sourceEventSeqs === undefined ? {} : { sourceEventSeqs }),
...(isSurfaceEvent(type) ? { surfaceOp: 'append' as const } : {}),
},
...(view === undefined ? {} : { view }),
})
return eventSeq
}
for (const rawTurn of array(thread.turns)) {
const turn = record(rawTurn)
const turnItems = array(turn.items).map(record)
const toolImages = turnItems.flatMap(toolOutputImageBlocks)
let imageOwner = -1
for (let index = 0;index < turnItems.length;index += 1) {
if (turnItems[index]!.type === 'agentMessage') imageOwner = index
}
turnNumber += 1
const turnActive = isActiveCodexTurn(turn)
const time = normalizeTime(turn.createdAt) || normalizeTime(turn.startedAt) || normalizeTime(thread.createdAt) || Date.now()
append('turn/start', { turn: turnNumber }, time)
append('step/start', { turn: turnNumber, step: 1 }, time)
for (let itemIndex = 0;itemIndex < turnItems.length;itemIndex += 1) {
const item = turnItems[itemIndex]!
let toolCallSeq: number | undefined
const turnModel = projectCodexModel(turn)
const selection: CodexModelSelection = turnModel.model === undefined
? fallbackSelection
: {
provider: 'codex',
model: turnModel.model,
...(turnModel.reasoningEffort === undefined ? {} : { reasoningEffort: turnModel.reasoningEffort }),
}
for (const event of itemEvents(
item,
turnNumber,
1,
undefined,
selection,
sessionId,
itemIndex === imageOwner ? toolImages : [],
)) {
const eventSeq = append(
event.type,
event.data,
normalizeTime(item.createdAt) || time,
event.view,
event.type === 'tool/result' && toolCallSeq !== undefined ? [toolCallSeq] : undefined,
)
if (event.type === 'tool/call') toolCallSeq = eventSeq
}
}
if (turnActive) continue
append('step/end', { turn: turnNumber, step: 1 }, normalizeTime(turn.updatedAt) || normalizeTime(turn.completedAt) || time)
append('turn/end', {
turn: turnNumber,
reason: turnEndReason(turn),
}, normalizeTime(turn.updatedAt) || normalizeTime(turn.completedAt) || time)
}
const projected = projectCodexThread(thread)
return {
header: {
version: sessionGeneration === 'v3' ? 3 : 1,
id: sessionId,
createdAt: projected?.createdAt ?? Date.now(),
...(projected?.cwd === undefined ? {} : { cwd: projected.cwd }),
...(projected?.model === undefined ? {} : { model: projected.model }),
...(projected?.reasoningEffort === undefined ? {} : { reasoningEffort: projected.reasoningEffort }),
...(sessionGeneration === 'v3' ? { isSeeded: false } : {}),
},
entries,
lastSeq: seq - 1,
nextTurn: turnNumber,
...(active === undefined ? {} : { activeTurnId: active }),
}
}
export function paginateCodexNativeHistory(
history: CodexNativeHistory,
request: { beforeSeq?: number; throughSeq?: number; maxMessages?: number },
): CodexNativeHistoryPage {
const throughSeq = Math.min(request.throughSeq ?? history.lastSeq, history.lastSeq)
const endSeq = Math.min(throughSeq, request.beforeSeq === undefined ? throughSeq : request.beforeSeq - 1)
const window = endSeq < 0 ? [] : history.entries.filter(entry => entry.event.seq <= endSeq)
const maxMessages = request.maxMessages ?? DEFAULT_HISTORY_MESSAGES
let messages = 0
let cut = 0
for (let index = window.length - 1;index >= 0;index -= 1) {
const event = window[index]!.event
if (!isSurfaceEvent(event.type) || event.surfaceOp !== 'append') continue
messages += 1
if (messages >= maxMessages) {
cut = Math.min(event.seq, ...(event.sourceEventSeqs ?? []))
break
}
}
return {
header: history.header,
cursor: history.lastSeq,
nextTurn: history.nextTurn,
records: window.filter(entry => entry.event.seq >= cut),
hasMore: window.some(entry => entry.event.seq < cut),
...(history.activeTurnId === undefined ? {} : { activeTurnId: history.activeTurnId }),
}
}
export function adaptEventData(type: string, data: unknown, sessionGeneration: HarnessSessionGeneration): unknown {
if (sessionGeneration !== 'v3' || type !== 'assistant/message') return data
const value = record(data)
return Array.isArray(value.stream) ? value : { ...value, stream: [] }
}
export function adaptCodexHistoryPage(value: unknown, sessionGeneration: HarnessSessionGeneration): unknown {
if (sessionGeneration !== 'v3') return value
const page = record(value)
const sourceHeader = record(page.header)
const { seedLength: _seedLength, ...header } = sourceHeader
const records = Array.isArray(page.records)
? page.records.map(raw => {
const entry = record(raw)
const sourceEvent = record(entry.event)
const sourceSurfaceOp = record(sourceEvent.surfaceOp)
const surfaceOp = sourceEvent.surfaceOp === 'append'
? 'append'
: sourceSurfaceOp.op === 'replace'
&& integer(sourceSurfaceOp.startSeq) !== undefined
&& integer(sourceSurfaceOp.endSeq) !== undefined
? sourceSurfaceOp
: sourceSurfaceOp.op === 'replace'
&& integer(sourceSurfaceOp.start) !== undefined
&& integer(sourceSurfaceOp.end) !== undefined
? {
op: 'replace',
startSeq: sourceSurfaceOp.start,
endSeq: sourceSurfaceOp.end,
}
: sourceEvent.surfaceOp
return {
...entry,
event: {
...sourceEvent,
data: adaptEventData(string(sourceEvent.type) ?? '', sourceEvent.data, sessionGeneration),
...(surfaceOp === undefined ? {} : { surfaceOp }),
},
}
})
: page.records
return {
...page,
header: { ...header, version: 3, isSeeded: sourceHeader.isSeeded === true },
records,
}
}
export function itemEvents(
item: JsonRecord,
turn: number,
step: number,
requestId?: string,
selection: CodexModelSelection = modelSelection(),
sessionId = CODEX_SESSION_PREFIX,
supplementalImages: JsonRecord[] = [],
): ProjectedNativeEvent[] {
const type = string(item.type)
const id = string(item.id) ?? `${turn}:${step}:${hashString(JSON.stringify(item))}`
const text = itemText(item)
const itemModel = projectCodexModel(item)
const effectiveSelection = itemModel.model === undefined
? selection
: {
provider: selection.provider,
model: itemModel.model,
...(itemModel.reasoningEffort === undefined ? {} : { reasoningEffort: itemModel.reasoningEffort }),
}
if (type === 'userMessage') return [{
type: 'user/message',
data: {
id,
role: 'user',
content: messageContent(item, `${sessionId}:${id}`, 'text', text),
source: requestId === undefined || requestId === '' ? { kind: 'user' } : { kind: 'user', rpcId: requestId },
},
}]
if (type === 'agentMessage' || type === 'reasoning' || type === 'plan') return [{
type: 'assistant/message',
data: {
turn,
step,
message: {
id,
role: 'assistant',
content: messageContent(
item,
`${sessionId}:${id}`,
type === 'reasoning' ? 'reasoning' : 'text',
text,
type === 'agentMessage' ? supplementalImages : [],
),
source: { kind: 'model', provider: effectiveSelection.provider, model: effectiveSelection.model },
},
},
}]
if (type !== undefined && isToolItemType(type)) {
const name = toolEventName(type)
const args = toolArguments(item)
return [
{
type: 'tool/call',
data: { turn, step, callId: id, name, arguments: JSON.stringify(args) },
view: { for: 'call', view: toolCallView(item, type, args) },
},
toolResultEvent(item, turn, step, id, toolResultText(item, type, text)),
]
}
if (type === 'error') return [{
type: 'assistant/message',
data: {
turn,
step,
message: {
id,
role: 'assistant',
content: [{ type: 'text', text: text ?? 'CodeX reported an error.' }],
source: { kind: 'model', provider: effectiveSelection.provider, model: effectiveSelection.model },
},
},
}]
return []
}
function messageContent(
item: JsonRecord,
attachmentSeed: string,
fallbackType: 'text' | 'reasoning',
fallbackText?: string,
supplementalImages: JsonRecord[] = [],
): JsonRecord[] {
const source = item.content ?? item.input
const blocks = contentBlocks(source, attachmentSeed)
const images = contentBlocks(supplementalImages, `${attachmentSeed}:tool-output`)
if (blocks.length > 0 || images.length > 0) {
return [...(blocks.length > 0 ? blocks : [{ type: fallbackType, text: fallbackText ?? '' }]), ...images]
}
return [{ type: fallbackType, text: fallbackText ?? '' }]
}
export function toolResultEvent(
item: JsonRecord,
turn: number,
step: number,
id: string,
resultText: string,
): ProjectedNativeEvent {
const type = string(item.type) ?? 'unknown'
return {
type: 'tool/result',
data: {
turn,
step,
message: {
id: `${id}:result`,
role: 'user',
content: [{
type: 'tool-result',
toolCallId: id,
content: [{ type: 'text', text: resultText }],
...(item.status === 'failed' || item.success === false ? { isError: true } : {}),
}],
source: { kind: 'tool', callId: id },
},
},
view: { for: 'result', view: toolResultView(item, type, resultText) },
}
}
export function toolResultContentReplacement(event: ProjectedNativeEvent): ProjectedNativeEvent {
const data = record(event.data)
const message = record(data.message)
const content = array(message.content)
const result = record(content[0])
if (result.isError === undefined) return event
const { isError: _isError, ...stableResult } = result
return {
...event,
data: {
...data,
message: { ...message, content: [stableResult] },
},
}
}
export function isToolItemType(type: string | undefined): boolean {
return type === 'commandExecution'
|| type === 'mcpToolCall'
|| type === 'dynamicToolCall'
|| type === 'fileChange'
|| type === 'functionCallOutput'
|| type === 'hookPrompt'
|| type === 'collabAgentToolCall'
|| type === 'subAgentActivity'
|| type === 'webSearch'
|| type === 'imageView'
|| type === 'imageGeneration'
|| type === 'sleep'
|| type === 'enteredReviewMode'
|| type === 'exitedReviewMode'
|| type === 'contextCompaction'
}
function toolEventName(type: string): string {
if (type === 'fileChange') return 'codex.fileChange'
if (type === 'commandExecution') return 'codex.command'
if (type === 'webSearch') return 'codex.webSearch'
if (type === 'collabAgentToolCall' || type === 'subAgentActivity') return 'codex.subagent'
if (type === 'imageView' || type === 'imageGeneration') return 'codex.image'
if (type === 'enteredReviewMode' || type === 'exitedReviewMode') return 'codex.reviewMode'
if (type === 'contextCompaction') return 'codex.compaction'
return `codex.${type}`
}
function toolResultText(item: JsonRecord, type: string, text?: string): string {
if (type === 'fileChange') return fileChangeSummary(item)
if (type === 'webSearch') {
const count = array(item.results).length
return count === 0 ? 'Web search completed.' : `Web search returned ${count} result${count === 1 ? '' : 's'}.`
}
if (type === 'imageView') return `Viewed image: ${string(item.path) ?? 'image'}`
if (type === 'imageGeneration') {
const savedPath = string(item.savedPath)
return savedPath === undefined ? `Image generation ${string(item.status) ?? 'completed'}.` : `Generated image: ${savedPath}`
}
if (type === 'contextCompaction') return 'CodeX compacted the conversation context.'
if (type === 'enteredReviewMode') return `Entered review mode${string(item.review) ? `: ${string(item.review)}` : '.'}`
if (type === 'exitedReviewMode') return `Exited review mode${string(item.review) ? `: ${string(item.review)}` : '.'}`
if (type === 'sleep') return `Waited ${integer(item.durationMs) ?? 0} ms.`
if (type === 'subAgentActivity') {
return [string(record(item.kind).type) ?? string(item.kind) ?? 'Subagent activity', string(item.agentPath)]
.filter((value): value is string => value !== undefined).join(': ')
}
return text ?? itemText(record(item.result)) ?? itemText(record(item.output)) ?? string(item.status) ?? type
}
export function isSurfaceEvent(type: string): boolean {
return type === 'user/message' || type === 'assistant/message' || type === 'tool/result'
}
function toolCallView(item: JsonRecord, type: string, args: JsonRecord): JsonRecord {
if (type === 'commandExecution') {
return {
card: 'terminal',
title: commandText(item.command) ?? 'CodeX command',
...(typeof item.cwd === 'string' ? { cwd: item.cwd } : {}),
}
}
const locations = fileLocations(item)
if (type === 'fileChange') {
return {
card: 'generic',
title: locations.length === 0 ? 'CodeX file changes' : `Modify ${locations.length} file${locations.length === 1 ? '' : 's'}`,
kind: 'edit',
rawInput: args,
...(locations.length === 0 ? {} : { locations }),
}
}
if (type === 'webSearch') {
return {
card: 'generic',
title: string(item.query) ?? 'CodeX web search',
kind: 'search',
rawInput: args,
}
}
if (type === 'imageView' || type === 'imageGeneration') {
const path = string(item.path) ?? string(item.savedPath)
return {
card: 'generic',
title: type === 'imageView' ? 'View image' : 'Generate image',
kind: type === 'imageView' ? 'read' : 'other',
...(path === undefined ? {} : { locations: [{ path }] }),
}
}
if (type === 'collabAgentToolCall' || type === 'subAgentActivity') {
return {
card: 'generic',
title: type === 'collabAgentToolCall'
? `Subagent: ${string(item.tool) ?? 'collaboration'}`
: `Subagent activity: ${string(item.agentPath) ?? string(item.agentThreadId) ?? 'agent'}`,
kind: 'other',
rawInput: args,
}
}
if (type === 'contextCompaction') return { card: 'generic', title: 'Compact conversation context', kind: 'other' }
if (type === 'enteredReviewMode') return { card: 'generic', title: 'Enter review mode', kind: 'other' }
if (type === 'exitedReviewMode') return { card: 'generic', title: 'Exit review mode', kind: 'other' }
return {
card: 'generic',
title: toolDisplayName(item, type),
kind: 'other',
}
}
function toolResultView(item: JsonRecord, type: string, resultText: string): JsonRecord {
if (type === 'commandExecution') {
return {
card: 'terminal',
output: resultText,
...(typeof item.exitCode === 'number' && Number.isSafeInteger(item.exitCode) ? { exitCode: item.exitCode } : {}),
}
}
return {
card: 'generic',
...(type === 'fileChange' ? { title: item.status === 'inProgress' ? 'CodeX file changes' : 'CodeX file changes completed' } : {}),
...(type === 'mcpToolCall' && item.status === 'inProgress'
? { title: 'CodeX MCP tool in progress', content: [{ type: 'text', text: resultText }] }
: {}),
}
}
function toolDisplayName(item: JsonRecord, type: string): string {
return string(item.name)
?? string(item.tool)
?? string(record(item.tool).name)
?? (type === 'mcpToolCall' ? 'CodeX MCP tool' : humanizeItemType(type))
}
function fileLocations(item: JsonRecord): Array<{ path: string }> {
return array(item.changes)
.map(value => string(record(value).path))
.filter((path): path is string => path !== undefined && path.length > 0)
.map(path => ({ path }))
}
export function itemText(value: JsonRecord): string | undefined {
if (typeof value.text === 'string') return value.text
if (typeof value.content === 'string') return value.content
const content = Array.isArray(value.content)
? value.content
: Array.isArray(value.input) ? value.input : undefined
if (content !== undefined) {
const text = content.map(part => {
if (typeof part === 'string') return part
const block = record(part)
return string(block.text) ?? string(block.content) ?? ''
}).filter(Boolean).join('\n')
if (text !== '') return text
}
if (Array.isArray(value.summary)) return value.summary.filter(item => typeof item === 'string').join('\n')
if (typeof value.output === 'string') return value.output
if (typeof value.aggregatedOutput === 'string') return value.aggregatedOutput
return undefined
}
function toolArguments(item: JsonRecord): JsonRecord {
if (item.type === 'commandExecution') return { command: commandText(item.command) ?? item.command ?? '' }
if (item.type === 'fileChange') return {
changes: array(item.changes).map(value => {
const change = record(value)
const kind = typeof change.kind === 'string' ? change.kind : string(record(change.kind).type)
return {
...(typeof change.path === 'string' ? { path: change.path } : {}),
...(kind === undefined ? {} : { kind }),
}
}),
}
if (item.type === 'webSearch') return { query: string(item.query) ?? '' }
if (item.type === 'imageView') return { path: string(item.path) ?? '' }
if (item.type === 'imageGeneration') return {
...(string(item.revisedPrompt) === undefined ? {} : { prompt: string(item.revisedPrompt) }),
transparentBackground: item.transparentBackground === true,
}
if (item.type === 'collabAgentToolCall') return {
tool: string(item.tool) ?? 'collaboration',
receiverThreadIds: array(item.receiverThreadIds).filter(value => typeof value === 'string'),
...(string(item.model) === undefined ? {} : { model: string(item.model) }),
}
if (item.type === 'subAgentActivity') return {
agentThreadId: string(item.agentThreadId) ?? '',
agentPath: string(item.agentPath) ?? '',
kind: string(record(item.kind).type) ?? string(item.kind) ?? 'activity',
}
if (item.type === 'sleep') return { durationMs: integer(item.durationMs) ?? 0 }
if (item.type === 'enteredReviewMode' || item.type === 'exitedReviewMode') return {
review: string(item.review) ?? '',
}
if (item.type === 'contextCompaction') return {}
return { name: item.name ?? item.tool ?? item.type ?? 'tool', arguments: item.arguments ?? item.input ?? {} }
}
export function fileChangeSummary(item: JsonRecord): string {
const changes = array(item.changes).map(value => {
const change = record(value)
const path = string(change.path)
const kind = typeof change.kind === 'string' ? change.kind : string(record(change.kind).type)
return [kind, path].filter((part): part is string => part !== undefined && part.length > 0).join(' ')
}).filter(Boolean)
return changes.length === 0 ? 'File changes completed.' : changes.join('\n')
}
export function sanitizedFileChanges(value: unknown): JsonRecord[] {
return array(value).flatMap(raw => {
const change = record(raw)
const path = string(change.path)
if (path === undefined) return []
const kind = typeof change.kind === 'string' ? change.kind : string(record(change.kind).type)
return [{ path, ...(kind === undefined ? {} : { kind }) }]
})
}
export function appendBoundedText(current: string, delta: string): string {
const value = `${current}${delta}`
if (value.length <= MAX_LIVE_TOOL_OUTPUT) return value
return `… earlier output omitted …\n${value.slice(value.length - MAX_LIVE_TOOL_OUTPUT)}`
}
function humanizeItemType(type: string): string {
const names: Record<string, string> = {
functionCallOutput: 'CodeX function output',
hookPrompt: 'CodeX hook prompt',
dynamicToolCall: 'CodeX tool',
collabAgentToolCall: 'CodeX subagent',
subAgentActivity: 'CodeX subagent activity',
webSearch: 'CodeX web search',
imageView: 'CodeX image view',
imageGeneration: 'CodeX image generation',
sleep: 'CodeX wait',
enteredReviewMode: 'CodeX review mode',
exitedReviewMode: 'CodeX review mode',
contextCompaction: 'CodeX context compaction',
}
return names[type] ?? 'CodeX tool'
}
export function commandText(value: unknown): string | undefined {
if (typeof value === 'string') return value
if (Array.isArray(value)) return value.filter(item => typeof item === 'string').join(' ')
const source = record(value)
return string(source.command) ?? string(source.text)
}
function activeTurnId(value: unknown): string | undefined {
if (!Array.isArray(value)) return undefined
for (let index = value.length - 1;index >= 0;index -= 1) {
const turn = record(value[index])
if (isActiveCodexTurn(turn) && typeof turn.id === 'string' && turn.id.length > 0) return turn.id
}
return undefined
}
function isActiveCodexTurn(turn: JsonRecord): boolean {
return turn.status === 'inProgress' || turn.status === 'running'
}
export function isCodexNativeHistoryPage(value: unknown, sessionId: string): value is CodexNativeHistoryPage {
const page = record(value)
const header = record(page.header)
return header.id === sessionId
&& integer(page.cursor) !== undefined
&& integer(page.nextTurn) !== undefined
&& Array.isArray(page.records)
&& typeof page.hasMore === 'boolean'
&& (page.activeTurnId === undefined || typeof page.activeTurnId === 'string')
}