chat.ts 44 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963
  1. import { computed, reactive, ref, watch } from 'vue'
  2. import { defineStore } from 'pinia'
  3. import type {
  4. ChatAttachment, ChatMessage, ChatRouteState, JsonValue, ModelOption, RealtimeConnectionState, SessionSummary,
  5. } from '@shared/types'
  6. import {
  7. deleteSession as deleteSessionApi, getMessages, getSession, getSessions, getSessionUnread, markSessionRead, updateSession,
  8. } from '@/api/sessions'
  9. import { getModels } from '@/api/profiles'
  10. import { ChatRpcSocket, RpcError } from '@/api/realtime'
  11. import { ApiError } from '@/api/client'
  12. import { encodeAttachment } from '@/utils/attachments'
  13. import { ScopedCache } from '@/utils/cache'
  14. import { createId, routeKey } from '@/utils/id'
  15. import { applyChatEvent, mergeChatMessages } from '@/utils/messageReducer'
  16. import { bool, normalizeChatMessage, number, record, string, values } from '@/utils/normalize'
  17. import { appendSessionPage, pinnedSessionsFirst } from '@/utils/sessionOrder'
  18. import { modelForSession, modelSelectionFromSessionInfo } from '@/utils/sessionModel'
  19. import { moveSessionFastMode, readSessionFastMode, writeSessionFastMode } from '@/utils/sessionPreferences'
  20. import { useAuthStore } from './auth'
  21. interface CachedHistory { messages: ChatMessage[]; total: number; savedAt: number }
  22. const historyCache = new ScopedCache<CachedHistory>('chat-history-v1')
  23. const INFLIGHT_SESSION_STORAGE_PREFIX = 'hermes-yaoyao:inflight-chat-sessions:'
  24. interface InflightSessionMarker {
  25. profile: string
  26. sessionId: string
  27. }
  28. function sessionStorageForInFlightSessions(): Storage | undefined {
  29. if (typeof window === 'undefined') return undefined
  30. try { return window.sessionStorage } catch { return undefined }
  31. }
  32. function readInflightSessionMarkers(accountId: string): InflightSessionMarker[] {
  33. const storage = sessionStorageForInFlightSessions()
  34. if (!storage) return []
  35. try {
  36. const value: unknown = JSON.parse(storage.getItem(`${INFLIGHT_SESSION_STORAGE_PREFIX}${accountId}`) ?? '[]')
  37. if (!Array.isArray(value)) return []
  38. return value.flatMap(item => {
  39. const marker = record(item)
  40. const profile = string(marker.profile)
  41. const sessionId = string(marker.sessionId)
  42. return profile && sessionId ? [{ profile, sessionId }] : []
  43. })
  44. } catch { return [] }
  45. }
  46. function writeInflightSessionMarkers(accountId: string, markers: InflightSessionMarker[]): void {
  47. const storage = sessionStorageForInFlightSessions()
  48. if (!storage) return
  49. try {
  50. const key = `${INFLIGHT_SESSION_STORAGE_PREFIX}${accountId}`
  51. if (markers.length) storage.setItem(key, JSON.stringify(markers))
  52. else storage.removeItem(key)
  53. } catch { /* Storage can be unavailable in privacy-restricted browsers. */ }
  54. }
  55. function emptyRoute(profile: string, sessionId: string): ChatRouteState {
  56. return {
  57. route: { profile, sessionId }, messages: [], historySynced: false, hasMoreBefore: false,
  58. loadedMessageCount: 0, messageTotal: 0, isLoadingHistory: false, isStreaming: false,
  59. isQueued: false, generation: 0,
  60. }
  61. }
  62. function errorMessage(cause: unknown): string {
  63. return cause instanceof Error ? cause.message : '聊天请求失败'
  64. }
  65. function resultRecord(value: JsonValue): Record<string, unknown> { return record(value) }
  66. function optionalBoolean(value: unknown): boolean | undefined {
  67. if (typeof value === 'boolean') return value
  68. if (value === 'true' || value === 'fast') return true
  69. if (value === 'false' || value === 'normal') return false
  70. return undefined
  71. }
  72. export const useChatStore = defineStore('chat', () => {
  73. const auth = useAuthStore()
  74. const sessions = ref<SessionSummary[]>([])
  75. const activeSessionId = ref<string>()
  76. const activeProfileName = ref<string>()
  77. const routes = reactive<Record<string, ChatRouteState>>({})
  78. const connectionState = ref<RealtimeConnectionState>('idle')
  79. const historySynced = computed(() => activeRouteState.value?.historySynced ?? false)
  80. const isLoading = ref(false)
  81. const isLoadingMoreSessions = ref(false)
  82. const hasMoreSessions = ref(false)
  83. const isSending = ref(false)
  84. const error = ref<string>()
  85. const models = ref<ModelOption[]>([])
  86. const unreadCounts = ref<Record<string, number>>({})
  87. const selectedModel = ref<ModelOption>()
  88. const reasoningEffort = ref<string>()
  89. const socket = new ChatRpcSocket()
  90. const runtimeRoutes = new Map<string, string>()
  91. const desiredModelRoutes = new Set<string>()
  92. const pendingModelConfirmations = new Map<string, { routeKey: string; model: ModelOption }>()
  93. let connectPromise: Promise<void> | undefined
  94. let reconnectTimer: number | undefined
  95. let reconnectAttempt = 0
  96. let sessionLoadGeneration = 0
  97. let nextSessionCursor: string | undefined
  98. let modelLoadGeneration = 0
  99. let unreadLoadGeneration = 0
  100. let reconnectResumePromise: Promise<unknown> | undefined
  101. let persistedRecoveryPromise: Promise<void> | undefined
  102. let hasConnectedOnce = false
  103. const runtimePromises = new Map<string, Promise<ChatRouteState>>()
  104. const activeRouteState = computed(() => {
  105. if (!activeSessionId.value || !activeProfileName.value) return undefined
  106. return routes[routeKey(activeProfileName.value, activeSessionId.value)]
  107. })
  108. const fastMode = computed(() => activeRouteState.value?.fastMode ?? false)
  109. const activeSession = computed(() => sessions.value.find(session => session.id === activeSessionId.value
  110. && (!activeProfileName.value || session.profile === activeProfileName.value)))
  111. const messages = computed(() => activeRouteState.value?.messages ?? [])
  112. const hasMoreBefore = computed(() => activeRouteState.value?.hasMoreBefore ?? false)
  113. const isStreaming = computed(() => activeRouteState.value?.isStreaming ?? false)
  114. const isQueued = computed(() => activeRouteState.value?.isQueued ?? false)
  115. const contextUsage = computed(() => activeRouteState.value?.usage)
  116. const pendingApproval = computed(() => activeRouteState.value?.pendingApproval)
  117. const pendingClarification = computed(() => activeRouteState.value?.pendingClarification)
  118. function ensureRoute(profile: string, sessionId: string): ChatRouteState {
  119. const key = routeKey(profile, sessionId)
  120. if (!routes[key]) {
  121. routes[key] = emptyRoute(profile, sessionId)
  122. routes[key].fastMode = readSessionFastMode(auth.user?.id ?? 'local', profile, sessionId)
  123. }
  124. return routes[key]
  125. }
  126. function persistFastMode(state: ChatRouteState): void {
  127. writeSessionFastMode(auth.user?.id ?? 'local', state.route.profile, state.route.sessionId, state.fastMode ?? false)
  128. }
  129. function syncSelectedModel(model?: string, provider?: string): void {
  130. const resolved = modelForSession(models.value, model, provider)
  131. if (resolved) selectedModel.value = resolved
  132. }
  133. function restoreSelectedSessionModel(key: string): void {
  134. const activeKey = activeSessionId.value && activeProfileName.value
  135. ? routeKey(activeProfileName.value, activeSessionId.value)
  136. : undefined
  137. if (key === activeKey) syncSelectedModel(activeSession.value?.model, activeSession.value?.provider)
  138. }
  139. function reconcileSessionModel(profile: string, sessionId: string, model: string, provider?: string): void {
  140. const key = routeKey(profile, sessionId)
  141. const sessionIndex = sessions.value.findIndex(session => session.id === sessionId && session.profile === profile)
  142. if (sessionIndex >= 0) {
  143. sessions.value.splice(sessionIndex, 1, {
  144. ...sessions.value[sessionIndex], model, provider,
  145. })
  146. }
  147. const activeKey = activeSessionId.value && activeProfileName.value
  148. ? routeKey(activeProfileName.value, activeSessionId.value)
  149. : undefined
  150. if (key === activeKey && !desiredModelRoutes.has(key)) syncSelectedModel(model, provider)
  151. }
  152. function cacheScope(profile: string): string {
  153. return `${auth.user?.id ?? 'anonymous'}:${profile}`
  154. }
  155. function scheduleReconnect(): void {
  156. if (!auth.isAuthenticated || reconnectTimer !== undefined) return
  157. const delay = Math.min(15_000, 500 * 2 ** Math.min(reconnectAttempt, 5))
  158. reconnectAttempt += 1
  159. connectionState.value = 'reconnecting'
  160. reconnectTimer = window.setTimeout(() => {
  161. reconnectTimer = undefined
  162. void connect().catch(() => scheduleReconnect())
  163. }, delay)
  164. }
  165. function accountId(): string { return auth.user?.id ?? 'anonymous' }
  166. function updateInflightMarker(state: ChatRouteState): void {
  167. const markers = readInflightSessionMarkers(accountId())
  168. const matches = (marker: InflightSessionMarker) => marker.profile === state.route.profile
  169. && marker.sessionId === state.route.sessionId
  170. const shouldKeep = state.isStreaming || state.isQueued || Boolean(state.pendingApproval) || Boolean(state.pendingClarification)
  171. const next = shouldKeep
  172. ? [...markers.filter(marker => !matches(marker)), { profile: state.route.profile, sessionId: state.route.sessionId }]
  173. : markers.filter(marker => !matches(marker))
  174. writeInflightSessionMarkers(accountId(), next)
  175. }
  176. function clearInflightMarker(profile: string, sessionId: string): void {
  177. const markers = readInflightSessionMarkers(accountId())
  178. writeInflightSessionMarkers(accountId(), markers.filter(marker => marker.profile !== profile || marker.sessionId !== sessionId))
  179. }
  180. function recoverPersistedInflightSessions(): Promise<void> | undefined {
  181. if (!auth.isAuthenticated || persistedRecoveryPromise) return persistedRecoveryPromise
  182. const markers = readInflightSessionMarkers(accountId())
  183. if (!markers.length) return undefined
  184. const operation = Promise.all(markers.map(async marker => {
  185. const state = ensureRoute(marker.profile, marker.sessionId)
  186. try {
  187. const resumed = await ensureRuntime(state)
  188. updateInflightMarker(resumed)
  189. } catch {
  190. // Keep the marker. A transient reconnect failure must not turn into an
  191. // accidental interruption before Hermes's disconnect grace expires.
  192. }
  193. })).then(() => undefined)
  194. persistedRecoveryPromise = operation.finally(() => { persistedRecoveryPromise = undefined })
  195. return persistedRecoveryPromise
  196. }
  197. socket.onState((state, reason) => {
  198. connectionState.value = state
  199. if (state === 'ready') {
  200. reconnectAttempt = 0
  201. const shouldResume = hasConnectedOnce
  202. hasConnectedOnce = true
  203. const active = activeRouteState.value
  204. if (shouldResume && active?.isStreaming && !active.runtimeSessionId && !reconnectResumePromise) {
  205. reconnectResumePromise = ensureRuntime(active)
  206. .catch(cause => { active.error = errorMessage(cause) })
  207. .finally(() => { reconnectResumePromise = undefined })
  208. }
  209. void recoverPersistedInflightSessions()
  210. }
  211. if (state === 'failed') {
  212. runtimeRoutes.clear()
  213. for (const route of Object.values(routes)) {
  214. route.runtimeSessionId = undefined
  215. route.serverFastMode = undefined
  216. }
  217. error.value = reason || '聊天实时连接已断开'
  218. scheduleReconnect()
  219. }
  220. })
  221. function migrateRoute(oldKey: string, storedSessionId: string, runtimeSessionId: string): ChatRouteState {
  222. const oldState = routes[oldKey]
  223. if (!oldState) throw new Error('会话状态已经失效')
  224. const newKey = routeKey(oldState.route.profile, storedSessionId)
  225. const target = routes[newKey]
  226. const migrated: ChatRouteState = {
  227. ...(target ?? oldState),
  228. route: { profile: oldState.route.profile, sessionId: storedSessionId },
  229. messages: target ? mergeChatMessages(target.messages, oldState.messages) : oldState.messages,
  230. runtimeSessionId,
  231. }
  232. routes[newKey] = migrated
  233. if (newKey !== oldKey) delete routes[oldKey]
  234. if (desiredModelRoutes.delete(oldKey)) desiredModelRoutes.add(newKey)
  235. runtimeRoutes.set(runtimeSessionId, newKey)
  236. if (activeSessionId.value === oldState.route.sessionId && activeProfileName.value === oldState.route.profile) {
  237. activeSessionId.value = storedSessionId
  238. }
  239. if (newKey !== oldKey) {
  240. moveSessionFastMode(auth.user?.id ?? 'local', oldState.route.profile, oldState.route.sessionId, storedSessionId, migrated.fastMode ?? false)
  241. }
  242. const draftIndex = sessions.value.findIndex(session => session.id === oldState.route.sessionId && session.profile === oldState.route.profile)
  243. const now = Date.now() / 1000
  244. const summary: SessionSummary = draftIndex >= 0
  245. ? { ...sessions.value[draftIndex], id: storedSessionId, updatedAt: now }
  246. : { id: storedSessionId, profile: oldState.route.profile, source: 'web', title: '新会话', messageCount: 0, toolCallCount: 0, startedAt: now, updatedAt: now }
  247. if (draftIndex >= 0) sessions.value.splice(draftIndex, 1, summary)
  248. else sessions.value.unshift(summary)
  249. return routes[newKey]
  250. }
  251. socket.onEvent(event => {
  252. if (event.type === 'gateway.ready') return
  253. const payload = record(event.payload)
  254. const runtimeId = string(event.session_id ?? payload.session_id ?? payload.sessionId)
  255. let key = runtimeRoutes.get(runtimeId)
  256. if (!key) key = Object.keys(routes).find(candidate => routes[candidate].runtimeSessionId === runtimeId
  257. || routes[candidate].route.sessionId === runtimeId)
  258. if (!key) return
  259. let state = routes[key]
  260. if (event.type === 'session.info') {
  261. const storedId = string(payload.stored_session_id ?? payload.storedSessionId ?? payload.session_key)
  262. if (storedId && storedId !== state.route.sessionId) {
  263. state = migrateRoute(key, storedId, runtimeId)
  264. key = routeKey(state.route.profile, storedId)
  265. }
  266. const liveSelection = modelSelectionFromSessionInfo(payload)
  267. if (liveSelection) {
  268. reconcileSessionModel(state.route.profile, state.route.sessionId, liveSelection.model, liveSelection.provider)
  269. }
  270. }
  271. const info = record(payload.info)
  272. const liveFastMode = optionalBoolean(payload.fast ?? info.fast)
  273. if (liveFastMode !== undefined && (event.type === 'session.info' || (event.type === 'session.command' && payload.action === 'fast'))) {
  274. state.serverFastMode = liveFastMode
  275. if (!state.fastModeDirty) state.fastMode = liveFastMode
  276. persistFastMode(state)
  277. }
  278. const attributedPayload = { ...payload, session_id: state.route.sessionId } as JsonValue
  279. const updated = applyChatEvent(state, {
  280. ...event, session_id: state.route.sessionId, profile: state.route.profile, payload: attributedPayload,
  281. })
  282. routes[key] = updated
  283. updateInflightMarker(updated)
  284. if (['message.complete', 'run.completed'].includes(event.type)) {
  285. void refreshContextUsage(updated).catch(() => undefined)
  286. }
  287. })
  288. async function connect(): Promise<void> {
  289. if (['connected', 'ready'].includes(connectionState.value)) return
  290. if (connectPromise) return connectPromise
  291. if (reconnectTimer !== undefined) {
  292. window.clearTimeout(reconnectTimer)
  293. reconnectTimer = undefined
  294. }
  295. connectPromise = socket.connect().catch(cause => {
  296. connectionState.value = 'failed'
  297. error.value = errorMessage(cause)
  298. throw cause
  299. }).finally(() => { connectPromise = undefined })
  300. return connectPromise
  301. }
  302. function disconnect(): void {
  303. if (reconnectTimer !== undefined) window.clearTimeout(reconnectTimer)
  304. reconnectTimer = undefined
  305. hasConnectedOnce = false
  306. socket.close()
  307. runtimeRoutes.clear()
  308. runtimePromises.clear()
  309. desiredModelRoutes.clear()
  310. pendingModelConfirmations.clear()
  311. for (const state of Object.values(routes)) {
  312. state.runtimeSessionId = undefined
  313. state.serverFastMode = undefined
  314. }
  315. }
  316. function switchProfile(profile: string): void {
  317. sessionLoadGeneration += 1
  318. modelLoadGeneration += 1
  319. unreadLoadGeneration += 1
  320. disconnect()
  321. activeSessionId.value = undefined
  322. activeProfileName.value = profile
  323. nextSessionCursor = undefined
  324. hasMoreSessions.value = false
  325. isLoadingMoreSessions.value = false
  326. error.value = undefined
  327. }
  328. function clearAccountState(): void {
  329. sessions.value = []
  330. nextSessionCursor = undefined
  331. hasMoreSessions.value = false
  332. isLoadingMoreSessions.value = false
  333. activeSessionId.value = undefined
  334. activeProfileName.value = undefined
  335. runtimeRoutes.clear()
  336. for (const key of Object.keys(routes)) delete routes[key]
  337. unreadCounts.value = {}
  338. error.value = undefined
  339. }
  340. watch(() => auth.status, status => {
  341. if (status !== 'authenticated') {
  342. disconnect()
  343. clearAccountState()
  344. }
  345. })
  346. async function loadSessions(profile?: string): Promise<void> {
  347. const requestedProfile = profile || undefined
  348. const loadGeneration = ++sessionLoadGeneration
  349. isLoading.value = true
  350. error.value = undefined
  351. try {
  352. const page = await getSessions(requestedProfile, undefined, 100)
  353. if (loadGeneration !== sessionLoadGeneration
  354. || (requestedProfile && auth.activeProfile?.name !== requestedProfile)) return
  355. // 9119 owns recency within each bucket. Pinning is an explicit user
  356. // command, so pinned sessions always form the visible top partition.
  357. sessions.value = pinnedSessionsFirst(page.items)
  358. nextSessionCursor = page.nextCursor ?? undefined
  359. hasMoreSessions.value = Boolean(nextSessionCursor)
  360. } catch (cause) {
  361. if (loadGeneration === sessionLoadGeneration) error.value = errorMessage(cause)
  362. throw cause
  363. } finally {
  364. if (loadGeneration === sessionLoadGeneration) isLoading.value = false
  365. }
  366. }
  367. async function loadMoreSessions(profile = auth.activeProfile?.name): Promise<void> {
  368. const cursor = nextSessionCursor
  369. const requestedProfile = profile || undefined
  370. if (!cursor || isLoadingMoreSessions.value) return
  371. const loadGeneration = sessionLoadGeneration
  372. isLoadingMoreSessions.value = true
  373. try {
  374. const page = await getSessions(requestedProfile, cursor, 100)
  375. if (loadGeneration !== sessionLoadGeneration
  376. || (requestedProfile && auth.activeProfile?.name !== requestedProfile)) return
  377. sessions.value = appendSessionPage(sessions.value, page.items)
  378. nextSessionCursor = page.nextCursor ?? undefined
  379. hasMoreSessions.value = Boolean(nextSessionCursor)
  380. } catch (cause) {
  381. if (loadGeneration === sessionLoadGeneration) error.value = errorMessage(cause)
  382. throw cause
  383. } finally {
  384. if (loadGeneration === sessionLoadGeneration) isLoadingMoreSessions.value = false
  385. }
  386. }
  387. async function loadUnread(profile?: string): Promise<void> {
  388. const loadGeneration = ++unreadLoadGeneration
  389. const loaded = await getSessionUnread(profile)
  390. if (loadGeneration === unreadLoadGeneration && (!profile || auth.activeProfile?.name === profile)) {
  391. unreadCounts.value = loaded
  392. }
  393. }
  394. async function markRead(sessionId = activeSessionId.value, profile = activeProfileName.value): Promise<void> {
  395. if (!sessionId) return
  396. const state = profile ? routes[routeKey(profile, sessionId)] : undefined
  397. const summaryCount = sessions.value.find(session => session.id === sessionId)?.messageCount ?? 0
  398. const count = Math.max(state?.messageTotal ?? 0, summaryCount)
  399. await markSessionRead(sessionId, count, profile)
  400. unreadCounts.value = { ...unreadCounts.value, [sessionId]: 0 }
  401. }
  402. async function loadHistory(state: ChatRouteState): Promise<void> {
  403. const generation = ++state.generation
  404. state.isLoadingHistory = true
  405. state.error = undefined
  406. const scope = cacheScope(state.route.profile)
  407. const cached = await historyCache.get(scope, state.route.sessionId)
  408. if (generation !== state.generation) return
  409. if (cached?.messages.length) {
  410. state.messages = mergeChatMessages(state.messages, cached.messages, 'snapshot')
  411. state.messageTotal = cached.total
  412. state.loadedMessageCount = cached.messages.length
  413. }
  414. try {
  415. const page = await getMessages(state.route.sessionId, 0, 150, state.route.profile)
  416. if (generation !== state.generation) return
  417. state.messages = mergeChatMessages(state.messages, page.messages, 'snapshot')
  418. state.messageTotal = page.total
  419. state.loadedMessageCount = page.returned
  420. state.hasMoreBefore = page.hasMore
  421. state.historySynced = true
  422. if (page.session) {
  423. const index = sessions.value.findIndex(session => session.id === page.session!.id && session.profile === page.session!.profile)
  424. if (index >= 0) sessions.value.splice(index, 1, page.session)
  425. }
  426. await historyCache.set(scope, state.route.sessionId, { messages: state.messages, total: page.total, savedAt: Date.now() })
  427. } catch (cause) {
  428. if (generation === state.generation) state.error = errorMessage(cause)
  429. throw cause
  430. } finally {
  431. if (generation === state.generation) state.isLoadingHistory = false
  432. }
  433. }
  434. async function selectSession(sessionId: string, profile?: string): Promise<void> {
  435. const session = sessions.value.find(item => item.id === sessionId && (!profile || item.profile === profile))
  436. const selectedProfile = profile ?? session?.profile ?? auth.activeProfile?.name ?? 'default'
  437. activeSessionId.value = sessionId
  438. activeProfileName.value = selectedProfile
  439. const state = ensureRoute(selectedProfile, sessionId)
  440. syncSelectedModel(session?.model, session?.provider)
  441. // Reading an old session must not rewrite the server's last_active field.
  442. // The runtime is attached lazily by send/interrupt/usage, or when a known
  443. // in-flight turn reconnects. REST history remains authoritative here.
  444. if (!state.historySynced) await loadHistory(state)
  445. // Context usage comes from the realtime runtime rather than the REST
  446. // history response. Fetch it when opening an existing session so the
  447. // composer does not stay at zero until a later event happens to include it.
  448. void refreshContextUsage(state).catch(() => undefined)
  449. const refreshed = sessions.value.find(item => item.id === sessionId && item.profile === selectedProfile)
  450. syncSelectedModel(refreshed?.model, refreshed?.provider)
  451. }
  452. async function loadOlder(): Promise<void> {
  453. const state = activeRouteState.value
  454. if (!state || state.isLoadingHistory || !state.hasMoreBefore) return
  455. const generation = state.generation
  456. state.isLoadingHistory = true
  457. try {
  458. const page = await getMessages(state.route.sessionId, state.loadedMessageCount, 150, state.route.profile)
  459. if (generation !== state.generation) return
  460. state.messages = mergeChatMessages(state.messages, page.messages, 'prepend')
  461. state.loadedMessageCount += page.returned
  462. state.messageTotal = Math.max(state.messageTotal, page.total)
  463. state.hasMoreBefore = page.hasMore
  464. await historyCache.set(cacheScope(state.route.profile), state.route.sessionId, {
  465. messages: state.messages, total: state.messageTotal, savedAt: Date.now(),
  466. })
  467. } catch (cause) { state.error = errorMessage(cause) }
  468. finally { if (generation === state.generation) state.isLoadingHistory = false }
  469. }
  470. function createSession(profile = auth.activeProfile?.name ?? 'default'): string {
  471. const id = `draft-${createId('session')}`
  472. const now = Date.now() / 1000
  473. sessions.value.unshift({ id, profile, source: 'web', title: '新会话', messageCount: 0, toolCallCount: 0, startedAt: now, updatedAt: now })
  474. ensureRoute(profile, id)
  475. activeSessionId.value = id
  476. activeProfileName.value = profile
  477. return id
  478. }
  479. async function performEnsureRuntime(initialState: ChatRouteState): Promise<ChatRouteState> {
  480. if (initialState.runtimeSessionId) return initialState
  481. await connect()
  482. const initialKey = routeKey(initialState.route.profile, initialState.route.sessionId)
  483. if (initialState.route.sessionId.startsWith('draft-')) {
  484. const params: Record<string, JsonValue> = {
  485. profile: initialState.route.profile, source: 'web', close_on_disconnect: false,
  486. }
  487. if (reasoningEffort.value) params.reasoning_effort = reasoningEffort.value
  488. params.fast = initialState.fastMode ?? false
  489. const result = resultRecord(await socket.request('session.create', params))
  490. const runtimeId = string(result.session_id ?? result.sessionId)
  491. const storedId = string(result.stored_session_id ?? result.storedSessionId ?? result.session_key)
  492. if (!runtimeId || !storedId) throw new Error('Hermes 未返回新会话标识')
  493. const migrated = migrateRoute(initialKey, storedId, runtimeId)
  494. const info = record(result.info)
  495. if (!desiredModelRoutes.has(routeKey(migrated.route.profile, migrated.route.sessionId))) {
  496. syncSelectedModel(string(result.model ?? info.model), string(result.provider ?? info.provider))
  497. }
  498. const liveFastMode = optionalBoolean(result.fast ?? info.fast)
  499. migrated.serverFastMode = liveFastMode ?? migrated.fastMode ?? false
  500. if (!migrated.fastModeDirty && liveFastMode !== undefined) migrated.fastMode = liveFastMode
  501. migrated.fastModeDirty = false
  502. persistFastMode(migrated)
  503. return migrated
  504. }
  505. const result = resultRecord(await socket.request('session.resume', {
  506. session_id: initialState.route.sessionId,
  507. profile: initialState.route.profile,
  508. source: 'web',
  509. omit_messages: true,
  510. }))
  511. const runtimeId = string(result.session_id ?? result.sessionId)
  512. if (!runtimeId) throw new Error('Hermes 未返回运行会话标识')
  513. const storedId = string(result.stored_session_id ?? result.storedSessionId ?? result.session_key, initialState.route.sessionId)
  514. const migrated = migrateRoute(initialKey, storedId, runtimeId)
  515. const info = record(result.info)
  516. if (!desiredModelRoutes.has(routeKey(migrated.route.profile, migrated.route.sessionId))) {
  517. syncSelectedModel(string(result.model ?? info.model), string(result.provider ?? info.provider))
  518. }
  519. const liveFastMode = optionalBoolean(result.fast ?? info.fast)
  520. migrated.serverFastMode = liveFastMode
  521. if (!migrated.fastModeDirty && liveFastMode !== undefined) migrated.fastMode = liveFastMode
  522. persistFastMode(migrated)
  523. const resumedMessages = values(result.messages)
  524. .map(value => normalizeChatMessage(value, storedId, migrated.route.profile))
  525. if (resumedMessages.length) migrated.messages = mergeChatMessages(migrated.messages, resumedMessages, 'snapshot')
  526. const inflight = record(result.inflight ?? result.active_run)
  527. const assistant = string(inflight.assistant)
  528. const inflightError = string(inflight.error)
  529. migrated.isStreaming = bool(result.running) || bool(inflight.streaming)
  530. const queued = record(result.queued)
  531. const queuedUser = string(queued.user)
  532. migrated.isQueued = Boolean(queuedUser)
  533. if (assistant || inflightError) {
  534. migrated.messages = mergeChatMessages(migrated.messages, [{
  535. id: `resume:${runtimeId}`,
  536. sessionId: storedId,
  537. profile: migrated.route.profile,
  538. role: 'assistant',
  539. content: assistant,
  540. timestamp: number(result.turn_started_at, Date.now() / 1000),
  541. stage: inflightError ? 'failed' : migrated.isStreaming ? 'streaming' : 'settled',
  542. isStreaming: migrated.isStreaming,
  543. error: inflightError || undefined,
  544. }])
  545. }
  546. values(inflight.corrections).forEach((correction, index) => {
  547. const content = string(correction)
  548. if (!content) return
  549. migrated.messages = mergeChatMessages(migrated.messages, [{
  550. id: `resume-correction:${runtimeId}:${index}`,
  551. sessionId: storedId,
  552. profile: migrated.route.profile,
  553. role: 'user',
  554. content,
  555. timestamp: number(result.turn_started_at, Date.now() / 1000) + (index + 1) / 1000,
  556. stage: 'accepted',
  557. }])
  558. })
  559. if (queuedUser) {
  560. migrated.messages = mergeChatMessages(migrated.messages, [{
  561. id: `resume-queued:${runtimeId}`,
  562. sessionId: storedId,
  563. profile: migrated.route.profile,
  564. role: 'user',
  565. content: queuedUser,
  566. timestamp: Date.now() / 1000,
  567. stage: 'accepted',
  568. }])
  569. }
  570. const approval = record(result.pending_approval)
  571. const approvalID = string(approval.request_id ?? approval.requestId ?? approval.id)
  572. if (approvalID) migrated.pendingApproval = {
  573. id: approvalID,
  574. sessionId: storedId,
  575. message: string(approval.message ?? approval.prompt) || undefined,
  576. toolName: string(approval.tool_name ?? approval.tool) || undefined,
  577. choices: Array.isArray(approval.choices) ? approval.choices.map(String) : undefined,
  578. payload: approval as Record<string, JsonValue>,
  579. }
  580. const clarification = record(result.pending_clarify)
  581. const clarificationID = string(clarification.request_id ?? clarification.requestId ?? clarification.id)
  582. if (clarificationID) migrated.pendingClarification = {
  583. id: clarificationID,
  584. sessionId: storedId,
  585. question: string(clarification.question ?? clarification.message ?? clarification.prompt, '需要补充信息'),
  586. choices: Array.isArray(clarification.choices) ? clarification.choices.map(String) : undefined,
  587. payload: clarification as Record<string, JsonValue>,
  588. }
  589. if (storedId !== initialState.route.sessionId) clearInflightMarker(initialState.route.profile, initialState.route.sessionId)
  590. updateInflightMarker(migrated)
  591. return migrated
  592. }
  593. async function ensureRuntime(initialState: ChatRouteState): Promise<ChatRouteState> {
  594. if (initialState.runtimeSessionId) return initialState
  595. const key = routeKey(initialState.route.profile, initialState.route.sessionId)
  596. const existing = runtimePromises.get(key)
  597. if (existing) return existing
  598. let operation: Promise<ChatRouteState>
  599. operation = performEnsureRuntime(initialState).finally(() => {
  600. if (runtimePromises.get(key) === operation) runtimePromises.delete(key)
  601. })
  602. runtimePromises.set(key, operation)
  603. return operation
  604. }
  605. function updateDelivery(state: ChatRouteState, clientMessageId: string, patch: Partial<ChatMessage>): void {
  606. state.messages = state.messages.map(message => message.clientMessageId === clientMessageId || message.id === clientMessageId
  607. ? { ...message, ...patch }
  608. : message)
  609. }
  610. async function send(
  611. text: string,
  612. files: File[] = [],
  613. mode: 'submit' | 'queue' | 'steer' = 'submit',
  614. ): Promise<void> {
  615. let state = activeRouteState.value
  616. if (!state) {
  617. createSession()
  618. state = activeRouteState.value!
  619. }
  620. const trimmed = text.trim()
  621. if (!trimmed && !files.length) return
  622. const clientMessageId = createId('message')
  623. const attachments: ChatAttachment[] = files.map((file, index) => ({
  624. id: `${clientMessageId}:${index}`, name: file.name, mimeType: file.type || 'application/octet-stream',
  625. size: file.size, kind: file.type.startsWith('image/') ? 'image' : file.type === 'application/pdf' ? 'pdf' : 'file',
  626. }))
  627. const optimistic: ChatMessage = {
  628. id: clientMessageId, clientMessageId, sessionId: state.route.sessionId, profile: state.route.profile,
  629. role: 'user', content: trimmed, timestamp: Date.now() / 1000, stage: 'preparing', attachments,
  630. }
  631. state.messages = mergeChatMessages(state.messages, [optimistic])
  632. isSending.value = true
  633. error.value = undefined
  634. let submitted = false
  635. try {
  636. state = await ensureRuntime(state)
  637. const runtimeId = state.runtimeSessionId!
  638. if (!await applyDesiredModel(state)) throw new Error('请先确认模型切换,再重新发送消息')
  639. if (reasoningEffort.value) {
  640. await socket.request('config.set', {
  641. session_id: runtimeId, key: 'reasoning', value: reasoningEffort.value, scope: 'session',
  642. })
  643. }
  644. const desiredFastMode = state.fastMode ?? false
  645. if (state.serverFastMode !== desiredFastMode) {
  646. await socket.request('config.set', {
  647. session_id: runtimeId, key: 'fast', value: desiredFastMode ? 'fast' : 'normal', scope: 'session',
  648. })
  649. state.serverFastMode = desiredFastMode
  650. state.fastModeDirty = false
  651. persistFastMode(state)
  652. }
  653. const parts = trimmed ? [trimmed] : []
  654. for (const file of files) {
  655. const encoded = await encodeAttachment(file)
  656. if (encoded.kind === 'image') {
  657. await socket.request('image.attach_bytes', {
  658. session_id: runtimeId, content_base64: encoded.base64, filename: encoded.name, ext: encoded.extension,
  659. })
  660. parts.push(`[用户附加图片:${encoded.name}]`)
  661. } else if (encoded.kind === 'pdf') {
  662. await socket.request('pdf.attach', { session_id: runtimeId, content_base64: encoded.base64, filename: encoded.name })
  663. parts.push(`[用户附加 PDF:${encoded.name}]`)
  664. } else {
  665. const result = resultRecord(await socket.request('file.attach', {
  666. session_id: runtimeId, name: encoded.name, data_url: encoded.dataUrl,
  667. }))
  668. parts.push(`[用户附加文件:${encoded.name}]${string(result.ref_text) ? `\n${string(result.ref_text)}` : ''}`)
  669. }
  670. }
  671. updateDelivery(state, clientMessageId, { stage: files.length ? 'attached' : 'pending', sessionId: state.route.sessionId })
  672. updateDelivery(state, clientMessageId, { stage: 'pending' })
  673. submitted = true
  674. const effectiveMode = mode === 'steer' && files.length ? 'queue' : mode
  675. const method = effectiveMode === 'steer' ? 'session.steer' : 'prompt.submit'
  676. const result = resultRecord(await socket.request(method, {
  677. session_id: runtimeId,
  678. text: parts.join('\n\n'),
  679. ...(effectiveMode === 'queue' ? { queued: true } : {}),
  680. }, 120_000, `web:prompt:${clientMessageId}`))
  681. const status = string(result.status, 'accepted').toLowerCase()
  682. if (effectiveMode === 'steer' && !['accepted', 'queued', 'steered', 'streaming'].includes(status)) {
  683. throw new RpcError(string(result.error ?? result.message, 'Hermes 拒绝了 Steer 请求'), status)
  684. }
  685. updateDelivery(state, clientMessageId, { stage: 'accepted' })
  686. const running = ['running', 'started', 'streaming'].includes(status)
  687. if (effectiveMode === 'steer') {
  688. // A steer receipt acknowledges injection into the current run. It is
  689. // not evidence of a new run, including Hermes's `status: queued`.
  690. state.isQueued = false
  691. if (running) state.isStreaming = true
  692. } else {
  693. state.isQueued = status === 'queued'
  694. if (running || status === 'accepted') {
  695. state.isQueued = false
  696. state.isStreaming = true
  697. }
  698. }
  699. updateInflightMarker(state)
  700. // The optimistic row remains local, but the sidebar is refreshed only
  701. // after a 9119 receipt and keeps the order returned by the server.
  702. void loadSessions(state.route.profile).catch(() => undefined)
  703. } catch (cause) {
  704. const explicitRejection = cause instanceof RpcError
  705. const stage = submitted && !explicitRejection ? 'unknown-receipt' : 'failed'
  706. updateDelivery(state, clientMessageId, { stage, error: errorMessage(cause) })
  707. state.error = errorMessage(cause)
  708. throw cause
  709. } finally { isSending.value = false }
  710. }
  711. async function interrupt(): Promise<void> {
  712. const state = activeRouteState.value
  713. if (!state) return
  714. const current = await ensureRuntime(state)
  715. await socket.request('session.interrupt', { session_id: current.runtimeSessionId! }, 15_000)
  716. current.isStreaming = false
  717. current.isQueued = false
  718. current.messages = current.messages.map(message => message.role === 'assistant' && message.isStreaming
  719. ? { ...message, stage: message.stage === 'streaming' ? 'settled' : message.stage, isStreaming: false }
  720. : message)
  721. clearInflightMarker(current.route.profile, current.route.sessionId)
  722. }
  723. async function respondToApproval(requestId: string, approved: boolean | 'once' | 'session' | 'always' | 'deny'): Promise<void> {
  724. const state = activeRouteState.value
  725. if (!state) return
  726. const choice = typeof approved === 'boolean' ? approved ? 'once' : 'deny' : approved
  727. const modelConfirmation = pendingModelConfirmations.get(requestId)
  728. if (modelConfirmation) {
  729. pendingModelConfirmations.delete(requestId)
  730. const target = routes[modelConfirmation.routeKey]
  731. if (!target) throw new Error('模型确认请求已失效')
  732. const modelState = await ensureRuntime(target)
  733. if (choice === 'deny') {
  734. desiredModelRoutes.delete(modelConfirmation.routeKey)
  735. restoreSelectedSessionModel(modelConfirmation.routeKey)
  736. } else {
  737. try {
  738. if (await configureModel(modelState, modelConfirmation.model, true)) {
  739. desiredModelRoutes.delete(modelConfirmation.routeKey)
  740. }
  741. } catch (cause) {
  742. desiredModelRoutes.delete(modelConfirmation.routeKey)
  743. restoreSelectedSessionModel(modelConfirmation.routeKey)
  744. modelState.pendingApproval = undefined
  745. throw cause
  746. }
  747. }
  748. modelState.pendingApproval = undefined
  749. return
  750. }
  751. const current = await ensureRuntime(state)
  752. await socket.request('approval.respond', { session_id: current.runtimeSessionId!, choice })
  753. if (current.pendingApproval?.id === requestId) current.pendingApproval = undefined
  754. }
  755. async function respondToClarification(requestId: string, response: string): Promise<void> {
  756. const state = activeRouteState.value
  757. if (!state) return
  758. const current = await ensureRuntime(state)
  759. await socket.request('clarify.respond', { session_id: current.runtimeSessionId!, request_id: requestId, answer: response })
  760. if (current.pendingClarification?.id === requestId) current.pendingClarification = undefined
  761. }
  762. async function branchSession(): Promise<string | undefined> {
  763. const state = activeRouteState.value
  764. if (!state) return
  765. const current = await ensureRuntime(state)
  766. const result = resultRecord(await socket.request('session.branch', { session_id: current.runtimeSessionId! }))
  767. const runtimeId = string(result.session_id ?? result.sessionId)
  768. const storedId = string(result.stored_session_id ?? result.storedSessionId)
  769. if (!runtimeId || !storedId) throw new Error('Hermes 未返回分支会话标识')
  770. const next = emptyRoute(current.route.profile, storedId)
  771. next.runtimeSessionId = runtimeId
  772. routes[routeKey(current.route.profile, storedId)] = next
  773. runtimeRoutes.set(runtimeId, routeKey(current.route.profile, storedId))
  774. activeSessionId.value = storedId
  775. activeProfileName.value = current.route.profile
  776. // The branch was created by 9119, but its position remains server-owned.
  777. void loadSessions(current.route.profile).catch(() => undefined)
  778. return storedId
  779. }
  780. async function renameSession(id: string, title: string, profile?: string): Promise<void> {
  781. await updateSession(id, { title }, profile)
  782. await loadSessions(profile)
  783. }
  784. async function setSessionPinned(id: string, pinned: boolean, profile?: string): Promise<void> {
  785. await updateSession(id, { pinned }, profile)
  786. await loadSessions(profile)
  787. }
  788. async function removeSession(id: string, profile?: string): Promise<void> {
  789. if (!id.startsWith('draft-')) await deleteSessionApi(id, profile)
  790. sessions.value = sessions.value.filter(session => session.id !== id || (profile && session.profile !== profile))
  791. if (activeSessionId.value === id && (!profile || activeProfileName.value === profile)) {
  792. activeSessionId.value = undefined
  793. activeProfileName.value = undefined
  794. }
  795. }
  796. async function loadModels(profile = auth.activeProfile?.name): Promise<void> {
  797. const loadGeneration = ++modelLoadGeneration
  798. const loaded = await getModels(profile)
  799. if (loadGeneration !== modelLoadGeneration || (profile && auth.activeProfile?.name !== profile)) return
  800. models.value = loaded
  801. selectedModel.value = modelForSession(models.value, activeSession.value?.model, activeSession.value?.provider)
  802. ?? models.value.find(model => model.isDefault) ?? models.value[0]
  803. }
  804. async function refreshActiveSessionModel(): Promise<void> {
  805. const state = activeRouteState.value
  806. if (!state || state.route.sessionId.startsWith('draft-')) return
  807. const expectedKey = routeKey(state.route.profile, state.route.sessionId)
  808. const refreshed = await getSession(state.route.sessionId, state.route.profile)
  809. const current = activeRouteState.value
  810. if (!current || routeKey(current.route.profile, current.route.sessionId) !== expectedKey || !refreshed.model) return
  811. reconcileSessionModel(current.route.profile, current.route.sessionId, refreshed.model, refreshed.provider)
  812. }
  813. async function configureModel(state: ChatRouteState, model: ModelOption, confirmsExpensiveModel: boolean): Promise<boolean> {
  814. const result = resultRecord(await socket.request('config.set', {
  815. session_id: state.runtimeSessionId!,
  816. key: 'model',
  817. value: `${model.id} --provider ${model.provider} --session`,
  818. ...(confirmsExpensiveModel ? { confirm_expensive_model: true } : {}),
  819. }))
  820. if (bool(result.confirm_required ?? result.confirmRequired)) {
  821. const requestId = createId('expensive-model')
  822. pendingModelConfirmations.set(requestId, { routeKey: routeKey(state.route.profile, state.route.sessionId), model })
  823. state.pendingApproval = {
  824. id: requestId,
  825. sessionId: state.route.sessionId,
  826. message: string(result.confirm_message ?? result.confirmMessage ?? result.warning, '此模型可能产生较高费用,请确认后使用。'),
  827. choices: ['once', 'deny'],
  828. payload: result as Record<string, JsonValue>,
  829. }
  830. return false
  831. }
  832. // Match iOS: switching a model invalidates the cached fast-mode server
  833. // state, so the desired mode is re-applied before the next prompt.
  834. state.serverFastMode = undefined
  835. return true
  836. }
  837. async function applyDesiredModel(state: ChatRouteState): Promise<boolean> {
  838. const key = routeKey(state.route.profile, state.route.sessionId)
  839. if (!desiredModelRoutes.has(key) || !selectedModel.value || !state.runtimeSessionId) return true
  840. const applied = await configureModel(state, selectedModel.value, false)
  841. if (applied) desiredModelRoutes.delete(key)
  842. return applied
  843. }
  844. async function setModel(model: ModelOption): Promise<void> {
  845. selectedModel.value = model
  846. const state = activeRouteState.value
  847. if (!state) return
  848. const key = routeKey(state.route.profile, state.route.sessionId)
  849. desiredModelRoutes.add(key)
  850. if (!state.runtimeSessionId) return
  851. try {
  852. if (await configureModel(state, model, false)) desiredModelRoutes.delete(key)
  853. } catch (cause) {
  854. desiredModelRoutes.delete(key)
  855. restoreSelectedSessionModel(key)
  856. throw cause
  857. }
  858. }
  859. async function setFastMode(enabled: boolean): Promise<void> {
  860. const state = activeRouteState.value
  861. if (!state) return
  862. const previous = state.fastMode ?? false
  863. state.fastMode = enabled
  864. state.fastModeDirty = true
  865. persistFastMode(state)
  866. if (!state.runtimeSessionId || state.isStreaming || !['connected', 'ready'].includes(connectionState.value)) return
  867. try {
  868. await socket.request('config.set', {
  869. session_id: state.runtimeSessionId, key: 'fast', value: enabled ? 'fast' : 'normal', scope: 'session',
  870. })
  871. state.serverFastMode = enabled
  872. state.fastModeDirty = false
  873. } catch (cause) {
  874. state.fastMode = previous
  875. state.fastModeDirty = false
  876. persistFastMode(state)
  877. error.value = `快速模式未同步:${errorMessage(cause)}`
  878. throw cause
  879. }
  880. }
  881. async function refreshContextUsage(initialState = activeRouteState.value): Promise<void> {
  882. // Opening history is read-only. Resuming an old session merely to fetch
  883. // usage updates Hermes' last_active timestamp and incorrectly moves it
  884. // into today's sidebar group.
  885. if (!initialState || initialState.route.sessionId.startsWith('draft-') || !initialState.runtimeSessionId) return
  886. const current = initialState
  887. const usage = resultRecord(await socket.request('session.usage', { session_id: current.runtimeSessionId! }))
  888. current.usage = {
  889. inputTokens: number(usage.input_tokens ?? usage.input) || undefined,
  890. outputTokens: number(usage.output_tokens ?? usage.output) || undefined,
  891. totalTokens: number(usage.total_tokens ?? usage.total) || undefined,
  892. contextTokens: number(usage.context_tokens ?? usage.context_used ?? usage.used) || undefined,
  893. contextLimit: number(usage.context_limit ?? usage.context_max ?? usage.limit) || undefined,
  894. percentUsed: number(usage.percent_used ?? usage.context_percent) || undefined,
  895. raw: usage as JsonValue,
  896. }
  897. }
  898. return {
  899. sessions, activeSessionId, activeProfileName, activeSession, routes, activeRouteState, messages,
  900. connectionState, historySynced, hasMoreBefore, isLoading, isLoadingMoreSessions, hasMoreSessions, isSending, isStreaming, isQueued,
  901. error, models, selectedModel, reasoningEffort, fastMode, contextUsage, pendingApproval, pendingClarification, unreadCounts,
  902. loadSessions, loadMoreSessions, selectSession, loadOlder, createSession, connect, disconnect, send, interrupt,
  903. respondToApproval, respondToClarification, branchSession, renameSession, setSessionPinned, removeSession,
  904. loadModels, setModel, setFastMode, refreshActiveSessionModel, refreshContextUsage, loadUnread, markRead, switchProfile,
  905. }
  906. })