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

605 lines
24 KiB
TypeScript

import type { CodexPermissionPreset } from '@dsh-remote/protocol'
import { projectCodexModel } from '@dsh-remote/client-core'
import type { HarnessSessionGeneration } from '../harness-version.js'
import { collectImageBlocks, toolOutputImageBlocks } from './codex-image-codec.js'
import { codexPermissionPresetFromResponse } from './permissions.js'
import type { CodexModelDirectory, CodexModelSelection } from './virtual-catalog.js'
import { CODEX_PROVIDER, modelSelectionProjection } from './virtual-catalog.js'
import type { CodexImageAttachmentEntry, FollowState, PendingApproval, StreamedBlock } from './virtual-contract.js'
import {
AsyncValueQueue,
CODEX_IMAGE_ATTACHMENT_PREFIX,
codexImageLimitsProjection,
codexPermissionsProjection,
sessionIdFromAddress,
} from './virtual-contract.js'
import type { CodexNativeHistoryPage, NativeEvent, ProjectedNativeEvent, ToolEventView } from './virtual-history.js'
import {
adaptEventData,
appendBoundedText,
commandText,
fileChangeSummary,
isSurfaceEvent,
isToolItemType,
itemEvents,
itemText,
sanitizedFileChanges,
toolResultContentReplacement,
toolResultEvent,
} from './virtual-history.js'
import { turnEndReason } from './turn-end-reason.js'
import type { CodexClientLike, JsonRecord } from './virtual-values.js'
import { array, integer, nativeThreadId, optionalPositiveInteger, record, string } from './virtual-values.js'
/** Collaborates with one CodexVirtualHarness; never creates a second session or connection state. */
export interface CodexLiveProjectionContext {
readonly readHistoryPage: (threadId: string, page: { beforeSeq?: number; throughSeq?: number; maxMessages?: number; }, signal?: AbortSignal) => Promise<CodexNativeHistoryPage>
readonly models: (signal?: AbortSignal) => Promise<CodexModelDirectory>
readonly pendingRequestIds: Map<string, string>
readonly follows: Set<FollowState>
readonly sessionTitle: (sessionId: string) => string | null
readonly modelSelection: (sessionId: string, directory?: CodexModelDirectory) => CodexModelSelection
readonly permissionSelection: (sessionId: string) => CodexPermissionPreset | undefined
readonly sessionGeneration: HarnessSessionGeneration
readonly client: CodexClientLike
readonly closed: boolean
readonly rememberOpenedSession: (sessionId: string) => void
readonly nextProjectionSeq: () => number
readonly updateThreadName: (threadId: string, name: string) => void
readonly publishProjection: (sessionId: string, key: string, value: unknown, seq: number) => void
readonly setPermissionSelection: (sessionId: string, preset: CodexPermissionPreset | undefined) => void
readonly emitRemoteEvent: (event: string, args: unknown[]) => void
readonly selectedModels: Map<string, CodexModelSelection>
readonly refreshAndPublishWorkspaces: (force?: boolean) => Promise<void>
readonly pendingApprovals: Map<string, PendingApproval>
readonly emitApproval: (input: { eventId: string; agentId: string; request: JsonRecord; }) => void
readonly imageAttachments: Map<string, CodexImageAttachmentEntry>
readonly invalidateThreadHistory?: (threadId: string) => void
}
export class CodexLiveProjection {
constructor(private readonly context: CodexLiveProjectionContext) {}
async sessionFollow(request: JsonRecord, signal: AbortSignal): Promise<AsyncIterable<unknown>> {
const sessionId = sessionIdFromAddress(record(request.address))
const threadId = nativeThreadId(sessionId)
// History and model metadata are independent reads. The workspace catalog
// is refreshed after the stream is ready so a slow project/thread index
// cannot delay the first session snapshot.
const historyPromise = this.context.readHistoryPage(threadId, {
maxMessages: optionalPositiveInteger(request.maxMessages),
}, signal)
const directoryPromise = this.context.models(signal).catch(() => undefined)
const [history, directory] = await Promise.all([historyPromise, directoryPromise])
const queue = new AsyncValueQueue(signal)
const follow: FollowState = {
sessionId,
threadId,
queue,
nextSeq: history.cursor + 1,
turn: history.nextTurn,
stepOpen: history.activeTurnId !== undefined,
startedItems: new Set(),
completedItems: new Set(),
streamedBlocks: new Map(),
nextBlockIndex: 0,
streamActive: false,
assistantStreamRevision: 0,
liveItems: new Map(),
liveToolOutput: new Map(),
liveToolResultSeq: new Map(),
pendingToolImages: [],
requestId: this.context.pendingRequestIds.get(sessionId),
...(history.activeTurnId === undefined ? {} : { activeTurnId: history.activeTurnId }),
}
this.context.follows.add(follow)
queue.push({
type: 'snapshot',
header: history.header,
cursor: history.cursor,
records: history.records,
hasMore: history.hasMore,
projections: {
asOfSeq: history.cursor,
values: {
title: this.context.sessionTitle(sessionId),
sessionListMetadata: { blank: history.cursor < 0, lastPromptAt: null },
modelSelection: modelSelectionProjection(this.context.modelSelection(sessionId, directory)),
permissions: codexPermissionsProjection(this.context.permissionSelection(sessionId)),
imageLimits: codexImageLimitsProjection(),
},
},
...(this.context.sessionGeneration === 'v3' ? { assistantStream: { revision: 0 } } : {}),
})
try {
const stream = await this.context.client.subscribe(
threadId,
frame => this.acceptCodexFrame(follow, frame),
signal,
() => this.closeFollowAfterRemoteStreamClosed(follow),
)
if (this.context.closed || signal.aborted) {
await stream.close().catch(() => undefined)
signal.throwIfAborted()
throw new Error('The CodeX virtual Harness is closed.')
}
follow.close = () => stream.close()
void this.context.refreshAndPublishWorkspaces().catch(() => undefined)
} catch (error) {
this.context.follows.delete(follow)
queue.close()
throw error
}
this.context.rememberOpenedSession(sessionId)
return queue.iterate(() => {
this.context.follows.delete(follow)
void follow.close?.().catch(() => undefined)
})
}
acceptCodexFrame(follow: FollowState, frame: { method: string; params: unknown }): void {
const params = record(frame.params)
if (frame.method === 'thread/name/updated') {
const name = string(params.threadName)
if (name === undefined) return
const seq = this.context.nextProjectionSeq()
this.context.updateThreadName(follow.threadId, name)
const title = name.trim() === '' ? null : name.slice(0, 256)
this.context.publishProjection(follow.sessionId, 'title', title, seq)
return
}
if (frame.method === 'thread/settings/updated') {
const preset = codexPermissionPresetFromResponse(params)
this.context.setPermissionSelection(follow.sessionId, preset)
return
}
this.context.invalidateThreadHistory?.(follow.threadId)
if (frame.method === 'turn/started') {
const turn = record(params.turn)
const turnModel = projectCodexModel(turn)
if (turnModel.model !== undefined) {
const selected: CodexModelSelection = {
provider: CODEX_PROVIDER,
model: turnModel.model,
...(turnModel.reasoningEffort === undefined ? {} : { reasoningEffort: turnModel.reasoningEffort }),
}
this.context.selectedModels.set(follow.sessionId, selected)
this.context.publishProjection(
follow.sessionId,
'modelSelection',
modelSelectionProjection(selected),
this.context.nextProjectionSeq(),
)
}
this.endAssistantAttempt(follow, { kind: 'abandoned' })
this.resetLiveTurn(follow)
follow.turn += 1
follow.activeTurnId = string(turn.id)
follow.requestId = this.context.pendingRequestIds.get(follow.sessionId)
follow.stepOpen = true
this.pushEvent(follow, 'turn/start', { turn: follow.turn })
this.pushEvent(follow, 'step/start', { turn: follow.turn, step: 1 })
this.context.emitRemoteEvent('api-session/status', [follow.sessionId, true])
for (const item of array(turn.items)) this.acceptCompletedItem(follow, record(item), false)
return
}
if (frame.method === 'item/started' || frame.method === 'item/completed') {
const item = record(params.item)
const itemId = string(item.id)
if (frame.method === 'item/started' && itemId !== undefined) {
follow.startedItems.add(itemId)
follow.liveItems.set(itemId, item)
if (isToolItemType(string(item.type))) this.ensureToolStarted(follow, item)
}
if (frame.method === 'item/completed') this.acceptCompletedItem(follow, item, true)
return
}
if (frame.method === 'item/agentMessage/delta') {
const itemId = string(params.itemId) ?? `assistant:${follow.turn}`
const delta = string(params.delta)
if (delta === undefined) return
this.appendStreamDelta(follow, `agent:${itemId}`, itemId, 'text', delta)
return
}
if (frame.method === 'item/reasoning/summaryPartAdded') {
const itemId = string(params.itemId)
if (itemId !== undefined) this.ensureStreamBlock(
follow,
`reasoning-summary:${itemId}:${integer(params.summaryIndex) ?? 0}`,
itemId,
'reasoning',
)
return
}
if (frame.method === 'item/reasoning/summaryTextDelta'
|| frame.method === 'item/reasoning/textDelta'
|| frame.method === 'item/plan/delta') {
const itemId = string(params.itemId)
const delta = string(params.delta)
if (itemId === undefined || delta === undefined) return
const key = frame.method === 'item/plan/delta'
? `plan:${itemId}`
: frame.method === 'item/reasoning/summaryTextDelta'
? `reasoning-summary:${itemId}:${integer(params.summaryIndex) ?? 0}`
: `reasoning-content:${itemId}:${integer(params.contentIndex) ?? 0}`
this.appendStreamDelta(follow, key, itemId, 'reasoning', delta)
return
}
if (frame.method === 'turn/plan/updated') {
const todos = array(params.plan).flatMap(value => {
const item = record(value)
const content = string(item.step)
if (content === undefined) return []
const status = item.status === 'inProgress'
? 'in_progress'
: item.status === 'completed' ? 'completed' : 'pending'
return [{ content, status }]
})
this.pushEvent(follow, 'todo/write', { todos })
return
}
if (frame.method === 'item/commandExecution/outputDelta'
|| frame.method === 'item/fileChange/outputDelta'
|| frame.method === 'item/mcpToolCall/progress') {
const itemId = string(params.itemId)
const delta = frame.method === 'item/mcpToolCall/progress'
? string(params.message)
: string(params.delta)
if (itemId === undefined || delta === undefined) return
const type = frame.method === 'item/commandExecution/outputDelta'
? 'commandExecution'
: frame.method === 'item/fileChange/outputDelta' ? 'fileChange' : 'mcpToolCall'
const item = follow.liveItems.get(itemId) ?? { id: itemId, type, status: 'inProgress' }
follow.liveItems.set(itemId, item)
this.ensureToolStarted(follow, item)
const separator = frame.method === 'item/mcpToolCall/progress' && follow.liveToolOutput.has(itemId) ? '\n' : ''
const output = appendBoundedText(follow.liveToolOutput.get(itemId) ?? '', `${separator}${delta}`)
follow.liveToolOutput.set(itemId, output)
this.emitToolResult(follow, item, output)
return
}
if (frame.method === 'item/fileChange/patchUpdated') {
const itemId = string(params.itemId)
if (itemId === undefined) return
const previous = follow.liveItems.get(itemId) ?? { id: itemId, type: 'fileChange', status: 'inProgress' }
const item = { ...previous, changes: sanitizedFileChanges(params.changes) }
follow.liveItems.set(itemId, item)
this.ensureToolStarted(follow, item)
this.emitToolResult(follow, item, fileChangeSummary(item))
return
}
if (frame.method === 'thread/status/changed') {
const status = record(params.status)
const running = status.type === 'active'
this.context.emitRemoteEvent('api-session/status', [follow.sessionId, running])
return
}
if (frame.method === 'model/rerouted') {
const model = string(params.toModel)
if (model === undefined) return
const previous = this.context.selectedModels.get(follow.sessionId)
const selected: CodexModelSelection = {
provider: CODEX_PROVIDER,
model,
...(previous?.reasoningEffort === undefined ? {} : { reasoningEffort: previous.reasoningEffort }),
}
this.context.selectedModels.set(follow.sessionId, selected)
const seq = this.pushEvent(follow, 'request/context', { provider: CODEX_PROVIDER, model })
this.context.publishProjection(follow.sessionId, 'modelSelection', modelSelectionProjection(selected), seq)
return
}
if (frame.method === 'turn/completed') {
const turn = record(params.turn)
for (const item of array(turn.items)) this.acceptCompletedItem(follow, record(item), true)
if (follow.stepOpen) {
this.closeAllStreamBlocks(follow)
if (follow.streamActive) this.finishStream(follow)
this.endAssistantAttempt(follow, { kind: 'abandoned' })
this.pushEvent(follow, 'step/end', { turn: follow.turn, step: 1 })
follow.stepOpen = false
}
this.pushEvent(follow, 'turn/end', {
turn: follow.turn,
reason: turnEndReason(turn),
})
this.context.emitRemoteEvent('api-session/status', [follow.sessionId, false])
this.context.emitRemoteEvent('api-session/activity', [follow.sessionId, Date.now()])
follow.activeTurnId = undefined
this.context.pendingRequestIds.delete(follow.sessionId)
// A burst of completed turns should publish from one short-lived
// catalog snapshot instead of starting a full project/thread scan for
// every follow at once.
// Completion must observe a fresh upstream catalog. Reusing the short
// catalog cache here can publish the pre-completion `running` snapshot
// after the authoritative turn/end event and make clients look stuck.
void this.context.refreshAndPublishWorkspaces(true)
return
}
if (frame.method === 'item/commandExecution/requestApproval'
|| frame.method === 'item/fileChange/requestApproval') {
const requestHandle = string(params.requestHandle)
if (requestHandle === undefined) return
const command = commandText(params.command)
this.context.pendingApprovals.set(requestHandle, { requestHandle, sessionId: follow.sessionId })
this.context.emitApproval({
eventId: requestHandle,
agentId: follow.sessionId,
request: {
toolName: frame.method.includes('fileChange') ? 'CodeX file change' : 'CodeX command',
...(command === undefined ? {} : { reason: command }),
},
})
}
}
acceptCompletedItem(follow: FollowState, item: JsonRecord, settleAssistant: boolean): void {
const itemId = string(item.id) ?? `item:${follow.nextSeq}`
if (follow.completedItems.has(itemId)) return
const type = string(item.type)
if (type === 'agentMessage' && !settleAssistant) return
follow.completedItems.add(itemId)
this.closeItemStreamBlocks(follow, itemId, itemText(item))
if (type === 'agentMessage' && follow.streamActive && follow.streamedBlocks.size === 0) this.finishStream(follow)
const supplementalImages = type === 'agentMessage' ? follow.pendingToolImages : []
let assistantMessageSeq: number | undefined
for (const event of itemEvents(
item,
follow.turn,
1,
follow.requestId,
this.context.modelSelection(follow.sessionId),
follow.sessionId,
supplementalImages,
)) {
if (event.type === 'tool/call' && follow.startedItems.has(itemId)) continue
if (event.type === 'tool/result') this.pushToolResult(follow, itemId, event)
else {
const seq = this.pushEvent(follow, event.type, event.data, event.view)
if (event.type === 'assistant/message') assistantMessageSeq = seq
}
}
if (type === 'agentMessage' && assistantMessageSeq !== undefined) {
this.endAssistantAttempt(follow, {
kind: 'committed',
eventType: 'assistant/message',
seq: assistantMessageSeq,
})
}
if (type === 'agentMessage' && supplementalImages.length > 0) follow.pendingToolImages = []
else if (type !== undefined && isToolItemType(type)) {
follow.pendingToolImages.push(...toolOutputImageBlocks(item))
}
follow.liveItems.delete(itemId)
follow.liveToolOutput.delete(itemId)
follow.liveToolResultSeq.delete(itemId)
follow.liveToolResultSeq.delete(`${itemId}:call`)
}
pushEvent(
follow: FollowState,
type: string,
data: unknown,
view?: ToolEventView,
placement?: { replaceSeq: number },
): number {
const seq = follow.nextSeq++
const event: NativeEvent = {
type,
seq,
time: Date.now(),
data: adaptEventData(
type,
type === 'assistant/message' && this.context.sessionGeneration === 'v3' && follow.assistantAttempt !== undefined
? { ...record(data), stream: follow.assistantAttempt.stream }
: data,
this.context.sessionGeneration,
),
...(isSurfaceEvent(type)
? placement === undefined
? { surfaceOp: 'append' as const }
: {
surfaceOp: this.context.sessionGeneration === 'v3'
? { op: 'replace' as const, startSeq: placement.replaceSeq, endSeq: placement.replaceSeq }
: { op: 'replace' as const, start: placement.replaceSeq, end: placement.replaceSeq },
sourceEventSeqs: [placement.replaceSeq],
}
: {}),
}
this.cacheImageBlocks(follow.sessionId, event.data)
follow.queue.push({
type: 'event',
event,
...(view === undefined ? {} : { view }),
})
return seq
}
cacheImageBlocks(sessionId: string, value: unknown): void {
for (const block of collectImageBlocks(value)) {
const attachment = record(block.attachment)
const attachmentId = string(attachment.attachmentId)
const data = string(block.data)
if (attachmentId === undefined || data === undefined || !attachmentId.startsWith(CODEX_IMAGE_ATTACHMENT_PREFIX)) continue
this.context.imageAttachments.set(attachmentId, { sessionId, attachment, data })
}
}
ensureStreamBlock(
follow: FollowState,
key: string,
itemId: string,
kind: 'text' | 'reasoning',
): StreamedBlock {
const current = follow.streamedBlocks.get(key)
if (current !== undefined) return current
const block = { itemId, index: follow.nextBlockIndex++, kind, text: '' }
follow.streamedBlocks.set(key, block)
follow.streamActive = true
this.pushAssistantChunk(follow, { type: 'block-start', index: block.index, blockType: kind })
return block
}
appendStreamDelta(
follow: FollowState,
key: string,
itemId: string,
kind: 'text' | 'reasoning',
delta: string,
): void {
const block = this.ensureStreamBlock(follow, key, itemId, kind)
block.text = appendBoundedText(block.text, delta)
this.pushAssistantChunk(follow, {
type: kind === 'reasoning' ? 'reasoning-delta' : 'text-delta', index: block.index, text: delta,
})
}
closeItemStreamBlocks(follow: FollowState, itemId: string, fallback?: string): void {
const matches = [...follow.streamedBlocks].filter(([, block]) => block.itemId === itemId)
for (const [key, block] of matches) {
const text = block.text || fallback || ''
this.pushAssistantChunk(follow, {
type: 'block-end', index: block.index, block: { type: block.kind, text },
})
follow.streamedBlocks.delete(key)
}
}
closeAllStreamBlocks(follow: FollowState): void {
for (const block of follow.streamedBlocks.values()) {
this.pushAssistantChunk(follow, {
type: 'block-end', index: block.index, block: { type: block.kind, text: block.text },
})
}
follow.streamedBlocks.clear()
}
finishStream(follow: FollowState): void {
this.pushAssistantChunk(follow, { type: 'finish', reason: { kind: 'stop' } })
follow.streamActive = false
}
pushAssistantChunk(follow: FollowState, chunk: JsonRecord): void {
if (this.context.sessionGeneration !== 'v3') {
this.pushEvent(follow, 'assistant/chunk', { turn: follow.turn, step: 1, chunk })
return
}
let attempt = follow.assistantAttempt
if (attempt === undefined) {
attempt = {
attemptId: `codex-attempt:${follow.activeTurnId ?? follow.turn}:${follow.nextSeq}`,
startedAfterSeq: follow.nextSeq - 1,
nextIndex: 0,
stream: [],
}
follow.assistantAttempt = attempt
follow.assistantStreamRevision += 1
follow.queue.push({
type: 'assistant-stream',
frame: {
type: 'start',
attemptId: attempt.attemptId,
revision: follow.assistantStreamRevision,
startedAfterSeq: attempt.startedAfterSeq,
turn: follow.turn,
step: 1,
},
})
}
const time = Date.now()
const index = attempt.nextIndex++
attempt.stream.push({ time, chunk })
follow.assistantStreamRevision += 1
follow.queue.push({
type: 'assistant-stream',
frame: {
type: 'chunk',
attemptId: attempt.attemptId,
revision: follow.assistantStreamRevision,
index,
time,
chunk,
},
})
}
endAssistantAttempt(
follow: FollowState,
outcome: { kind: 'abandoned' } | { kind: 'committed'; eventType: 'assistant/message'; seq: number },
): void {
const attempt = follow.assistantAttempt
if (attempt === undefined) return
follow.assistantAttempt = undefined
follow.assistantStreamRevision += 1
if (this.context.sessionGeneration === 'v3') {
follow.queue.push({
type: 'assistant-stream',
frame: {
type: 'end',
attemptId: attempt.attemptId,
revision: follow.assistantStreamRevision,
index: attempt.nextIndex,
outcome,
},
})
}
}
ensureToolStarted(follow: FollowState, item: JsonRecord): void {
const itemId = string(item.id)
if (itemId === undefined) return
if (!follow.startedItems.has(itemId)) follow.startedItems.add(itemId)
if (follow.liveItems.get(itemId) !== item) follow.liveItems.set(itemId, item)
const call = itemEvents(
item,
follow.turn,
1,
follow.requestId,
this.context.modelSelection(follow.sessionId),
follow.sessionId,
).find(event => event.type === 'tool/call')
if (call !== undefined && !follow.liveToolResultSeq.has(`${itemId}:call`)) {
this.pushEvent(follow, call.type, call.data, call.view)
follow.liveToolResultSeq.set(`${itemId}:call`, -1)
}
}
emitToolResult(follow: FollowState, item: JsonRecord, resultText: string): void {
const itemId = string(item.id)
if (itemId === undefined) return
const result = toolResultEvent(item, follow.turn, 1, itemId, resultText)
this.pushToolResult(follow, itemId, result)
}
pushToolResult(follow: FollowState, itemId: string, event: ProjectedNativeEvent): void {
const previous = follow.liveToolResultSeq.get(itemId)
const projected = previous === undefined ? event : toolResultContentReplacement(event)
const seq = this.pushEvent(
follow,
projected.type,
projected.data,
projected.view,
previous === undefined ? undefined : { replaceSeq: previous },
)
follow.liveToolResultSeq.set(itemId, seq)
}
resetLiveTurn(follow: FollowState): void {
follow.startedItems.clear()
follow.completedItems.clear()
follow.streamedBlocks.clear()
follow.nextBlockIndex = 0
follow.streamActive = false
follow.assistantAttempt = undefined
follow.liveItems.clear()
follow.liveToolOutput.clear()
follow.liveToolResultSeq.clear()
follow.pendingToolImages = []
}
closeFollowAfterRemoteStreamClosed(follow: FollowState): void {
this.context.follows.delete(follow)
follow.queue.close()
this.context.emitRemoteEvent('api-session/status', [follow.sessionId, false])
}
}