An AI-powered search engine with a generative UI
TypeScript generative-aigenerative-uinextjsollamareactsearxngshadcn-uitailwindcsstavilytypescriptupstashvercel-ai-sdk
'use client'
import { Chat } from '@ai-sdk/react'
import { ChatInit, DefaultChatTransport } from 'ai'
import { getDistinctId } from '@/lib/analytics/posthog-client'
import { generateId } from '@/lib/db/schema'
import type { UIMessage } from '@/lib/types/ai'
export type ChatHandlers = Pick<ChatInit<UIMessage>, 'onFinish' | 'onError'>
export type ChatEntry = {
chat: Chat<UIMessage>
handlers: { current: ChatHandlers }
verifiedAt: number
loadedAt: number
hasServerHistory: boolean
createdLocally: boolean
fetching?: Promise<void>
error?: Error
revision: number
size: number
dispose: () => void
}
const busy = (entry: ChatEntry) =>
entry.chat.status === 'submitted' || entry.chat.status === 'streaming'
export class ChatStore {
private entries = new Map<string, ChatEntry>()
private userId: string | null = null
private listeners = new Set<() => void>()
private version = 0
constructor(
private maxEntries = 20,
private maxSize = 20 * 1024 * 1024
) {}
subscribe = (listener: () => void) => {
this.listeners.add(listener)
return () => {
this.listeners.delete(listener)
}
}
getSnapshot = () => this.version
private emit() {
this.version++
this.listeners.forEach(listener => listener())
}
setUser(userId: string | null) {
if (this.userId !== userId) {
this.userId = userId
this.clear()
}
}
attachHandlers(entry: ChatEntry, handlers: ChatHandlers) {
entry.handlers.current = handlers
return () => {
if (entry.handlers.current === handlers) entry.handlers.current = {}
}
}
get(id: string) {
return this.entries.get(id)
}
getOrCreate(
id: string,
options: { messages?: UIMessage[]; isNew?: boolean; isGuest?: boolean } = {}
) {
const existing = this.entries.get(id)
if (existing) {
this.entries.delete(id)
this.entries.set(id, existing)
this.prune(existing)
return existing
}
const now = Date.now()
const handlers: ChatEntry['handlers'] = { current: {} }
const entry: ChatEntry = {
chat: new Chat<UIMessage>({
id,
messages: options.messages,
generateId,
transport: new DefaultChatTransport({
api: '/api/chat',
prepareSendMessagesRequest: ({
messages,
trigger,
messageId,
body
}) => {
const lastMessage = messages[messages.length - 1]
const original =
trigger === 'regenerate-message'
? messages.find(m => m.id === messageId)
: undefined
return {
body: {
...body,
trigger,
chatId: id,
messageId,
clientSource: 'web',
analyticsId: getDistinctId(),
...(options.isGuest ? { messages } : {}),
message:
trigger === 'regenerate-message' && original?.role === 'user'
? original
: trigger === 'submit-message'
? lastMessage
: undefined,
isNewChat:
trigger === 'submit-message' &&
messages.length === 1 &&
!entry.hasServerHistory
}
}
}
}),
onFinish: event => {
if (this.entries.get(id) === entry) {
if (event.isAbort || event.isError) this.invalidate(id)
else this.markVerified(id)
}
if (typeof window !== 'undefined') {
window.dispatchEvent(new CustomEvent('chat-history-updated'))
}
return handlers.current.onFinish?.(event)
},
onError: error => {
if (this.entries.get(id) === entry) this.invalidate(id)
handlers.current.onError?.(error)
}
}),
handlers,
verifiedAt: options.messages !== undefined || options.isNew ? now : 0,
loadedAt: now,
hasServerHistory: options.messages !== undefined && !options.isNew,
createdLocally: !!options.isNew,
revision: 0,
size: 0,
dispose: () => {}
}
const updateSize = () => {
if (!busy(entry)) {
entry.size = JSON.stringify(entry.chat.messages).length
this.prune(entry)
}
}
const unsubscribes = [
entry.chat['~registerMessagesCallback'](updateSize),
entry.chat['~registerStatusCallback'](() => {
entry.revision++
updateSize()
})
]
entry.dispose = () => unsubscribes.forEach(unsubscribe => unsubscribe())
entry.size = JSON.stringify(entry.chat.messages).length
this.entries.set(id, entry)
this.prune(entry)
return entry
}
private prune(protectedEntry: ChatEntry) {
let size = [...this.entries.values()].reduce((sum, e) => sum + e.size, 0)
for (const [id, entry] of this.entries) {
if (this.entries.size <= this.maxEntries && size <= this.maxSize) break
if (entry === protectedEntry || busy(entry) || entry.fetching) continue
size -= entry.size
entry.dispose()
this.entries.delete(id)
}
}
markVerified(id: string) {
const entry = this.entries.get(id)
if (!entry) return
entry.verifiedAt = Date.now()
entry.hasServerHistory = true
entry.revision++
this.emit()
}
invalidate(id: string) {
const entry = this.entries.get(id)
if (!entry) return
entry.verifiedAt = 0
entry.revision++
this.emit()
}
remove(id: string) {
const entry = this.entries.get(id)
if (entry) entry.handlers.current = {}
entry?.dispose()
this.entries.delete(id)
void entry?.chat.stop()
this.emit()
}
clear() {
const entries = [...this.entries.values()]
this.entries.clear()
entries.forEach(entry => {
entry.handlers.current = {}
entry.dispose()
void entry.chat.stop()
})
this.emit()
}
revalidate(id: string): Promise<void> {
const entry = this.entries.get(id)
if (!entry) return Promise.resolve()
if (
entry.createdLocally &&
!entry.hasServerHistory &&
entry.chat.messages.length === 0
)
return Promise.resolve()
if (entry.fetching) return entry.fetching
const now = Date.now()
if (
entry.verifiedAt !== 0 &&
now - entry.verifiedAt < 30_000 &&
now - entry.loadedAt < 30 * 60_000
)
return Promise.resolve()
const revision = entry.revision
entry.error = undefined
entry.fetching = (async () => {
let notFound = false
try {
const response = await fetch(`/api/chats/${encodeURIComponent(id)}`, {
cache: 'no-store'
})
if (!response.ok) {
notFound = response.status === 404
throw new Error(notFound ? 'Chat not found' : 'Failed to load chat')
}
const data = (await response.json()) as { messages: UIMessage[] }
// A local turn or account change makes this response obsolete.
if (
this.entries.get(id) !== entry ||
busy(entry) ||
entry.revision !== revision
)
return
entry.chat.messages = data.messages
entry.loadedAt = Date.now()
this.markVerified(id)
} catch (error) {
if (this.entries.get(id) === entry && entry.revision === revision) {
if (notFound) {
if (entry.createdLocally && !entry.hasServerHistory) return
entry.chat.messages = []
entry.verifiedAt = 0
entry.error = new Error('Chat not found')
} else if (entry.hasServerHistory || entry.chat.messages.length > 0) {
console.error('Failed to revalidate chat:', error)
} else {
entry.verifiedAt = 0
entry.error =
error instanceof Error ? error : new Error('Failed to load chat')
}
}
} finally {
entry.fetching = undefined
this.emit()
}
})()
this.emit()
return entry.fetching
}
}
export const chatStore = new ChatStore()