431 lines
16 KiB
TypeScript
431 lines
16 KiB
TypeScript
|
/**
|
||
|
|
* CLI Bridge run handler — handles runs that use the agent bridge
|
||
|
|
* to communicate with Hermes CLI agent.
|
||
|
|
*/
|
||
|
|
|
||
|
|
import type { Server, Socket } from 'socket.io'
|
||
|
|
import { getSession, createSession, addMessage, updateSessionStats } from '../../../db/hermes/session-store'
|
||
|
|
import { updateUsage } from '../../../db/hermes/usage-store'
|
||
|
|
import { countTokens } from '../../../lib/context-compressor'
|
||
|
|
import { logger, bridgeLogger } from '../../logger'
|
||
|
|
import { AgentBridgeClient, type AgentBridgeMessage, type AgentBridgeOutput } from '../agent-bridge'
|
||
|
|
import { contentBlocksToString, extractTextForPreview } from './content-blocks'
|
||
|
|
import { buildCompressedHistory } from './compression'
|
||
|
|
import { pushState, replaceState } from './compression'
|
||
|
|
import { calcAndUpdateUsage } from './usage'
|
||
|
|
import {
|
||
|
|
flushBridgePendingToDb,
|
||
|
|
ensureOpenBridgeAssistantMessage,
|
||
|
|
syncBridgeReasoningToMessage,
|
||
|
|
recordBridgeToolStarted,
|
||
|
|
recordBridgeToolCompleted,
|
||
|
|
} from './bridge-message'
|
||
|
|
import { forceCompressBridgeHistory } from './compression'
|
||
|
|
import { summarizeToolArguments } from './response-utils'
|
||
|
|
import { buildDbHistory } from './compression'
|
||
|
|
import type { ContentBlock, SessionState } from './types'
|
||
|
|
import type { ChatMessage } from '../../../lib/context-compressor'
|
||
|
|
|
||
|
|
const BRIDGE_USAGE_FLUSH_DELAY_MS = 200
|
||
|
|
|
||
|
|
export async function handleBridgeRun(
|
||
|
|
nsp: ReturnType<Server['of']>,
|
||
|
|
socket: Socket,
|
||
|
|
data: { input: string | ContentBlock[]; session_id?: string; model?: string; instructions?: string; source?: string },
|
||
|
|
profile: string,
|
||
|
|
sessionMap: Map<string, SessionState>,
|
||
|
|
gatewayManager: any,
|
||
|
|
bridge: AgentBridgeClient,
|
||
|
|
_skipUserMessage = false,
|
||
|
|
loadSessionStateFromDbFn: (sid: string, sessionMap: Map<string, SessionState>) => Promise<SessionState>,
|
||
|
|
dequeueNextQueuedRun: (socket: Socket, sessionId: string, fallbackProfile?: string) => void,
|
||
|
|
) {
|
||
|
|
const { input, session_id, model, instructions } = data
|
||
|
|
if (!session_id) {
|
||
|
|
socket.emit('run.failed', { event: 'run.failed', error: 'session_id is required for cli source' })
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
const runMarker = `cli_run_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`
|
||
|
|
const now = Math.floor(Date.now() / 1000)
|
||
|
|
let state = sessionMap.get(session_id)
|
||
|
|
if (!state) {
|
||
|
|
state = getSession(session_id)
|
||
|
|
? await loadSessionStateFromDbFn(session_id, sessionMap)
|
||
|
|
: { messages: [], isWorking: false, events: [], queue: [] }
|
||
|
|
sessionMap.set(session_id, state)
|
||
|
|
}
|
||
|
|
|
||
|
|
state.isWorking = true
|
||
|
|
state.isAborting = false
|
||
|
|
state.profile = profile
|
||
|
|
state.source = 'cli'
|
||
|
|
state.activeRunMarker = runMarker
|
||
|
|
state.runId = undefined
|
||
|
|
state.abortController = undefined
|
||
|
|
state.bridgeOutput = ''
|
||
|
|
state.bridgePendingAssistantContent = ''
|
||
|
|
state.bridgePendingReasoningContent = ''
|
||
|
|
state.bridgeToolCounter = 0
|
||
|
|
state.bridgePendingTools = []
|
||
|
|
state.responseRun = undefined
|
||
|
|
|
||
|
|
const inputStr = contentBlocksToString(input)
|
||
|
|
state.messages.push({
|
||
|
|
id: state.messages.length + 1,
|
||
|
|
session_id,
|
||
|
|
runMarker,
|
||
|
|
role: 'user',
|
||
|
|
content: inputStr,
|
||
|
|
timestamp: now,
|
||
|
|
})
|
||
|
|
|
||
|
|
if (!getSession(session_id)) {
|
||
|
|
const previewText = extractTextForPreview(input)
|
||
|
|
const preview = previewText.replace(/[\r\n]/g, ' ').substring(0, 100)
|
||
|
|
createSession({ id: session_id, profile, source: 'cli', model, title: preview })
|
||
|
|
}
|
||
|
|
addMessage({
|
||
|
|
session_id,
|
||
|
|
role: 'user',
|
||
|
|
content: inputStr,
|
||
|
|
timestamp: now,
|
||
|
|
})
|
||
|
|
|
||
|
|
socket.join(`session:${session_id}`)
|
||
|
|
const emit = (event: string, payload: any) => {
|
||
|
|
const tagged = { ...payload, session_id }
|
||
|
|
nsp.to(`session:${session_id}`).emit(event, tagged)
|
||
|
|
if (!nsp.adapter.rooms.get(`session:${session_id}`)?.size && socket.connected) {
|
||
|
|
socket.emit(event, tagged)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
const history = await buildCompressedHistory(
|
||
|
|
session_id, profile,
|
||
|
|
gatewayManager.getUpstream(profile).replace(/\/$/, ''),
|
||
|
|
gatewayManager.getApiKey(profile) || undefined,
|
||
|
|
emit,
|
||
|
|
sessionMap,
|
||
|
|
)
|
||
|
|
|
||
|
|
try {
|
||
|
|
logger.info('[chat-run-socket] starting CLI bridge run for session %s', session_id)
|
||
|
|
bridgeLogger.info({
|
||
|
|
sessionId: session_id,
|
||
|
|
profile,
|
||
|
|
inputChars: inputStr.length,
|
||
|
|
historyMessages: history.length,
|
||
|
|
hasInstructions: Boolean(instructions),
|
||
|
|
}, '[chat-run-socket] starting CLI bridge run')
|
||
|
|
const started = await bridge.chat(session_id, input as AgentBridgeMessage, history, instructions, profile)
|
||
|
|
state.runId = started.run_id
|
||
|
|
bridgeLogger.info({
|
||
|
|
sessionId: session_id,
|
||
|
|
runId: started.run_id,
|
||
|
|
status: started.status,
|
||
|
|
}, '[chat-run-socket] CLI bridge run started')
|
||
|
|
pushState(sessionMap, session_id, 'run.started', {
|
||
|
|
event: 'run.started',
|
||
|
|
run_id: started.run_id,
|
||
|
|
queue_length: state.queue.length || 0,
|
||
|
|
})
|
||
|
|
emit('run.started', {
|
||
|
|
event: 'run.started',
|
||
|
|
run_id: started.run_id,
|
||
|
|
queue_length: state.queue.length || 0,
|
||
|
|
})
|
||
|
|
|
||
|
|
for await (const chunk of bridge.streamOutput(started.run_id)) {
|
||
|
|
await applyBridgeChunkAsync(nsp, socket, state, session_id, runMarker, chunk, emit, profile, sessionMap, gatewayManager, bridge, dequeueNextQueuedRun)
|
||
|
|
if (chunk.done) break
|
||
|
|
}
|
||
|
|
} catch (err: any) {
|
||
|
|
if (state.activeRunMarker !== runMarker) return
|
||
|
|
if (!state.isWorking) return
|
||
|
|
const queueLen = state.queue?.length ?? 0
|
||
|
|
state.isWorking = false
|
||
|
|
state.isAborting = false
|
||
|
|
state.profile = undefined
|
||
|
|
state.runId = undefined
|
||
|
|
state.activeRunMarker = undefined
|
||
|
|
state.events = []
|
||
|
|
flushBridgePendingToDb(state, session_id)
|
||
|
|
updateSessionStats(session_id)
|
||
|
|
const message = err instanceof Error ? err.message : String(err)
|
||
|
|
emit('run.failed', { event: 'run.failed', error: message, queue_remaining: queueLen })
|
||
|
|
const errUsage = await calcAndUpdateUsage(session_id, state, emit)
|
||
|
|
updateUsage(session_id, {
|
||
|
|
inputTokens: errUsage.inputTokens,
|
||
|
|
outputTokens: errUsage.outputTokens,
|
||
|
|
profile: state.profile,
|
||
|
|
})
|
||
|
|
if (queueLen > 0) dequeueNextQueuedRun(socket, session_id)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
async function applyBridgeChunkAsync(
|
||
|
|
nsp: ReturnType<Server['of']>,
|
||
|
|
socket: Socket,
|
||
|
|
state: SessionState,
|
||
|
|
sessionId: string,
|
||
|
|
runMarker: string,
|
||
|
|
chunk: AgentBridgeOutput,
|
||
|
|
emit: (event: string, payload: any) => void,
|
||
|
|
profile: string,
|
||
|
|
sessionMap: Map<string, SessionState>,
|
||
|
|
gatewayManager: any,
|
||
|
|
bridge: AgentBridgeClient,
|
||
|
|
dequeueNextQueuedRun: (socket: Socket, sessionId: string, fallbackProfile?: string) => void,
|
||
|
|
): Promise<void> {
|
||
|
|
if (state.activeRunMarker !== runMarker) {
|
||
|
|
bridgeLogger.info({
|
||
|
|
sessionId,
|
||
|
|
runId: chunk.run_id,
|
||
|
|
runMarker,
|
||
|
|
activeRunMarker: state.activeRunMarker,
|
||
|
|
}, '[chat-run-socket] ignoring stale CLI bridge chunk')
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
state.runId = chunk.run_id
|
||
|
|
|
||
|
|
for (const ev of chunk.events || []) {
|
||
|
|
const evType = ev.event as string | undefined
|
||
|
|
if (evType === 'tool.started') {
|
||
|
|
flushBridgePendingToDb(state, sessionId, runMarker)
|
||
|
|
const toolName = (ev.tool_name as string) || ''
|
||
|
|
const args = ev.args as Record<string, unknown> | undefined
|
||
|
|
const tool = recordBridgeToolStarted(state, sessionId, runMarker, toolName, args, ev.tool_call_id)
|
||
|
|
const payload = {
|
||
|
|
event: 'tool.started',
|
||
|
|
run_id: chunk.run_id,
|
||
|
|
tool_call_id: tool.id,
|
||
|
|
tool: toolName,
|
||
|
|
name: toolName,
|
||
|
|
arguments: tool.arguments,
|
||
|
|
preview: ev.preview || summarizeToolArguments(tool.arguments),
|
||
|
|
}
|
||
|
|
pushState(sessionMap, sessionId, 'tool.started', payload)
|
||
|
|
emit('tool.started', payload)
|
||
|
|
} else if (evType === 'tool.completed') {
|
||
|
|
const toolName = (ev.tool_name as string) || ''
|
||
|
|
const completed = recordBridgeToolCompleted(state, sessionId, runMarker, toolName, ev)
|
||
|
|
const payload = {
|
||
|
|
event: 'tool.completed',
|
||
|
|
run_id: chunk.run_id,
|
||
|
|
tool_call_id: completed.id,
|
||
|
|
tool: toolName,
|
||
|
|
name: toolName,
|
||
|
|
output: completed.output,
|
||
|
|
duration: completed.duration ?? ev.duration,
|
||
|
|
error: ev.is_error || undefined,
|
||
|
|
}
|
||
|
|
pushState(sessionMap, sessionId, 'tool.completed', payload)
|
||
|
|
emit('tool.completed', payload)
|
||
|
|
} else if (evType === 'turn.boundary') {
|
||
|
|
flushBridgePendingToDb(state, sessionId, runMarker)
|
||
|
|
} else if (evType === 'reasoning.delta' || evType === 'thinking.delta') {
|
||
|
|
const text = String(ev.text || '')
|
||
|
|
if (text) {
|
||
|
|
state.bridgePendingReasoningContent = (state.bridgePendingReasoningContent || '') + text
|
||
|
|
const message = ensureOpenBridgeAssistantMessage(state, sessionId, runMarker)
|
||
|
|
message.reasoning = (message.reasoning || '') + text
|
||
|
|
message.reasoning_content = (message.reasoning_content || '') + text
|
||
|
|
}
|
||
|
|
emit(evType, {
|
||
|
|
event: evType,
|
||
|
|
run_id: chunk.run_id,
|
||
|
|
text,
|
||
|
|
})
|
||
|
|
} else if (evType === 'reasoning.available') {
|
||
|
|
emit('reasoning.available', {
|
||
|
|
event: 'reasoning.available',
|
||
|
|
run_id: chunk.run_id,
|
||
|
|
})
|
||
|
|
} else if (evType === 'approval.requested') {
|
||
|
|
const payload = {
|
||
|
|
event: 'approval.requested',
|
||
|
|
run_id: chunk.run_id,
|
||
|
|
approval_id: ev.approval_id,
|
||
|
|
command: ev.command,
|
||
|
|
description: ev.description,
|
||
|
|
choices: ev.choices,
|
||
|
|
allow_permanent: ev.allow_permanent,
|
||
|
|
timeout_ms: ev.timeout_ms,
|
||
|
|
}
|
||
|
|
replaceState(sessionMap, sessionId, 'approval.requested', payload)
|
||
|
|
emit('approval.requested', payload)
|
||
|
|
} else if (evType === 'approval.resolved') {
|
||
|
|
const payload = {
|
||
|
|
event: 'approval.resolved',
|
||
|
|
run_id: chunk.run_id,
|
||
|
|
approval_id: ev.approval_id,
|
||
|
|
choice: ev.choice,
|
||
|
|
}
|
||
|
|
replaceState(sessionMap, sessionId, 'approval.resolved', payload)
|
||
|
|
emit('approval.resolved', payload)
|
||
|
|
} else if (evType === 'bridge.compression.requested') {
|
||
|
|
const bridgeHistory = await buildDbHistory(sessionId, { excludeLastUser: true })
|
||
|
|
const tokenCount = bridgeHistory.length > 0
|
||
|
|
? countTokens(JSON.stringify(bridgeHistory))
|
||
|
|
: ev.approx_tokens
|
||
|
|
const payload = {
|
||
|
|
event: 'compression.started',
|
||
|
|
run_id: chunk.run_id,
|
||
|
|
request_id: ev.request_id,
|
||
|
|
message_count: bridgeHistory.length || ev.message_count,
|
||
|
|
token_count: tokenCount,
|
||
|
|
source: 'bridge',
|
||
|
|
}
|
||
|
|
replaceState(sessionMap, sessionId, 'compression.started', payload)
|
||
|
|
emit('compression.started', payload)
|
||
|
|
if (ev.request_id && Array.isArray(ev.messages)) {
|
||
|
|
try {
|
||
|
|
const compressed = await forceCompressBridgeHistory(
|
||
|
|
sessionId,
|
||
|
|
profile,
|
||
|
|
ev.messages as ChatMessage[],
|
||
|
|
(p: string) => gatewayManager.getUpstream(p),
|
||
|
|
(p: string) => gatewayManager.getApiKey(p),
|
||
|
|
)
|
||
|
|
state.bridgeCompressionResults = state.bridgeCompressionResults || {}
|
||
|
|
state.bridgeCompressionResults[String(ev.request_id)] = compressed
|
||
|
|
await bridge.compressionRespond(String(ev.request_id), { messages: compressed.messages })
|
||
|
|
} catch (err: any) {
|
||
|
|
await bridge.compressionRespond(String(ev.request_id), {
|
||
|
|
error: err?.message || String(err),
|
||
|
|
}).catch(() => undefined)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else if (evType === 'bridge.compression.completed') {
|
||
|
|
const compressionResult = ev.request_id
|
||
|
|
? state.bridgeCompressionResults?.[String(ev.request_id)]
|
||
|
|
: undefined
|
||
|
|
const payload = {
|
||
|
|
event: 'compression.completed',
|
||
|
|
run_id: chunk.run_id,
|
||
|
|
request_id: ev.request_id,
|
||
|
|
compressed: compressionResult?.compressed ?? ev.compressed !== false,
|
||
|
|
llmCompressed: compressionResult?.llmCompressed,
|
||
|
|
totalMessages: compressionResult?.beforeMessages ?? ev.message_count,
|
||
|
|
resultMessages: compressionResult?.resultMessages ?? ev.result_messages,
|
||
|
|
beforeTokens: compressionResult?.beforeTokens ?? ev.approx_tokens,
|
||
|
|
afterTokens: compressionResult?.afterTokens,
|
||
|
|
summaryTokens: compressionResult?.summaryTokens,
|
||
|
|
verbatimCount: compressionResult?.verbatimCount,
|
||
|
|
compressedStartIndex: compressionResult?.compressedStartIndex,
|
||
|
|
source: 'bridge',
|
||
|
|
}
|
||
|
|
if (ev.request_id && state.bridgeCompressionResults) {
|
||
|
|
delete state.bridgeCompressionResults[String(ev.request_id)]
|
||
|
|
}
|
||
|
|
replaceState(sessionMap, sessionId, 'compression.completed', payload)
|
||
|
|
emit('compression.completed', payload)
|
||
|
|
await calcAndUpdateUsage(sessionId, state, emit)
|
||
|
|
} else if (evType === 'bridge.compression.failed') {
|
||
|
|
const payload = {
|
||
|
|
event: 'compression.completed',
|
||
|
|
run_id: chunk.run_id,
|
||
|
|
request_id: ev.request_id,
|
||
|
|
compressed: false,
|
||
|
|
totalMessages: ev.message_count,
|
||
|
|
resultMessages: ev.message_count,
|
||
|
|
beforeTokens: ev.approx_tokens,
|
||
|
|
error: ev.error,
|
||
|
|
source: 'bridge',
|
||
|
|
}
|
||
|
|
if (ev.request_id && state.bridgeCompressionResults) {
|
||
|
|
delete state.bridgeCompressionResults[String(ev.request_id)]
|
||
|
|
}
|
||
|
|
replaceState(sessionMap, sessionId, 'compression.completed', payload)
|
||
|
|
emit('compression.completed', payload)
|
||
|
|
} else if (evType === 'status') {
|
||
|
|
emit('agent.event', {
|
||
|
|
event: 'agent.event',
|
||
|
|
run_id: chunk.run_id,
|
||
|
|
...ev,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (chunk.delta) {
|
||
|
|
state.bridgeOutput = (state.bridgeOutput || '') + chunk.delta
|
||
|
|
state.bridgePendingAssistantContent = (state.bridgePendingAssistantContent || '') + chunk.delta
|
||
|
|
const last = [...state.messages].reverse().find(m => m.runMarker === runMarker)
|
||
|
|
if (last?.role === 'assistant' && last.finish_reason == null) {
|
||
|
|
last.content += chunk.delta
|
||
|
|
syncBridgeReasoningToMessage(last, state.bridgePendingReasoningContent)
|
||
|
|
} else {
|
||
|
|
state.messages.push({
|
||
|
|
id: state.messages.length + 1,
|
||
|
|
session_id: sessionId,
|
||
|
|
runMarker,
|
||
|
|
role: 'assistant',
|
||
|
|
content: chunk.delta,
|
||
|
|
reasoning: state.bridgePendingReasoningContent || null,
|
||
|
|
reasoning_content: state.bridgePendingReasoningContent || null,
|
||
|
|
timestamp: Math.floor(Date.now() / 1000),
|
||
|
|
})
|
||
|
|
}
|
||
|
|
emit('message.delta', {
|
||
|
|
event: 'message.delta',
|
||
|
|
run_id: chunk.run_id,
|
||
|
|
delta: chunk.delta,
|
||
|
|
output: state.bridgeOutput,
|
||
|
|
})
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!chunk.done) return
|
||
|
|
if (!state.isWorking) return
|
||
|
|
if (state.isAborting) {
|
||
|
|
bridgeLogger.info({
|
||
|
|
sessionId,
|
||
|
|
runId: chunk.run_id,
|
||
|
|
status: chunk.status,
|
||
|
|
}, '[chat-run-socket][abort] suppressing CLI bridge terminal chunk during abort')
|
||
|
|
return
|
||
|
|
}
|
||
|
|
|
||
|
|
flushBridgePendingToDb(state, sessionId)
|
||
|
|
updateSessionStats(sessionId)
|
||
|
|
await delay(BRIDGE_USAGE_FLUSH_DELAY_MS)
|
||
|
|
const usage = await calcAndUpdateUsage(sessionId, state, emit)
|
||
|
|
updateUsage(sessionId, {
|
||
|
|
inputTokens: usage.inputTokens,
|
||
|
|
outputTokens: usage.outputTokens,
|
||
|
|
profile: state.profile,
|
||
|
|
})
|
||
|
|
const nextQueuedRun = state.queue.length > 0 ? state.queue[0] : undefined
|
||
|
|
state.isWorking = Boolean(nextQueuedRun)
|
||
|
|
state.isAborting = false
|
||
|
|
if (nextQueuedRun) {
|
||
|
|
state.profile = nextQueuedRun.profile || profile
|
||
|
|
state.source = nextQueuedRun.source
|
||
|
|
} else {
|
||
|
|
state.profile = undefined
|
||
|
|
}
|
||
|
|
state.runId = undefined
|
||
|
|
state.activeRunMarker = undefined
|
||
|
|
state.events = []
|
||
|
|
const eventName = chunk.status === 'error' ? 'run.failed' : 'run.completed'
|
||
|
|
const payload = {
|
||
|
|
event: eventName,
|
||
|
|
run_id: chunk.run_id,
|
||
|
|
output: chunk.output || state.bridgeOutput || '',
|
||
|
|
result: chunk.result,
|
||
|
|
error: chunk.error,
|
||
|
|
inputTokens: usage.inputTokens,
|
||
|
|
outputTokens: usage.outputTokens,
|
||
|
|
queue_remaining: state.queue.length,
|
||
|
|
}
|
||
|
|
emit(eventName, payload)
|
||
|
|
if (state.queue.length > 0) {
|
||
|
|
dequeueNextQueuedRun(socket, sessionId)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function delay(ms: number): Promise<void> {
|
||
|
|
return new Promise(resolve => setTimeout(resolve, ms))
|
||
|
|
}
|