572 lines
24 KiB
TypeScript
572 lines
24 KiB
TypeScript
import type { AgentAcpFrameData } from '@dsh-remote/protocol'
|
|
import { acpImageLimits } from './image-content.js'
|
|
import { piToolResult } from './pi-tool-result.js'
|
|
import type { AcpCatalogBackend, AcpModelSelection } from './virtual-catalog.js'
|
|
import { acpBackendLabel } from './virtual-catalog.js'
|
|
import type {
|
|
AcpClientLike,
|
|
AcpPermissionPreset,
|
|
AcpSessionState,
|
|
FollowState,
|
|
JsonRecord,
|
|
NativeEvent,
|
|
PendingApproval,
|
|
PiTurnOutcome,
|
|
} from './virtual-contract.js'
|
|
import {
|
|
AsyncValueQueue,
|
|
extractSessionId,
|
|
extractText,
|
|
isRecord,
|
|
isSurfaceEvent,
|
|
optionalPositiveInteger,
|
|
piPromptOutcome,
|
|
piStreamOutcome,
|
|
record,
|
|
string,
|
|
summarizeQuestions,
|
|
} from './virtual-contract.js'
|
|
|
|
/** Collaborates with one AcpVirtualHarness; never creates a second session or connection state. */
|
|
export interface AcpLiveProjectionContext {
|
|
readonly ensureSessionRegistered: (sessionId: string) => AcpSessionState | undefined
|
|
readonly sessions: Map<string, AcpSessionState>
|
|
readonly hydrateSession: (session: AcpSessionState) => Promise<void>
|
|
readonly historyPage: (session: AcpSessionState, options?: { beforeSeq?: number; throughSeq?: number; limit?: number; }) => { assistantStream: { revision: number; }; activeTurnId?: string | undefined; header: { version: number; id: string; createdAt: number; cwd: string; isSeeded: boolean; }; cursor: number; nextTurn: number; records: { type: "event"; event: NativeEvent; }[]; hasMore: boolean; }
|
|
readonly follows: Set<FollowState>
|
|
readonly backend: AcpCatalogBackend
|
|
readonly modelSelectionProjection: (sessionId: string) => { lastUsed: AcpModelSelection; next: AcpModelSelection; }
|
|
readonly client: AcpClientLike
|
|
readonly emitRemoteEvent: (event: string, args: unknown[]) => void
|
|
readonly selectedModels: Map<string, AcpModelSelection>
|
|
readonly publishProjection: (sessionId: string, key: string, value: unknown, seq?: number) => void
|
|
readonly nextProjectionSeq: () => number
|
|
readonly refreshSessionTitle: (session: AcpSessionState) => Promise<void>
|
|
readonly applySessionTitle: (session: AcpSessionState, title: string) => void
|
|
readonly publishWorkspaceBaseline: () => void
|
|
readonly pendingApprovals: Map<string, PendingApproval>
|
|
readonly emitApproval: (input: { eventId: string; agentId: string; request: JsonRecord; }) => void
|
|
readonly modelSelection: (sessionId: string) => AcpModelSelection
|
|
readonly permissionsProjection: (sessionId: string) => unknown
|
|
readonly permissionSelection: (sessionId: string) => AcpPermissionPreset | undefined
|
|
readonly rememberOpenedSession?: (sessionId: string) => void
|
|
readonly syncSessionCache?: (session: AcpSessionState) => void
|
|
}
|
|
|
|
export class AcpLiveProjection {
|
|
constructor(private readonly context: AcpLiveProjectionContext) {}
|
|
|
|
async sessionFollow(request: JsonRecord, signal: AbortSignal): Promise<AsyncIterable<unknown>> {
|
|
const sessionId = extractSessionId(request)
|
|
const session = this.context.ensureSessionRegistered(sessionId) ?? this.context.sessions.get(sessionId)
|
|
if (session === undefined) throw new Error('The Session was not found.')
|
|
await this.context.hydrateSession(session)
|
|
this.context.rememberOpenedSession?.(session.sessionId)
|
|
const history = this.context.historyPage(session, {
|
|
limit: optionalPositiveInteger(request.maxMessages) ?? 50,
|
|
})
|
|
const queue = new AsyncValueQueue(signal)
|
|
const follow: FollowState = {
|
|
sessionId,
|
|
acpSessionId: session.acpSessionId,
|
|
queue,
|
|
nextSeq: session.events.length,
|
|
turn: Math.max(0, ...session.events.map(entry => (isRecord(entry.event.data) && typeof entry.event.data.turn === 'number' ? entry.event.data.turn : 0))),
|
|
stepOpen: session.running,
|
|
streamActive: false,
|
|
assistantStreamRevision: 0,
|
|
accumulatedText: '',
|
|
activeToolCalls: new Set(),
|
|
piToolOutputs: new Map(),
|
|
piToolCalls: new Map(),
|
|
}
|
|
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: session.title ?? acpBackendLabel(this.context.backend),
|
|
sessionListMetadata: { blank: session.blank && session.events.length === 0, lastPromptAt: null },
|
|
modelSelection: this.context.modelSelectionProjection(sessionId),
|
|
permissions: this.context.permissionsProjection(sessionId),
|
|
imageLimits: acpImageLimits(this.context.backend),
|
|
},
|
|
},
|
|
assistantStream: { revision: 0 },
|
|
})
|
|
try {
|
|
const stream = await this.context.client.openStream(
|
|
session.acpSessionId,
|
|
frame => this.acceptAcpFrame(follow, frame),
|
|
closed => {
|
|
session.running = false
|
|
this.context.emitRemoteEvent('api-session/status', [sessionId, false])
|
|
this.closeFollowAfterRemoteStreamClosed(follow, piStreamOutcome(closed.reason))
|
|
},
|
|
signal,
|
|
)
|
|
follow.close = () => stream.close()
|
|
} catch (error) {
|
|
this.context.follows.delete(follow)
|
|
queue.close()
|
|
throw error
|
|
}
|
|
return queue.iterate(() => {
|
|
this.context.follows.delete(follow)
|
|
void follow.close?.().catch(() => undefined)
|
|
})
|
|
}
|
|
|
|
async ensureFollow(session: AcpSessionState): Promise<void> {
|
|
if ([...this.context.follows].some(follow => follow.sessionId === session.sessionId)) return
|
|
// Native UI opens session/follow; prompts before follow still work via Host stream open on demand.
|
|
const controller = new AbortController()
|
|
const queue = new AsyncValueQueue(controller.signal)
|
|
const follow: FollowState = {
|
|
sessionId: session.sessionId,
|
|
acpSessionId: session.acpSessionId,
|
|
queue,
|
|
nextSeq: session.events.length === 0 ? 0 : Math.max(...session.events.map(entry => entry.event.seq)) + 1,
|
|
turn: Math.max(0, ...session.events.map(entry => (isRecord(entry.event.data) && typeof entry.event.data.turn === 'number' ? entry.event.data.turn : 0))),
|
|
stepOpen: false,
|
|
streamActive: false,
|
|
assistantStreamRevision: 0,
|
|
accumulatedText: '',
|
|
activeToolCalls: new Set(),
|
|
piToolOutputs: new Map(),
|
|
piToolCalls: new Map(),
|
|
}
|
|
this.context.follows.add(follow)
|
|
const stream = await this.context.client.openStream(
|
|
session.acpSessionId,
|
|
frame => this.acceptAcpFrame(follow, frame),
|
|
closed => {
|
|
if (this.context.backend === 'pi') {
|
|
session.running = false
|
|
this.context.emitRemoteEvent('api-session/status', [session.sessionId, false])
|
|
}
|
|
this.closeFollowAfterRemoteStreamClosed(follow, piStreamOutcome(closed.reason))
|
|
},
|
|
)
|
|
follow.close = async () => {
|
|
controller.abort()
|
|
await stream.close()
|
|
}
|
|
}
|
|
|
|
acceptAcpFrame(follow: FollowState, frame: AgentAcpFrameData): void {
|
|
const method = frame.frame.method
|
|
const params = record(frame.frame.params)
|
|
if (method === 'session/update') {
|
|
this.acceptSessionUpdate(follow, params)
|
|
return
|
|
}
|
|
if (method === 'session/request_permission' || method === 'cursor/ask_question' || method === 'cursor/create_plan') {
|
|
this.acceptApproval(follow, params, method)
|
|
}
|
|
}
|
|
|
|
acceptSessionUpdate(follow: FollowState, params: JsonRecord): void {
|
|
const update = isRecord(params.update) ? params.update : params
|
|
const kind = string(update.sessionUpdate) ?? string(update.type)
|
|
const session = this.context.sessions.get(follow.sessionId)
|
|
if (kind === 'session_info_update') {
|
|
if (session && params.sessionId === follow.acpSessionId && typeof update.title === 'string') {
|
|
this.context.applySessionTitle(session, update.title)
|
|
}
|
|
return
|
|
}
|
|
if (kind === 'model_selection' && isRecord(update.selected)
|
|
&& update.selected.provider === this.context.backend && typeof update.selected.model === 'string') {
|
|
this.context.selectedModels.set(follow.sessionId, update.selected as unknown as AcpModelSelection)
|
|
this.context.publishProjection(follow.sessionId, 'modelSelection', this.context.modelSelectionProjection(follow.sessionId), this.context.nextProjectionSeq())
|
|
return
|
|
}
|
|
if (kind === 'agent_message_chunk' || kind === 'agent_message') {
|
|
const text = extractText(update)
|
|
if (text === undefined || text.length === 0) return
|
|
this.appendAssistantDelta(follow, text)
|
|
return
|
|
}
|
|
if (kind === 'tool_call' || kind === 'tool_call_update') {
|
|
const toolName = string(update.title) ?? string(update.toolName) ?? string(update.name) ?? 'tool'
|
|
const status = string(update.status)
|
|
const callId = string(update.toolCallId) ?? string(update.callId) ?? toolName
|
|
const terminal = status === 'completed' || status === 'failed'
|
|
if (this.context.backend === 'pi') {
|
|
const call = follow.piToolCalls.get(callId) ?? { name: toolName }
|
|
if (typeof update.title === 'string') call.name = update.title
|
|
if (update.rawInput !== undefined) call.input = update.rawInput
|
|
follow.piToolCalls.set(callId, call)
|
|
const output = piToolResult(update)
|
|
const delta = record(record(update._meta).terminal_output).data
|
|
if (typeof delta === 'string') {
|
|
const buffered = follow.piToolOutputs.get(callId) ?? { text: '', overflow: false }
|
|
if (!buffered.overflow) {
|
|
if (buffered.text.length + delta.length > 1_048_576) { buffered.text = ''; buffered.overflow = true }
|
|
else buffered.text += delta
|
|
}
|
|
follow.piToolOutputs.set(callId, buffered)
|
|
}
|
|
// Pi streams partial arguments while pending, then confirms final input
|
|
// at execution start. Do not freeze a partial/empty call in the transcript.
|
|
if (!terminal && status !== 'in_progress') return
|
|
if (!follow.activeToolCalls.has(callId)) {
|
|
this.ensurePiStep(follow, false)
|
|
this.finishPiAssistant(follow)
|
|
follow.piAfterTools = true
|
|
this.pushEvent(follow, 'tool/call', {
|
|
turn: follow.turn, step: follow.piStep ?? 1, callId, toolCallId: callId, name: call.name, toolName: call.name,
|
|
arguments: typeof call.input === 'string' ? call.input
|
|
: call.input != null ? JSON.stringify(call.input) : '{}',
|
|
status: terminal ? status === 'failed' ? 'failed' : 'finished' : 'running',
|
|
})
|
|
follow.activeToolCalls.add(callId)
|
|
}
|
|
if (terminal) {
|
|
const buffered = follow.piToolOutputs.get(callId)
|
|
const content = buffered ? [{
|
|
type: 'text', text: buffered.overflow
|
|
? '[Pi tool output exceeds the live preview limit; reload history to read the bounded persisted result.]' : buffered.text
|
|
}]
|
|
: output.content
|
|
this.pushEvent(follow, 'tool/result', {
|
|
turn: follow.turn, step: follow.piStep ?? 1, message: {
|
|
id: `${callId}:result`, role: 'user', content: [{
|
|
type: 'tool-result', toolCallId: callId,
|
|
content, ...(output.isError ? { isError: true } : {})
|
|
}], source: { kind: 'tool', callId },
|
|
}
|
|
})
|
|
follow.piToolOutputs.delete(callId)
|
|
follow.piToolCalls.delete(callId)
|
|
follow.activeToolCalls.delete(callId)
|
|
}
|
|
if (session !== undefined) session.updatedAt = Date.now()
|
|
return
|
|
}
|
|
if (kind === 'tool_call_update' && !terminal) return
|
|
if (kind === 'tool_call' && follow.activeToolCalls.has(callId)) return
|
|
this.pushEvent(follow, 'tool/call', {
|
|
turn: follow.turn,
|
|
step: 1,
|
|
callId,
|
|
name: toolName,
|
|
arguments: typeof update.parameters === 'object' && update.parameters !== null
|
|
? JSON.stringify(update.parameters)
|
|
: typeof update.rawInput === 'object' && update.rawInput !== null
|
|
? JSON.stringify(update.rawInput)
|
|
: '{}',
|
|
toolCallId: callId,
|
|
toolName,
|
|
status: status === 'completed' ? 'finished' : status === 'failed' ? 'failed' : 'running',
|
|
})
|
|
if (terminal) follow.activeToolCalls.delete(callId)
|
|
else follow.activeToolCalls.add(callId)
|
|
if (session !== undefined) session.updatedAt = Date.now()
|
|
return
|
|
}
|
|
if (kind === 'agent_thought_chunk') {
|
|
const text = extractText(update)
|
|
if (text === undefined || text.length === 0) return
|
|
this.appendReasoningDelta(follow, text)
|
|
return
|
|
}
|
|
if (kind === 'prompt_completed' || kind === 'prompt_failed') {
|
|
const hasLiveContent = follow.stepOpen || follow.streamActive
|
|
if (!hasLiveContent && Array.isArray(update.catchUp)) {
|
|
for (const item of update.catchUp) {
|
|
if (!isRecord(item) || typeof item.method !== 'string') continue
|
|
const params = isRecord(item.params) ? item.params : {}
|
|
if (item.method === 'session/update') this.acceptSessionUpdate(follow, params)
|
|
}
|
|
}
|
|
if (session !== undefined) {
|
|
session.running = false
|
|
session.updatedAt = Date.now()
|
|
this.context.emitRemoteEvent('api-session/status', [follow.sessionId, false])
|
|
this.context.publishWorkspaceBaseline()
|
|
if (kind === 'prompt_completed') void this.context.refreshSessionTitle(session)
|
|
}
|
|
this.closeFollowAfterRemoteStreamClosed(follow, piPromptOutcome(kind, update))
|
|
}
|
|
}
|
|
|
|
acceptApproval(follow: FollowState, params: JsonRecord, method: string): void {
|
|
const requestHandle = string(params.requestHandle)
|
|
if (requestHandle === undefined) return
|
|
const currentPermission = this.context.permissionSelection(follow.sessionId)
|
|
if (currentPermission === 'danger-full-access' && method === 'session/request_permission') {
|
|
void this.context.client.respond(requestHandle, 'allow-once').catch(() => undefined)
|
|
return
|
|
}
|
|
this.context.pendingApprovals.set(requestHandle, { requestHandle, sessionId: follow.sessionId })
|
|
const toolName = method === 'cursor/create_plan'
|
|
? (string(params.name) ?? 'plan')
|
|
: method === 'cursor/ask_question'
|
|
? (string(params.title) ?? 'question')
|
|
: (string(params.toolName) ?? string(record(params.toolCall).title) ?? 'permission')
|
|
const reason = method === 'cursor/create_plan'
|
|
? string(params.overview) ?? string(params.plan)
|
|
: method === 'cursor/ask_question'
|
|
? summarizeQuestions(params)
|
|
: string(params.reason) ?? string(record(record(params.toolCall).rawInput).message)
|
|
this.context.emitApproval({
|
|
eventId: requestHandle,
|
|
agentId: follow.sessionId,
|
|
request: {
|
|
toolName,
|
|
...(reason === undefined ? {} : { reason }),
|
|
},
|
|
})
|
|
}
|
|
|
|
pushAssistantChunk(follow: FollowState, chunk: JsonRecord): void {
|
|
let attempt = follow.assistantAttempt
|
|
if (attempt === undefined) {
|
|
attempt = {
|
|
attemptId: this.context.backend === 'pi' ? `pi-attempt:${follow.sessionId}:${follow.turn}:${follow.piStep ?? 1}:${follow.nextSeq}`
|
|
: `cursor-attempt:${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: this.context.backend === 'pi' ? follow.piStep ?? 1 : 1,
|
|
},
|
|
})
|
|
}
|
|
const time = Date.now()
|
|
const index = attempt.nextIndex++
|
|
// Durable streams use AssistantStreamRecord, unlike the timed chunks in
|
|
// the live feed. Without this discriminator the native reader treats a
|
|
// raw chunk as a packed run and throws while settling the conversation.
|
|
attempt.stream.push({ type: 'chunk', 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
|
|
follow.queue.push({
|
|
type: 'assistant-stream',
|
|
frame: {
|
|
type: 'end',
|
|
attemptId: attempt.attemptId,
|
|
revision: follow.assistantStreamRevision,
|
|
index: attempt.nextIndex,
|
|
outcome,
|
|
},
|
|
})
|
|
}
|
|
|
|
appendAssistantDelta(follow: FollowState, delta: string): void {
|
|
if (this.context.backend === 'pi') this.ensurePiStep(follow, true)
|
|
if (!follow.stepOpen) {
|
|
follow.turn += 1
|
|
follow.stepOpen = true
|
|
this.pushEvent(follow, 'turn/start', { turn: follow.turn })
|
|
this.pushEvent(follow, 'step/start', { turn: follow.turn, step: 1 })
|
|
}
|
|
if (follow.blockIndex === undefined) {
|
|
follow.blockIndex = (follow.reasoningBlockIndex ?? -1) + 1
|
|
follow.streamActive = true
|
|
this.pushAssistantChunk(follow, { type: 'block-start', index: follow.blockIndex, blockType: 'text' })
|
|
}
|
|
follow.accumulatedText += delta
|
|
this.pushAssistantChunk(follow, { type: 'text-delta', index: follow.blockIndex, text: delta })
|
|
}
|
|
|
|
appendReasoningDelta(follow: FollowState, delta: string): void {
|
|
if (this.context.backend === 'pi') {
|
|
this.ensurePiStep(follow, true)
|
|
follow.piReasoning = (follow.piReasoning ?? '') + delta
|
|
}
|
|
if (!follow.stepOpen) {
|
|
follow.turn += 1
|
|
follow.stepOpen = true
|
|
this.pushEvent(follow, 'turn/start', { turn: follow.turn })
|
|
this.pushEvent(follow, 'step/start', { turn: follow.turn, step: 1 })
|
|
}
|
|
if (follow.reasoningBlockIndex === undefined) {
|
|
follow.reasoningBlockIndex = (follow.blockIndex ?? -1) + 1
|
|
follow.streamActive = true
|
|
this.pushAssistantChunk(follow, { type: 'block-start', index: follow.reasoningBlockIndex, blockType: 'reasoning' })
|
|
}
|
|
this.pushAssistantChunk(follow, { type: 'reasoning-delta', index: follow.reasoningBlockIndex, text: delta })
|
|
}
|
|
|
|
/** Pi model steps settle before tools; a tool round does not end the turn. */
|
|
ensurePiStep(follow: FollowState, advanceAfterTools: boolean): void {
|
|
if (!follow.stepOpen) {
|
|
follow.turn++
|
|
follow.piStep = 1
|
|
follow.stepOpen = true
|
|
this.pushEvent(follow, 'turn/start', { turn: follow.turn })
|
|
this.pushEvent(follow, 'step/start', { turn: follow.turn, step: 1 })
|
|
} else if (advanceAfterTools && follow.piAfterTools) {
|
|
this.pushEvent(follow, 'step/end', { turn: follow.turn, step: follow.piStep ?? 1 })
|
|
follow.piStep = (follow.piStep ?? 1) + 1
|
|
this.pushEvent(follow, 'step/start', { turn: follow.turn, step: follow.piStep })
|
|
}
|
|
if (advanceAfterTools) follow.piAfterTools = false
|
|
}
|
|
|
|
finishPiAssistant(follow: FollowState, outcome: PiTurnOutcome = { kind: 'completed' }): void {
|
|
if (!follow.streamActive) return
|
|
const blocks = [
|
|
{ index: follow.reasoningBlockIndex, type: 'reasoning', text: follow.piReasoning ?? '' },
|
|
{ index: follow.blockIndex, type: 'text', text: follow.accumulatedText },
|
|
].filter((block): block is { index: number; type: string; text: string } => block.index !== undefined)
|
|
.sort((a, b) => a.index - b.index)
|
|
for (const { index, type, text } of blocks) this.pushAssistantChunk(follow, { type: 'block-end', index, block: { type, text } })
|
|
const reason = outcome.kind === 'error' ? { kind: 'error', failure: outcome.error }
|
|
: outcome.kind === 'aborted' ? { kind: 'aborted', failure: { code: 'ABORTED', message: 'Pi reply interrupted.' } }
|
|
: { kind: outcome.kind === 'max-tokens' ? 'max-tokens' : 'stop' }
|
|
this.pushAssistantChunk(follow, { type: 'finish', reason })
|
|
const selection = this.context.modelSelection(follow.sessionId)
|
|
const seq = this.pushEvent(follow, 'assistant/message', {
|
|
turn: follow.turn, step: follow.piStep ?? 1,
|
|
message: {
|
|
id: `${follow.sessionId}:${follow.turn}:${follow.piStep ?? 1}`,
|
|
role: 'assistant', content: blocks.map(({ type, text }) => ({ type, text })),
|
|
source: { kind: 'model', provider: selection.provider, model: selection.model },
|
|
},
|
|
stream: follow.assistantAttempt?.stream ?? [],
|
|
})
|
|
this.endAssistantAttempt(follow, { kind: 'committed', eventType: 'assistant/message', seq })
|
|
follow.streamActive = false
|
|
follow.blockIndex = undefined
|
|
follow.reasoningBlockIndex = undefined
|
|
follow.accumulatedText = ''
|
|
follow.piReasoning = ''
|
|
}
|
|
|
|
closeFollowAfterRemoteStreamClosed(follow: FollowState, outcome: PiTurnOutcome = { kind: 'completed' }): void {
|
|
const session = this.context.sessions.get(follow.sessionId)
|
|
if (session !== undefined) session.running = false
|
|
if (this.context.backend === 'pi') {
|
|
this.finishPiAssistant(follow, outcome)
|
|
if (follow.stepOpen) {
|
|
this.pushEvent(follow, 'step/end', { turn: follow.turn, step: follow.piStep ?? 1 })
|
|
this.pushEvent(follow, 'turn/end', { turn: follow.turn, reason: outcome })
|
|
}
|
|
follow.stepOpen = false
|
|
follow.piStep = 1
|
|
follow.piAfterTools = false
|
|
follow.piToolOutputs.clear()
|
|
follow.piToolCalls.clear()
|
|
follow.activeToolCalls.clear()
|
|
if (session !== undefined) this.context.syncSessionCache?.(session)
|
|
return
|
|
}
|
|
if (follow.streamActive) {
|
|
if (follow.reasoningBlockIndex !== undefined) {
|
|
this.pushAssistantChunk(follow, {
|
|
type: 'block-end',
|
|
index: follow.reasoningBlockIndex,
|
|
block: { type: 'reasoning', text: '' },
|
|
})
|
|
follow.reasoningBlockIndex = undefined
|
|
}
|
|
if (follow.blockIndex !== undefined) {
|
|
const fullText = follow.accumulatedText
|
|
this.pushAssistantChunk(follow, {
|
|
type: 'block-end',
|
|
index: follow.blockIndex,
|
|
block: { type: 'text', text: fullText },
|
|
})
|
|
}
|
|
this.pushAssistantChunk(follow, {
|
|
type: 'finish',
|
|
reason: { kind: 'stop' },
|
|
})
|
|
const fullText = follow.accumulatedText
|
|
const selection = this.context.modelSelection(follow.sessionId)
|
|
const stream = follow.assistantAttempt?.stream ?? []
|
|
const assistantMessageSeq = this.pushEvent(follow, 'assistant/message', {
|
|
turn: follow.turn,
|
|
step: 1,
|
|
message: {
|
|
id: `${follow.sessionId}:${follow.turn}`,
|
|
role: 'assistant',
|
|
content: [{ type: 'text', text: fullText }],
|
|
source: { kind: 'model', provider: selection.provider, model: selection.model },
|
|
},
|
|
stream,
|
|
})
|
|
this.endAssistantAttempt(follow, {
|
|
kind: 'committed',
|
|
eventType: 'assistant/message',
|
|
seq: assistantMessageSeq,
|
|
})
|
|
this.pushEvent(follow, 'step/end', { turn: follow.turn, step: 1 })
|
|
this.pushEvent(follow, 'turn/end', { turn: follow.turn, reason: { kind: 'completed' } })
|
|
} else if (follow.stepOpen) {
|
|
this.pushEvent(follow, 'step/end', { turn: follow.turn, step: 1 })
|
|
this.pushEvent(follow, 'turn/end', { turn: follow.turn, reason: { kind: 'completed' } })
|
|
}
|
|
follow.streamActive = false
|
|
follow.stepOpen = false
|
|
follow.blockIndex = undefined
|
|
follow.reasoningBlockIndex = undefined
|
|
follow.accumulatedText = ''
|
|
follow.piToolOutputs.clear()
|
|
follow.piToolCalls.clear()
|
|
if (session !== undefined) this.context.syncSessionCache?.(session)
|
|
}
|
|
|
|
pushEvent(follow: FollowState, type: string, data: unknown): number {
|
|
const session = this.context.sessions.get(follow.sessionId)
|
|
const seq = session !== undefined ? session.events.length : follow.nextSeq++
|
|
const event: NativeEvent = {
|
|
type,
|
|
seq,
|
|
time: Date.now(),
|
|
data,
|
|
...(isSurfaceEvent(type) ? { surfaceOp: 'append' as const } : {}),
|
|
}
|
|
if (session !== undefined) {
|
|
session.events.push({ type: 'event', event })
|
|
this.context.syncSessionCache?.(session)
|
|
}
|
|
for (const f of this.context.follows) {
|
|
if (f.sessionId === follow.sessionId) {
|
|
f.queue.push({ type: 'event', event })
|
|
f.nextSeq = seq + 1
|
|
}
|
|
}
|
|
return seq
|
|
}
|
|
}
|