An AI-powered search engine with a generative UI
TypeScript generative-aigenerative-uinextjsollamareactsearxngshadcn-uitailwindcsstavilytypescriptupstashvercel-ai-sdk
import { generateId } from '@/lib/db/schema'
import { DeterministicPreparationError } from '@/lib/errors/deterministic-preparation-error'
import type {
UIDataTypes,
UIMessage,
UIMessageMetadata,
UITools
} from '@/lib/types/ai'
import type { DynamicToolPart } from '@/lib/types/dynamic-tools'
import type {
DBMessagePart,
DBMessagePartSelect,
ToolState
} from '@/lib/types/message-persistence'
// The tsvector search columns are projected out of normal chat loads
// (loadChat / loadChatWithMessages) so stored vectors are not transported on
// every chat open. Mapping only needs the remaining columns.
export type DBMessagePartWithoutVectors = Omit<
DBMessagePartSelect,
'search' | 'searchReasoning'
>
// Define local types for message parts that are compatible with the AI SDK
type TextUIPart = { type: 'text'; text: string; providerMetadata?: any }
type ReasoningUIPart = {
type: 'reasoning'
text: string
providerMetadata?: any
}
type FileUIPart = {
type: 'file'
mediaType: string
filename?: string
url: string
key?: string
}
type SourceUrlUIPart = {
type: 'source-url'
sourceId: string
url: string
title: string
} // title is required
type SourceDocumentUIPart = {
type: 'source-document'
sourceId: string
mediaType: string
title: string
filename: string
url: string
snippet: string
} // all fields required
type ToolCallPart = {
type: 'tool-call'
toolCallId: string
toolName: string
args: any
}
type ToolResultPart = {
type: 'tool-result'
toolCallId: string
result: any
isError?: boolean
}
type DataPart = { type: string; [key: string]: any }
type UIMessagePart =
| TextUIPart
| ReasoningUIPart
| FileUIPart
| SourceUrlUIPart
| SourceDocumentUIPart
| ToolCallPart
| ToolResultPart
| DataPart
// Type guards
function isToolCallPart(part: any): part is ToolCallPart {
return (
part.type === 'tool-call' &&
typeof part.toolCallId === 'string' &&
typeof part.toolName === 'string' &&
part.args !== undefined
)
}
function isToolResultPart(part: any): part is ToolResultPart {
return (
part.type === 'tool-result' &&
typeof part.toolCallId === 'string' &&
part.result !== undefined
)
}
// Type for tool-specific parts with extended properties
type ExtendedToolPart = {
type: string
toolCallId?: string
state?: ToolState
errorText?: string
input?: any
output?: any
}
function isExtendedToolPart(part: any): part is ExtendedToolPart {
return (
typeof part === 'object' &&
part !== null &&
typeof part.type === 'string' &&
part.type.startsWith('tool-')
)
}
// Helper function to create tool part mapping
function createToolPartMapping(
basePart: Omit<DBMessagePart, 'type'>,
part: ExtendedToolPart,
toolName: string
): DBMessagePart {
const inputColumn = `tool_${toolName}_input` as keyof DBMessagePart
const outputColumn = `tool_${toolName}_output` as keyof DBMessagePart
return {
...basePart,
type: part.type,
tool_toolCallId: part.toolCallId || generateId(),
tool_state: part.state || ('input-available' as ToolState),
tool_errorText: part.errorText,
[inputColumn]: part.input,
[outputColumn]: part.output
} as DBMessagePart
}
/**
* Convert UI message parts to DB format
*/
export function mapUIMessagePartsToDBParts(
messageParts: UIMessagePart[],
messageId: string
): DBMessagePart[] {
const mappedParts = messageParts.map((part, index): DBMessagePart | null => {
const basePart = {
messageId,
order: index,
type: part.type
}
switch (part.type) {
case 'text':
return {
...basePart,
text_text: part.text
}
case 'reasoning':
return {
...basePart,
reasoning_text: part.text,
providerMetadata: part.providerMetadata
}
case 'file':
return {
...basePart,
file_mediaType: part.mediaType,
file_filename: part.filename,
file_url: part.key ? undefined : part.url,
file_key: part.key
}
case 'source-url':
return {
...basePart,
source_url_sourceId: part.sourceId,
source_url_url: part.url,
source_url_title: part.title
}
case 'source-document':
return {
...basePart,
source_document_sourceId: part.sourceId,
source_document_mediaType: part.mediaType,
source_document_title: part.title,
source_document_filename: part.filename,
source_document_url: part.url,
source_document_snippet: part.snippet
}
// Tool parts
case 'tool-call':
// Type guard ensures part has the required properties
if (!isToolCallPart(part)) {
console.error('Invalid tool-call part:', part)
return null
}
const toolName = getToolNameFromType(part.toolName)
const toolInputColumn = `tool_${toolName}_input` as keyof DBMessagePart
const result = {
...basePart,
type: `tool-${toolName}`,
tool_toolCallId: part.toolCallId,
tool_state: 'input-available' as ToolState,
[toolInputColumn]: part.args
} as DBMessagePart
// Store additional metadata for dynamic tools
if (toolName === 'dynamic') {
result.tool_dynamic_name = part.toolName
result.tool_dynamic_type = part.toolName.startsWith('mcp__')
? 'mcp'
: 'dynamic'
}
return result
case 'tool-result':
const resultToolName = getToolNameFromCallId(
part.toolCallId,
messageParts
)
const toolOutputColumn =
`tool_${resultToolName}_output` as keyof DBMessagePart
const toolResult = {
...basePart,
type: `tool-${resultToolName}`,
tool_toolCallId: part.toolCallId,
tool_state: part.isError
? 'output-error'
: ('output-available' as ToolState),
tool_errorText: part.isError ? String(part.result) : undefined,
[toolOutputColumn]: !part.isError ? part.result : undefined
} as DBMessagePart
// Preserve dynamic tool metadata from the corresponding tool-call
if (resultToolName === 'dynamic') {
const toolCallPart = messageParts.find(
p => isToolCallPart(p) && p.toolCallId === part.toolCallId
) as ToolCallPart | undefined
if (toolCallPart) {
toolResult.tool_dynamic_name = toolCallPart.toolName
toolResult.tool_dynamic_type = toolCallPart.toolName.startsWith(
'mcp__'
)
? 'mcp'
: 'dynamic'
}
}
return toolResult
// Step parts (for UI tracking)
case 'step-start':
// Persist step-start to maintain message structure
return basePart
case 'step-result':
case 'step-continue':
case 'step-finish':
return null // These are not needed for message structure
// Dynamic tool parts from AI SDK v5
case 'dynamic-tool':
const dynamicPart = part as DynamicToolPart
return {
...basePart,
type: 'tool-dynamic',
tool_toolCallId: dynamicPart.toolCallId || generateId(),
tool_state: dynamicPart.state as ToolState,
tool_dynamic_name: dynamicPart.toolName,
tool_dynamic_type: dynamicPart.toolName.startsWith('mcp__')
? 'mcp'
: 'dynamic',
tool_dynamic_input: dynamicPart.input,
tool_dynamic_output:
dynamicPart.state === 'output-available'
? dynamicPart.output
: undefined,
tool_errorText:
dynamicPart.state === 'output-error'
? dynamicPart.errorText
: undefined
}
// Tool-specific parts that are not tool-call or tool-result
// The following cases are tool parts with state tracking
case 'tool-search':
if (!isExtendedToolPart(part)) {
console.error('Invalid extended tool part:', part)
return null
}
return createToolPartMapping(basePart, part, 'search')
case 'tool-fetch':
if (!isExtendedToolPart(part)) {
console.error('Invalid extended tool part:', part)
return null
}
return createToolPartMapping(basePart, part, 'fetch')
case 'tool-question':
if (!isExtendedToolPart(part)) {
console.error('Invalid extended tool part:', part)
return null
}
return createToolPartMapping(basePart, part, 'question')
case 'tool-todoWrite':
if (!isExtendedToolPart(part)) {
console.error('Invalid extended tool part:', part)
return null
}
return createToolPartMapping(basePart, part, 'todoWrite')
case 'tool-todoRead':
if (!isExtendedToolPart(part)) {
console.error('Invalid extended tool part:', part)
return null
}
return createToolPartMapping(basePart, part, 'todoRead')
// Stored in the dynamic tool columns, so drafts need no schema change.
// Read back as tool-editDraft by the 'draft' dynamic type.
case 'tool-editDraft':
if (!isExtendedToolPart(part)) {
console.error('Invalid extended tool part:', part)
return null
}
return {
...basePart,
type: 'tool-dynamic',
tool_toolCallId: part.toolCallId || generateId(),
tool_state: part.state || ('input-available' as ToolState),
tool_dynamic_name: 'editDraft',
tool_dynamic_type: 'draft',
tool_dynamic_input: part.input,
tool_dynamic_output: part.output,
tool_errorText: part.errorText
}
// Data parts
default:
if (part.type.startsWith('data-')) {
const dataType = part.type.substring(5) // Remove 'data-' prefix
return {
...basePart,
data_prefix: dataType,
data_content: 'data' in part ? part.data : part,
data_id: 'id' in part ? part.id : undefined
}
}
// Unknown part type - store as data
return {
...basePart,
data_prefix: part.type,
data_content: part
}
}
})
// Filter out null values and re-index
return mappedParts
.filter((part): part is DBMessagePart => part !== null)
.map((part, index) => ({ ...part, order: index }))
}
/**
* Convert DB message parts to UI format
*/
export function mapDBPartToUIMessagePart(
part: DBMessagePartWithoutVectors
): UIMessagePart {
switch (part.type) {
case 'text':
return {
type: 'text',
text: part.text_text || ''
}
case 'reasoning':
return {
type: 'reasoning',
text: part.reasoning_text || '',
providerMetadata: part.providerMetadata
}
case 'file':
return {
type: 'file',
mediaType: part.file_mediaType || '',
filename: part.file_filename || '',
url: part.file_key ? '' : part.file_url || '',
key: part.file_key || undefined
}
case 'source-url':
return {
type: 'source-url',
sourceId: part.source_url_sourceId || '',
url: part.source_url_url || '',
title: part.source_url_title || ''
}
case 'source-document':
return {
type: 'source-document',
sourceId: part.source_document_sourceId || '',
mediaType: part.source_document_mediaType || '',
title: part.source_document_title || '',
filename: part.source_document_filename || '',
url: part.source_document_url || '',
snippet: part.source_document_snippet || ''
}
default:
// Tool parts
if (part.type.startsWith('tool-')) {
const toolName = part.type.substring(5) // Remove 'tool-' prefix
const inputColumn =
`tool_${toolName}_input` as keyof DBMessagePartWithoutVectors
const outputColumn =
`tool_${toolName}_output` as keyof DBMessagePartWithoutVectors
// Special handling for dynamic tools
if (toolName === 'dynamic' && part.tool_dynamic_type === 'draft') {
return {
type: `tool-${part.tool_dynamic_name}`,
toolCallId: part.tool_toolCallId || '',
state: part.tool_state as any,
input: part.tool_dynamic_input,
output: part.tool_dynamic_output,
errorText: part.tool_errorText
} as any
}
if (toolName === 'dynamic') {
return {
type: 'dynamic-tool',
toolCallId: part.tool_toolCallId || '',
toolName: part.tool_dynamic_name || '',
state: part.tool_state as any, // Maps directly to AI SDK states
input: part.tool_dynamic_input,
output: part.tool_dynamic_output,
errorText: part.tool_errorText
}
}
// Special handling for tool parts that maintain their type
if (toolName === 'search') {
if (!part.tool_state) {
throw new DeterministicPreparationError(
`tool_state is undefined for ${toolName}`
)
}
switch (part.tool_state) {
case 'input-streaming':
return {
type: 'tool-search',
state: 'input-streaming',
toolCallId: part.tool_toolCallId || '',
input: part.tool_search_input!
}
case 'input-available':
return {
type: 'tool-search',
state: 'input-available',
toolCallId: part.tool_toolCallId || '',
input: part.tool_search_input!
}
case 'output-available':
return {
type: 'tool-search',
state: 'output-available',
toolCallId: part.tool_toolCallId || '',
input: part.tool_search_input!,
output: part.tool_search_output!
}
case 'output-error':
return {
type: 'tool-search',
state: 'output-error',
toolCallId: part.tool_toolCallId || '',
input: part.tool_search_input!,
errorText: part.tool_errorText!
}
default:
throw new DeterministicPreparationError(
`Unknown tool state: ${part.tool_state}`
)
}
}
if (toolName === 'fetch') {
if (!part.tool_state) {
throw new DeterministicPreparationError(
`tool_state is undefined for ${toolName}`
)
}
switch (part.tool_state) {
case 'input-streaming':
return {
type: 'tool-fetch',
state: 'input-streaming',
toolCallId: part.tool_toolCallId || '',
input: part.tool_fetch_input!
}
case 'input-available':
return {
type: 'tool-fetch',
state: 'input-available',
toolCallId: part.tool_toolCallId || '',
input: part.tool_fetch_input!
}
case 'output-available':
return {
type: 'tool-fetch',
state: 'output-available',
toolCallId: part.tool_toolCallId || '',
input: part.tool_fetch_input!,
output: part.tool_fetch_output!
}
case 'output-error':
return {
type: 'tool-fetch',
state: 'output-error',
toolCallId: part.tool_toolCallId || '',
input: part.tool_fetch_input!,
errorText: part.tool_errorText!
}
default:
throw new DeterministicPreparationError(
`Unknown tool state: ${part.tool_state}`
)
}
}
if (toolName === 'question') {
if (!part.tool_state) {
throw new DeterministicPreparationError(
`tool_state is undefined for ${toolName}`
)
}
switch (part.tool_state) {
case 'input-streaming':
return {
type: 'tool-question',
state: 'input-streaming',
toolCallId: part.tool_toolCallId || '',
input: part.tool_question_input!
}
case 'input-available':
return {
type: 'tool-question',
state: 'input-available',
toolCallId: part.tool_toolCallId || '',
input: part.tool_question_input!
}
case 'output-available':
return {
type: 'tool-question',
state: 'output-available',
toolCallId: part.tool_toolCallId || '',
input: part.tool_question_input!,
output: part.tool_question_output!
}
case 'output-error':
return {
type: 'tool-question',
state: 'output-error',
toolCallId: part.tool_toolCallId || '',
input: part.tool_question_input!,
errorText: part.tool_errorText!
}
default:
throw new DeterministicPreparationError(
`Unknown tool state: ${part.tool_state}`
)
}
}
if (toolName === 'todoWrite') {
if (!part.tool_state) {
throw new DeterministicPreparationError(
`tool_state is undefined for ${toolName}`
)
}
switch (part.tool_state) {
case 'input-streaming':
return {
type: 'tool-todoWrite',
state: 'input-streaming',
toolCallId: part.tool_toolCallId || '',
input: part.tool_todoWrite_input!
}
case 'input-available':
return {
type: 'tool-todoWrite',
state: 'input-available',
toolCallId: part.tool_toolCallId || '',
input: part.tool_todoWrite_input!
}
case 'output-available':
return {
type: 'tool-todoWrite',
state: 'output-available',
toolCallId: part.tool_toolCallId || '',
input: part.tool_todoWrite_input!,
output: part.tool_todoWrite_output!
}
case 'output-error':
return {
type: 'tool-todoWrite',
state: 'output-error',
toolCallId: part.tool_toolCallId || '',
input: part.tool_todoWrite_input!,
errorText: part.tool_errorText!
}
default:
throw new DeterministicPreparationError(
`Unknown tool state: ${part.tool_state}`
)
}
}
if (toolName === 'todoRead') {
if (!part.tool_state) {
throw new DeterministicPreparationError(
`tool_state is undefined for ${toolName}`
)
}
switch (part.tool_state) {
case 'input-streaming':
return {
type: 'tool-todoRead',
state: 'input-streaming',
toolCallId: part.tool_toolCallId || '',
input: part.tool_todoRead_input!
}
case 'input-available':
return {
type: 'tool-todoRead',
state: 'input-available',
toolCallId: part.tool_toolCallId || '',
input: part.tool_todoRead_input!
}
case 'output-available':
return {
type: 'tool-todoRead',
state: 'output-available',
toolCallId: part.tool_toolCallId || '',
input: part.tool_todoRead_input!,
output: part.tool_todoRead_output!
}
case 'output-error':
return {
type: 'tool-todoRead',
state: 'output-error',
toolCallId: part.tool_toolCallId || '',
input: part.tool_todoRead_input!,
errorText: part.tool_errorText!
}
default:
throw new DeterministicPreparationError(
`Unknown tool state: ${part.tool_state}`
)
}
}
// Standard tool-call/tool-result pattern
if (
part.tool_state === 'input-available' ||
part.tool_state === 'input-streaming'
) {
// For dynamic tools, use the stored original name
const originalToolName =
toolName === 'dynamic' && part.tool_dynamic_name
? part.tool_dynamic_name
: getOriginalToolName(toolName)
return {
type: 'tool-call',
toolCallId: part.tool_toolCallId || '',
toolName: originalToolName,
args: part[inputColumn] as any
}
} else {
// output-available or output-error
return {
type: 'tool-result',
toolCallId: part.tool_toolCallId || '',
isError: part.tool_state === 'output-error',
result:
part.tool_state === 'output-error'
? part.tool_errorText
: part[outputColumn]
}
}
}
// Step parts
if (part.type === 'step-start') {
return {
type: 'step-start'
}
}
// Data parts
if (part.data_prefix) {
return {
type: `data-${part.data_prefix}`,
data: part.data_content,
...(part.data_id ? { id: part.data_id } : {})
}
}
// Fallback - should not happen
throw new DeterministicPreparationError(`Unknown part type: ${part.type}`)
}
}
/**
* Normalize tool name (from tool-call's toolName)
*/
function getToolNameFromType(toolName: string): string {
// Map original tool names to DB column names
const toolNameMap: Record<string, string> = {
search: 'search',
fetch: 'fetch',
askQuestion: 'question',
question: 'question',
todoWrite: 'todoWrite',
todoRead: 'todoRead'
}
// For dynamic tools (MCP and others)
if (toolName.startsWith('mcp__') || toolName.startsWith('dynamic__')) {
return 'dynamic'
}
return toolNameMap[toolName] || toolName
}
/**
* Get tool name from tool-result
*/
function getToolNameFromCallId(
toolCallId: string,
allParts: UIMessagePart[]
): string {
// Find tool-call part with the same toolCallId
const toolCallPart = allParts.find(
part => part.type === 'tool-call' && part.toolCallId === toolCallId
) as any
if (toolCallPart) {
return getToolNameFromType(toolCallPart.toolName)
}
// Fallback - should not happen
return 'unknown'
}
/**
* Convert DB column name back to original tool name
*/
function getOriginalToolName(dbToolName: string): string {
const reverseMap: Record<string, string> = {
search: 'search',
fetch: 'fetch',
question: 'askQuestion',
todoWrite: 'todoWrite',
todoRead: 'todoRead',
dynamic: 'dynamic' // For dynamic tools, the actual tool name is stored separately
}
return reverseMap[dbToolName] || dbToolName
}
/**
* Convert UI message to DB message (excluding parts)
*/
export function mapUIMessageToDBMessage(
message: UIMessage & { id: string; chatId: string }
): {
id: string
chatId: string
role: string
metadata?: UIMessageMetadata | null
} {
return {
id: message.id,
chatId: message.chatId,
role: message.role,
metadata: message.metadata || null
}
}
/**
* Build UI message from DB message and parts
*/
export function buildUIMessageFromDB(
dbMessage: {
id: string
role: string
metadata?: UIMessageMetadata | null
createdAt?: Date | string
},
dbParts: DBMessagePartWithoutVectors[]
): UIMessage {
// Merge metadata from DB with createdAt
const metadata: UIMessageMetadata = {
...(dbMessage.metadata || {}),
...(dbMessage.createdAt && {
createdAt:
dbMessage.createdAt instanceof Date
? dbMessage.createdAt
: new Date(dbMessage.createdAt)
})
}
return {
id: dbMessage.id,
role: dbMessage.role as 'user' | 'assistant',
parts: dbParts.map(mapDBPartToUIMessagePart) as UIMessage['parts'],
metadata: Object.keys(metadata).length > 0 ? metadata : undefined
}
}