messageReducer.ts 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397
  1. import type {
  2. ApprovalRequest, ChatMessage, ChatRouteState, ClarificationRequest, JsonValue, RpcEventFrame, ToolCall,
  3. } from '@shared/types'
  4. import { createId } from './id'
  5. import { toolStatus } from '@shared/chatTools'
  6. import { bool, number, record, string } from './normalize'
  7. import { normalizeChatUsage } from './contextUsage'
  8. type MergePosition = 'append' | 'prepend' | 'snapshot'
  9. function messageTime(message: ChatMessage): number {
  10. return message.timestamp < 10_000_000_000 ? message.timestamp * 1000 : message.timestamp
  11. }
  12. /**
  13. * Keep the conversation in its canonical chronological order even when a
  14. * history snapshot races a realtime event. Sequence is preferred when both
  15. * rows carry one; otherwise timestamps retain the order supplied by Hermes.
  16. */
  17. export function orderChatMessages(messages: ChatMessage[]): ChatMessage[] {
  18. return messages
  19. .map((message, index) => ({ message, index }))
  20. .sort((left, right) => {
  21. const leftSequence = left.message.sequence
  22. const rightSequence = right.message.sequence
  23. if (leftSequence !== undefined && rightSequence !== undefined && leftSequence !== rightSequence) {
  24. return leftSequence - rightSequence
  25. }
  26. const timeDelta = messageTime(left.message) - messageTime(right.message)
  27. return timeDelta || left.index - right.index
  28. })
  29. .map(({ message }) => message)
  30. }
  31. function sameMessage(left: ChatMessage, right: ChatMessage): boolean {
  32. if (left.id && right.id && left.id === right.id) return true
  33. return Boolean(left.clientMessageId && right.clientMessageId && left.clientMessageId === right.clientMessageId)
  34. }
  35. function mergeOne(previous: ChatMessage, incoming: ChatMessage): ChatMessage {
  36. const persistedUser = (message: ChatMessage) => message.role === 'user' && message.stage === 'settled'
  37. && message.serverMessageId === message.id && message.id !== message.clientMessageId && !message.id.startsWith('user:')
  38. // A late receipt or a cached optimistic row must not demote persisted history.
  39. if (persistedUser(previous) && !persistedUser(incoming)) [previous, incoming] = [incoming, previous]
  40. const replacesContent = Boolean(incoming.content) || Boolean(incoming.attachments?.length)
  41. return {
  42. ...previous,
  43. ...incoming,
  44. id: incoming.serverMessageId || incoming.stage === 'settled' ? incoming.id : previous.id,
  45. clientMessageId: incoming.clientMessageId ?? previous.clientMessageId,
  46. serverMessageId: incoming.serverMessageId ?? previous.serverMessageId,
  47. content: replacesContent ? incoming.content : previous.content,
  48. reasoning: incoming.reasoning ?? previous.reasoning,
  49. attachments: incoming.attachments?.length ? incoming.attachments : previous.attachments,
  50. toolCalls: incoming.toolCalls?.length ? incoming.toolCalls : previous.toolCalls,
  51. }
  52. }
  53. /** Merge only by server/client identity. Repeated text is always retained. */
  54. export function mergeChatMessages(existing: ChatMessage[], incoming: ChatMessage[], position: MergePosition = 'append'): ChatMessage[] {
  55. const base = position === 'prepend' || position === 'snapshot' ? [...incoming, ...existing] : [...existing, ...incoming]
  56. const result: ChatMessage[] = []
  57. for (const message of base) {
  58. let merged = message
  59. let index: number
  60. let insertionIndex = result.length
  61. // An enriched history row can bridge both an old server row and its local
  62. // echo already in the cache. Consume every identity match, not just the first.
  63. while ((index = result.findIndex(candidate => sameMessage(candidate, merged))) >= 0) {
  64. insertionIndex = Math.min(insertionIndex, index)
  65. merged = mergeOne(result.splice(index, 1)[0]!, merged)
  66. }
  67. result.splice(insertionIndex, 0, merged)
  68. }
  69. return orderChatMessages(result)
  70. }
  71. function payloadRecord(event: RpcEventFrame['params']): Record<string, unknown> {
  72. return record(event.payload)
  73. }
  74. function eventSessionId(event: RpcEventFrame['params'], fallback: string): string {
  75. const payload = payloadRecord(event)
  76. return string(event.session_id ?? payload.session_id ?? payload.sessionId, fallback)
  77. }
  78. function eventMessageId(payload: Record<string, unknown>, fallback: string): string {
  79. return string(payload.message_id ?? payload.messageId ?? payload.id ?? payload.run_id ?? payload.runId, fallback)
  80. }
  81. function lastUserMessage(messages: ChatMessage[]): ChatMessage | undefined {
  82. return [...messages].reverse().find(message => message.role === 'user')
  83. }
  84. function lastStreamingAssistant(messages: ChatMessage[], afterLatestUser = false): ChatMessage | undefined {
  85. let latestUserIndex = -1
  86. if (afterLatestUser) {
  87. for (let index = messages.length - 1; index >= 0; index -= 1) {
  88. if (messages[index].role === 'user') {
  89. latestUserIndex = index
  90. break
  91. }
  92. }
  93. }
  94. return messages.slice(latestUserIndex + 1).reverse()
  95. .find(message => message.role === 'assistant' && message.isStreaming)
  96. }
  97. export function chatHasUnfinishedOutput(messages: ChatMessage[]): boolean {
  98. return messages.some(message => message.role === 'assistant'
  99. && message.toolCalls?.some(tool => ['pending', 'running'].includes(tool.status)))
  100. }
  101. export function settleChatMessages(messages: ChatMessage[], current?: ChatMessage, interruptUnfinishedTools = true): ChatMessage[] {
  102. return messages.map(message => message.role === 'assistant' && message !== current
  103. ? { ...message, stage: message.stage === 'streaming' ? 'settled' : message.stage, isStreaming: false,
  104. toolCalls: message.toolCalls?.map(tool => interruptUnfinishedTools && ['running', 'pending'].includes(tool.status)
  105. ? { ...tool, status: 'interrupted' }
  106. : tool) }
  107. : message)
  108. }
  109. function streamingSegmentId(state: ChatRouteState): string {
  110. const latestUser = lastUserMessage(state.messages)
  111. return `stream:${state.route.profile}:${state.route.sessionId}:${latestUser?.id ?? 'orphan'}:${createId('segment')}`
  112. }
  113. function sealInterimMessage(state: ChatRouteState, payload: Record<string, unknown>): ChatMessage[] {
  114. const content = string(payload.output ?? payload.text ?? payload.content)
  115. if (!content.trim()) return state.messages
  116. const current = lastStreamingAssistant(state.messages)
  117. const occurredAt = number(payload.timestamp ?? payload.created_at, Date.now() / 1000)
  118. const sealedId = current?.id ?? streamingSegmentId(state)
  119. const sealed: ChatMessage = {
  120. ...(current ?? {}),
  121. id: sealedId,
  122. clientMessageId: current?.clientMessageId ?? (sealedId.startsWith('stream:') ? sealedId : undefined),
  123. sessionId: state.route.sessionId,
  124. profile: state.route.profile,
  125. role: 'assistant',
  126. content,
  127. timestamp: current?.timestamp ?? occurredAt,
  128. stage: 'settled',
  129. isStreaming: false,
  130. raw: payload as JsonValue,
  131. }
  132. const nextId = streamingSegmentId(state)
  133. const next: ChatMessage = {
  134. id: nextId,
  135. clientMessageId: nextId,
  136. sessionId: state.route.sessionId,
  137. profile: state.route.profile,
  138. role: 'assistant',
  139. content: '',
  140. timestamp: occurredAt,
  141. stage: 'streaming',
  142. isStreaming: true,
  143. raw: { stream_interim_continuation: true },
  144. }
  145. return mergeChatMessages(mergeChatMessages(state.messages, [sealed]), [next])
  146. }
  147. function toolFromEvent(payload: Record<string, unknown>, status: ToolCall['status']): ToolCall {
  148. return {
  149. id: string(payload.tool_call_id ?? payload.toolCallId ?? payload.tool_id ?? payload.id, createId('tool')),
  150. name: string(payload.name ?? payload.tool_name, '工具'),
  151. status,
  152. arguments: (payload.arguments ?? payload.args ?? payload.context) as JsonValue | undefined,
  153. result: (payload.result ?? payload.output) as JsonValue | undefined,
  154. preview: string(payload.preview ?? payload.summary ?? payload.args_text) || undefined,
  155. error: string(payload.error) || undefined,
  156. durationSeconds: number(payload.duration_seconds ?? payload.duration_s) || undefined,
  157. }
  158. }
  159. function updateStreamingMessage(
  160. state: ChatRouteState,
  161. payload: Record<string, unknown>,
  162. mode: 'start' | 'delta' | 'reasoning' | 'complete' | 'failed',
  163. ): ChatMessage[] {
  164. // A start event belongs to the turn after the latest user row. An interrupted
  165. // turn may never receive a terminal event, so reusing any older streaming row
  166. // would make the new answer render above the new prompt.
  167. const current = lastStreamingAssistant(state.messages, mode === 'start')
  168. const fallbackId = current?.id ?? streamingSegmentId(state)
  169. const id = eventMessageId(payload, fallbackId)
  170. const existing = state.messages.find(message => message.id === id) ?? current
  171. const delta = string(payload.delta ?? payload.text_delta ?? payload.content_delta)
  172. const full = string(payload.output ?? payload.text ?? payload.content)
  173. const emptyInterimContinuation = mode === 'complete'
  174. && existing === current
  175. && bool(record(current?.raw).stream_interim_continuation)
  176. && !current?.content.trim()
  177. && !current?.reasoning?.trim()
  178. && !current?.toolCalls?.length
  179. if (emptyInterimContinuation && current) {
  180. const currentIndex = state.messages.indexOf(current)
  181. const previous = state.messages.slice(0, currentIndex).reverse()
  182. .find(message => message.role === 'assistant')
  183. const previousContent = previous?.content.trim() ?? ''
  184. const continuesPrevious = Boolean(full && previousContent
  185. && (full === previousContent || full.startsWith(previousContent) || previousContent.startsWith(full)))
  186. if (previous && (!full || bool(payload.response_previewed) || continuesPrevious)) {
  187. return orderChatMessages(state.messages
  188. .filter(message => message !== current)
  189. .map(message => message === previous && full
  190. ? { ...message, content: full, stage: 'settled', isStreaming: false, raw: payload as JsonValue }
  191. : message))
  192. }
  193. }
  194. let content = existing?.content ?? ''
  195. let reasoning = existing?.reasoning
  196. if (mode === 'delta') content += delta || full
  197. if (mode === 'complete') content = bool(payload.authoritative_output) && full ? full : full || content
  198. if (mode === 'reasoning') reasoning = `${reasoning ?? ''}${delta || full}`
  199. const message: ChatMessage = {
  200. id,
  201. // Keep a stable local identity while Hermes promotes a synthetic stream ID
  202. // to its authoritative message/run ID on a later event.
  203. clientMessageId: existing?.clientMessageId
  204. ?? (existing?.id.startsWith('stream:') ? existing.id : id.startsWith('stream:') ? id : undefined),
  205. serverMessageId: id.startsWith('stream:') ? undefined : id,
  206. sessionId: state.route.sessionId,
  207. profile: state.route.profile,
  208. role: 'assistant',
  209. content,
  210. reasoning,
  211. timestamp: number(payload.timestamp ?? payload.created_at, existing?.timestamp ?? Date.now() / 1000),
  212. stage: mode === 'complete' ? 'settled' : mode === 'failed' ? 'failed' : 'streaming',
  213. isStreaming: !['complete', 'failed'].includes(mode),
  214. error: mode === 'failed' ? string(payload.error ?? payload.message, '运行失败') : undefined,
  215. toolCalls: existing?.toolCalls,
  216. raw: payload as JsonValue,
  217. }
  218. const messages = mode === 'start' ? settleChatMessages(state.messages, current) : state.messages
  219. return mergeChatMessages(messages, [message])
  220. }
  221. export function applyChatEvent(state: ChatRouteState, event: RpcEventFrame['params']): ChatRouteState {
  222. if (event.type === 'gateway.ready') return state
  223. const payload = payloadRecord(event)
  224. if (eventSessionId(event, state.route.sessionId) !== state.route.sessionId) return state
  225. const next: ChatRouteState = { ...state, error: undefined }
  226. switch (event.type) {
  227. case 'run.peer_user_message':
  228. case 'peer.user.message': {
  229. const id=string(payload.message_id),clientMessageId=string(payload.client_message_id ?? payload.queue_id)
  230. const existing=state.messages.find(m=>m.id===id||m.clientMessageId===clientMessageId)
  231. const stage=payload.status==='failed'?'failed':payload.status==='accepted'?'accepted':existing?.stage??'pending'
  232. next.messages=mergeChatMessages(state.messages,[{...existing,id,clientMessageId,sessionId:state.route.sessionId,profile:state.route.profile,
  233. role:'user',content:string(payload.text ?? payload.content),timestamp:existing?.timestamp??number(payload.timestamp,Date.now()/1000),stage}])
  234. break
  235. }
  236. case 'message.start':
  237. case 'run.started':
  238. next.messages = updateStreamingMessage(state, payload, 'start')
  239. next.isStreaming = true
  240. next.isQueued = false
  241. break
  242. case 'message.delta':
  243. case 'content.delta':
  244. case 'assistant.delta':
  245. next.messages = updateStreamingMessage(state, payload, 'delta')
  246. next.isStreaming = true
  247. break
  248. case 'message.interim':
  249. // Hermes emits this after commentary that precedes a tool call. Seal the
  250. // visible text in place and start a fresh segment, otherwise later deltas
  251. // keep rewriting the older bubble until message.complete replaces it.
  252. next.messages = sealInterimMessage(state, payload)
  253. next.isStreaming = true
  254. break
  255. case 'reasoning.delta':
  256. next.messages = updateStreamingMessage(state, payload, 'reasoning')
  257. next.isStreaming = true
  258. break
  259. case 'thinking.delta':
  260. case 'status.update':
  261. next.liveStatus = string(payload.text ?? payload.message ?? payload.status) || undefined
  262. break
  263. case 'message.complete':
  264. case 'run.completed': {
  265. const terminalStatus = string(payload.status).trim().toLowerCase()
  266. const failed = terminalStatus === 'error' || terminalStatus === 'failed' || Boolean(payload.error)
  267. next.messages = updateStreamingMessage(state, payload, failed ? 'failed' : 'complete')
  268. const waitingForOutput = !failed && chatHasUnfinishedOutput(next.messages)
  269. next.messages = settleChatMessages(next.messages, undefined, !waitingForOutput)
  270. next.isStreaming = waitingForOutput
  271. next.isQueued = false
  272. next.liveStatus = undefined
  273. const usage = normalizeChatUsage(payload)
  274. if (usage) next.usage = { ...next.usage, ...usage }
  275. if (failed) next.error = string(payload.error ?? payload.text ?? payload.message, '运行失败')
  276. break
  277. }
  278. case 'error':
  279. case 'run.failed':
  280. next.messages = updateStreamingMessage(state, payload, 'failed')
  281. next.messages = settleChatMessages(next.messages)
  282. next.isStreaming = false
  283. next.isQueued = false
  284. next.error = string(payload.error ?? payload.message, '运行失败')
  285. break
  286. case 'run.queued':
  287. next.isQueued = true
  288. break
  289. case 'run.steered':
  290. case 'submission.acknowledged':
  291. next.isQueued = false
  292. break
  293. case 'session.usage':
  294. case 'usage.update':
  295. case 'context.update': {
  296. const usage = normalizeChatUsage(payload)
  297. if (usage) next.usage = { ...next.usage, ...usage }
  298. break
  299. }
  300. case 'tool.start':
  301. case 'tool.progress':
  302. case 'tool.started':
  303. case 'tool.generating': {
  304. const id = string(payload.tool_call_id ?? payload.toolCallId ?? payload.tool_id ?? payload.id)
  305. if (!id) {
  306. next.liveStatus = `正在准备 ${string(payload.name ?? payload.tool_name, '工具')}`
  307. break
  308. }
  309. const current = lastStreamingAssistant(next.messages)
  310. ?? [...next.messages].reverse().find(message => message.role === 'assistant'
  311. && (message.toolCalls?.some(tool => tool.id === id)
  312. || message.toolCalls?.some(tool => ['pending', 'running'].includes(tool.status))))
  313. ?? [...next.messages].reverse().find(message => message.role === 'assistant')
  314. if (!current) break
  315. const tool = toolFromEvent(payload, 'running')
  316. const tools = [...(current.toolCalls ?? [])]
  317. const index = tools.findIndex(item => item.id === tool.id)
  318. if (index >= 0) tools[index] = { ...tools[index], ...tool,
  319. result: tool.result ?? tools[index].result,
  320. status: ['completed', 'failed'].includes(tools[index].status) ? tools[index].status : tool.status }
  321. else tools.push(tool)
  322. next.messages = mergeChatMessages(next.messages, [{ ...current, toolCalls: tools }])
  323. next.isStreaming = true
  324. next.liveStatus = undefined
  325. break
  326. }
  327. case 'tool.complete':
  328. case 'tool.completed':
  329. case 'tool.failed': {
  330. const id = string(payload.tool_call_id ?? payload.toolCallId ?? payload.tool_id ?? payload.id)
  331. if (!id) break
  332. const current = [...next.messages].reverse().find(message => message.role === 'assistant' && message.toolCalls?.some(tool => tool.id === id))
  333. ?? lastStreamingAssistant(next.messages)
  334. if (!current) break
  335. const tool = toolFromEvent(payload, toolStatus(event.type, payload.result ?? payload.output, payload.error))
  336. const tools = [...(current.toolCalls ?? [])]
  337. const index = tools.findIndex(item => item.id === tool.id)
  338. if (index >= 0) tools[index] = { ...tools[index], ...tool }
  339. else tools.push(tool)
  340. next.messages = mergeChatMessages(next.messages, [{ ...current, toolCalls: tools }])
  341. if (!chatHasUnfinishedOutput(next.messages) && !next.messages.some(message => message.isStreaming)) {
  342. next.isStreaming = false
  343. next.isQueued = false
  344. next.liveStatus = undefined
  345. }
  346. break
  347. }
  348. case 'approval.request':
  349. case 'approval.requested': {
  350. const id = string(payload.request_id ?? payload.requestId ?? payload.id)
  351. if (id) next.pendingApproval = {
  352. id, sessionId: state.route.sessionId, message: string(payload.message ?? payload.prompt) || undefined,
  353. toolName: string(payload.tool_name ?? payload.tool) || undefined,
  354. choices: Array.isArray(payload.choices) ? payload.choices.map(String) : undefined,
  355. payload: payload as Record<string, JsonValue>,
  356. } satisfies ApprovalRequest
  357. break
  358. }
  359. case 'approval.resolved':
  360. next.pendingApproval = undefined
  361. break
  362. case 'clarify.request':
  363. case 'clarify.requested': {
  364. const id = string(payload.request_id ?? payload.requestId ?? payload.id)
  365. if (id) next.pendingClarification = {
  366. id, sessionId: state.route.sessionId, question: string(payload.question ?? payload.message ?? payload.prompt, '需要补充信息'),
  367. choices: Array.isArray(payload.choices) ? payload.choices.map(String) : undefined,
  368. payload: payload as Record<string, JsonValue>,
  369. } satisfies ClarificationRequest
  370. break
  371. }
  372. case 'clarify.expire':
  373. case 'clarify.resolved':
  374. next.pendingClarification = undefined
  375. break
  376. }
  377. return next
  378. }