Big sigh, finally getting control of my markup

This commit is contained in:
Glen Maddern 2025-06-25 19:01:30 +10:00
commit ba845e7852
10 changed files with 253 additions and 284 deletions

View file

@ -1,64 +0,0 @@
import React from 'react'
import ReactMarkdown from 'react-markdown'
import remarkGfm from 'remark-gfm'
import rehypeHighlight from 'rehype-highlight'
import { type Message } from '../types'
import ToolCallMessage from './ToolCallMessage'
import ToolResultMessage from './ToolResultMessage'
import ReasoningBlock from './ReasoningBlock'
interface ChatMessageProps {
message: Message
}
const ChatMessage: React.FC<ChatMessageProps> = ({ message }) => {
// Handle tool calls and results differently
if (message.role === 'tool-call') {
return <ToolCallMessage message={message} />
}
if (message.role === 'tool-result') {
return <ToolResultMessage message={message} />
}
// Handle regular messages (user, assistant, system)
return (
<div className={`flex ${message.role === 'user' ? 'justify-end' : 'justify-start'}`}>
<div
className={`
${
message.role === 'user'
? 'max-w-[80%] rounded-2xl px-3 py-2 border border-zinc-200/10 bg-white text-black'
: ' text-zinc-900 w-full'
}`}
>
{/* Show reasoning block for assistant messages with reasoning */}
{message.role === 'assistant' && 'reasoning' in message && (message.reasoning || message.isReasoningStreaming) && (
<ReasoningBlock
reasoning={message.reasoning || ''}
isStreaming={message.isReasoningStreaming}
startTime={message.reasoningStartTime}
endTime={message.reasoningEndTime}
/>
)}
{/* Only render content div if there's actual content */}
{message.content && message.content.trim() && (
<div className="prose prose-zinc">
<ReactMarkdown
remarkPlugins={[remarkGfm]}
rehypePlugins={[rehypeHighlight]}
components={{
table: ({ children }) => <div className="overflow-x-scroll text-sm">{children}</div>,
}}
>
{message.content}
</ReactMarkdown>
</div>
)}
</div>
</div>
)
}
export default ChatMessage

View file

@ -6,7 +6,7 @@ import { type Conversation, type Message } from '../types'
import { type Model } from '../types/models' import { type Model } from '../types/models'
import { type IDBPDatabase } from 'idb' import { type IDBPDatabase } from 'idb'
import { type Tool } from 'use-mcp/react' import { type Tool } from 'use-mcp/react'
import ChatMessage from './ChatMessage' import ChatMessage from './messages/ChatMessage.tsx'
import ChatInput from './ChatInput' import ChatInput from './ChatInput'
import ModelSelectionModal from './ModelSelectionModal' import ModelSelectionModal from './ModelSelectionModal'
import McpServerModal from './McpServerModal' import McpServerModal from './McpServerModal'
@ -180,43 +180,12 @@ const ConversationThread: React.FC<ConversationThreadProps> = ({
> >
<div className="max-w-2xl mx-auto w-full px-4"> <div className="max-w-2xl mx-auto w-full px-4">
{currentConversation.messages.length === 0 ? ( {currentConversation.messages.length === 0 ? (
<div className="text-center"> <div className="text-center">{/*<h1 className="text-9xl font-semibold text-zinc-800 h-20 overflow-auto">use-mcp</h1>*/}</div>
{/* Title and description text hidden but kept in codebase */}
{false && (
<>
<h1 className="text-4xl font-semibold text-zinc-800">What do you want to know?</h1>
<div className="mt-4">
<h2 className="mt-2 text-md opacity-70">
AI chat template built with React, Vite and Cloudflare Workers AI.
<div className="mt-1 w-full">
Find the source code on{' '}
<a className="text-blue-700" href="https://github.com/thomasgauvin/ai-chat-template">
GitHub
</a>
.
</div>
</h2>
</div>
</>
)}
</div>
) : ( ) : (
<div className="py-4 px-4 space-y-4"> <div className="py-4 px-4 space-y-4">
{currentConversation.messages {currentConversation.messages.map((message, index) => (
.filter((message) => { <ChatMessage key={index} message={message} />
// Filter out empty assistant messages (no content and no reasoning) ))}
if (
message.role === 'assistant' &&
(!message.content || !message.content.trim()) &&
!('reasoning' in message && (message.reasoning || message.isReasoningStreaming))
) {
return false
}
return true
})
.map((message, index) => (
<ChatMessage key={index} message={message} />
))}
{isLoading && !streamStarted && <div className="text-center text-sm text-zinc-600">Thinking...</div>} {isLoading && !streamStarted && <div className="text-center text-sm text-zinc-600">Thinking...</div>}
<div ref={messagesEndRef} /> <div ref={messagesEndRef} />
</div> </div>

View file

@ -0,0 +1,31 @@
import React from 'react'
import { type AssistantMessage } from '../../types'
import ReactMarkdown from 'react-markdown'
import remarkGfm from 'remark-gfm'
import rehypeHighlight from 'rehype-highlight'
interface AssistantMessageProps {
message: AssistantMessage
}
const AssistantMessage: React.FC<AssistantMessageProps> = ({ message }) => {
return (
<div className={`flex justify-start`}>
<div className={`text-zinc-900 w-full`}>
<div className="prose prose-zinc">
<ReactMarkdown
remarkPlugins={[remarkGfm]}
rehypePlugins={[rehypeHighlight]}
components={{
table: ({ children }) => <div className="overflow-x-scroll text-sm">{children}</div>,
}}
>
{message.content}
</ReactMarkdown>
</div>
</div>
</div>
)
}
export default AssistantMessage

View file

@ -0,0 +1,53 @@
import React from 'react'
import ReactMarkdown from 'react-markdown'
import remarkGfm from 'remark-gfm'
import rehypeHighlight from 'rehype-highlight'
import { type Message } from '../../types'
import ToolCallMessage from './ToolCallMessage.tsx'
import ToolResultMessage from './ToolResultMessage.tsx'
import AssistantMessage from './AssistantMessage.tsx'
import ReasoningMessage from './ReasoningMessage.tsx'
interface ChatMessageProps {
message: Message
}
const ChatMessage: React.FC<ChatMessageProps> = ({ message }) => {
// Handle tool calls and results differently
if (message.role === 'tool-call') {
return <ToolCallMessage message={message} />
}
if (message.role === 'tool-result') {
return <ToolResultMessage message={message} />
}
if (message.role === 'assistant') {
if (message.type === 'reasoning') {
return <ReasoningMessage message={message} />
} else {
return <AssistantMessage message={message} />
}
}
// Handle regular messages (user, assistant, system)
return (
<div className={`flex justify-end`}>
<div className={`max-w-[80%] rounded-2xl px-3 py-2 shadow bg-white text-black`}>
<div className="prose prose-zinc">
<ReactMarkdown
remarkPlugins={[remarkGfm]}
rehypePlugins={[rehypeHighlight]}
components={{
table: ({ children }) => <div className="overflow-x-scroll text-sm">{children}</div>,
}}
>
{message.content}
</ReactMarkdown>
</div>
</div>
</div>
)
}
export default ChatMessage

View file

@ -0,0 +1,82 @@
import React, { useState, useEffect } from 'react'
interface ReasoningBlockProps {
reasoning: string
isStreaming?: boolean
startTime?: number
endTime?: number
}
const ReasoningBlock: React.FC<ReasoningBlockProps> = ({ reasoning, isStreaming = false, startTime, endTime }) => {
const [isExpanded, setIsExpanded] = useState(isStreaming) // Start expanded when streaming
// Auto-collapse instantly when streaming finishes
useEffect(() => {
if (!isStreaming && startTime && endTime) {
setIsExpanded(false)
}
}, [isStreaming, startTime, endTime])
if (!reasoning || reasoning.trim().length === 0) {
return null
}
const toggleExpanded = () => {
setIsExpanded(!isExpanded)
}
// Calculate thinking duration
const duration = startTime && endTime ? (endTime - startTime) / 1000 : null
// Format duration nicely
const formatDuration = (seconds: number) => {
if (seconds < 1) {
return `${Math.round(seconds * 1000)}ms`
}
return `${seconds.toFixed(1)}s`
}
return (
<div className="mb-3">
<div
className={`text-sm text-zinc-600 border border-zinc-200 rounded-lg p-3 bg-zinc-50 cursor-pointer hover:bg-zinc-100 transition-all duration-300 ${
isExpanded ? 'border-zinc-300' : ''
}`}
onClick={toggleExpanded}
>
<div className="flex items-start gap-2">
<span className="text-zinc-400 text-xs mt-0.5 flex-shrink-0">💭</span>
{isExpanded ? (
// Expanded view: show reasoning content
<div className={`flex-1 ${isStreaming ? 'overflow-hidden whitespace-nowrap flex justify-end' : 'whitespace-pre-wrap'}`}>
<span className={isStreaming ? 'inline-block' : ''}>
{reasoning}
{isStreaming && <span className="inline-block w-2 h-4 bg-zinc-400 ml-1 animate-pulse"></span>}
</span>
</div>
) : (
// Collapsed view: show timing summary
<div className="flex-1">
<span className="text-zinc-500">
{isStreaming ? 'Thinking...' : duration ? `Thought for ${formatDuration(duration)}` : 'Thought process'}
</span>
</div>
)}
<button
className="text-zinc-400 hover:text-zinc-600 text-xs ml-auto flex-shrink-0"
onClick={(e) => {
e.stopPropagation()
toggleExpanded()
}}
>
{isExpanded ? '↑' : '↓'}
</button>
</div>
</div>
</div>
)
}
export default ReasoningBlock

View file

@ -0,0 +1,25 @@
import React from 'react'
import { type ReasoningMessage } from '../../types'
import ReasoningBlock from './ReasoningBlock.tsx'
interface ReasoningMessageProps {
message: ReasoningMessage
}
const ReasoningMessage: React.FC<ReasoningMessageProps> = ({ message }) => {
console.log({ ReasoningMessage: message })
return (
<div className={`flex justify-start`}>
<div className={`text-zinc-900 w-full`}>
<ReasoningBlock
reasoning={message.content}
isStreaming={message.isReasoningStreaming}
startTime={message.reasoningStartTime}
endTime={message.reasoningEndTime}
/>
</div>
</div>
)
}
export default ReasoningMessage

View file

@ -0,0 +1,47 @@
import { useState } from 'react'
import { ChevronDown, ChevronRight, Wrench } from 'lucide-react'
import { type ToolCallMessage } from '../../types'
interface ToolCallMessageProps {
message: ToolCallMessage
}
const ToolCallMessage: React.FC<ToolCallMessageProps> = ({ message }) => {
const [expanded, setExpanded] = useState(false)
const argsPreview = JSON.stringify(message.toolArgs).substring(0, 100)
const shouldTruncate = JSON.stringify(message.toolArgs).length > 100
return (
<div className="flex gap-3 py-3 px-4 bg-blue-50 border border-blue-200 rounded-lg">
<div className="flex-shrink-0 mt-1">
<Wrench size={16} className="text-blue-600" />
</div>
<div className="flex-grow min-w-0">
<div className="flex items-center gap-2 mb-1">
<span className="font-medium text-blue-800 text-sm">Tool Call</span>
<span className="text-blue-600 text-sm font-mono bg-blue-100 px-2 py-0.5 rounded">{message.toolName}</span>
</div>
<div
className={`text-sm text-blue-700 font-mono bg-blue-100 p-2 rounded ${shouldTruncate ? 'cursor-pointer hover:bg-blue-200' : ''}`}
onClick={() => shouldTruncate && setExpanded(!expanded)}
>
<div className="flex items-start justify-between">
<span className={expanded ? '' : 'truncate'}>
{expanded ? JSON.stringify(message.toolArgs, null, 2) : `${argsPreview}${shouldTruncate ? '...' : ''}`}
</span>
{shouldTruncate && (
<button className="ml-2 flex-shrink-0">{expanded ? <ChevronDown size={14} /> : <ChevronRight size={14} />}</button>
)}
</div>
{expanded && shouldTruncate && (
<pre className="mt-2 whitespace-pre-wrap break-words max-h-64 overflow-y-auto">{JSON.stringify(message.toolArgs, null, 2)}</pre>
)}
</div>
</div>
</div>
)
}
export default ToolCallMessage

View file

@ -0,0 +1,49 @@
import { useState } from 'react'
import { ChevronDown, ChevronRight, CheckCircle } from 'lucide-react'
import { type ToolResultMessage } from '../../types'
interface ToolResultMessageProps {
message: ToolResultMessage
}
const ToolResultMessage: React.FC<ToolResultMessageProps> = ({ message }) => {
const [expanded, setExpanded] = useState(false)
const resultPreview = JSON.stringify(message.toolResult).substring(0, 100)
const shouldTruncate = JSON.stringify(message.toolResult).length > 100
return (
<div className="flex gap-3 py-3 px-4 bg-green-50 border border-green-200 rounded-lg">
<div className="flex-shrink-0 mt-1">
<CheckCircle size={16} className="text-green-600" />
</div>
<div className="flex-grow min-w-0">
<div className="flex items-center gap-2 mb-1">
<span className="font-medium text-green-800 text-sm">Tool Result</span>
<span className="text-green-600 text-sm font-mono bg-green-100 px-2 py-0.5 rounded">{message.toolName}</span>
</div>
<div
className={`text-sm text-green-700 font-mono bg-green-100 p-2 rounded ${shouldTruncate ? 'cursor-pointer hover:bg-green-200' : ''}`}
onClick={() => shouldTruncate && setExpanded(!expanded)}
>
<div className="flex items-start justify-between">
<span className={expanded ? '' : 'truncate'}>
{expanded ? JSON.stringify(message.toolResult, null, 2) : `${resultPreview}${shouldTruncate ? '...' : ''}`}
</span>
{shouldTruncate && (
<button className="ml-2 flex-shrink-0">{expanded ? <ChevronDown size={14} /> : <ChevronRight size={14} />}</button>
)}
</div>
{expanded && shouldTruncate && (
<pre className="mt-2 whitespace-pre-wrap break-words max-h-64 overflow-y-auto">
{JSON.stringify(message.toolResult, null, 2)}
</pre>
)}
</div>
</div>
</div>
)
}
export default ToolResultMessage

View file

@ -113,9 +113,6 @@ export const useStreamResponse = ({
} }
const streamResponse = async (messages: Message[]) => { const streamResponse = async (messages: Message[]) => {
let aiResponse = ''
let currentReasoning = ''
// Check if API key is available // Check if API key is available
let apiKey = getApiKey(selectedModel.provider.id) let apiKey = getApiKey(selectedModel.provider.id)
if (!apiKey) { if (!apiKey) {
@ -138,7 +135,7 @@ export const useStreamResponse = ({
const aiTools = convertMcpToolsToAiTools(mcpTools) const aiTools = convertMcpToolsToAiTools(mcpTools)
// Prepare stream options // Prepare stream options
const streamOptions: any = { const streamOptions = {
model: modelInstance, model: modelInstance,
messages: messages messages: messages
.filter((msg) => ['user', 'assistant', 'system'].includes(msg.role) && hasContent(msg)) .filter((msg) => ['user', 'assistant', 'system'].includes(msg.role) && hasContent(msg))
@ -198,155 +195,127 @@ export const useStreamResponse = ({
} }
if (event.type === 'tool-call') { if (event.type === 'tool-call') {
// End reasoning phase immediately when we see a tool call for linear flow
if (currentReasoningStartTime && !currentReasoningEndTime) {
currentReasoningEndTime = Date.now()
// Update reasoning end time and stop streaming immediately
setConversations((prev) => {
const updated = [...prev]
const conv = updated.find((c) => c.id === conversationId)
if (conv && assistantMessageIndex >= 0) {
const assistantMessage = conv.messages[assistantMessageIndex]
if (assistantMessage && hasContent(assistantMessage) && assistantMessage.role === 'assistant') {
assistantMessage.reasoningEndTime = currentReasoningEndTime
assistantMessage.isReasoningStreaming = false
}
}
return updated
})
// Reset reasoning state for potential new reasoning session
currentReasoningStartTime = undefined
currentReasoningEndTime = undefined
assistantMessageCreated = false
}
if (event.toolName) { if (event.toolName) {
setConversations((prev) => { conv.messages.push({
const updated = [...prev] role: 'tool-call',
const conv = updated.find((c) => c.id === conversationId) toolName: event.toolName,
if (conv) { toolArgs: event.args || {},
conv.messages.push({ callId: event.toolCallId || 'unknown',
role: 'tool-call',
toolName: event.toolName,
toolArgs: event.args || {},
callId: event.toolCallId || 'unknown',
})
debugMessages('Added new tool-call message:', event.toolName, 'callId:', event.toolCallId)
debugMessages('Current messages:', JSON.stringify(conv.messages))
}
return updated
}) })
debugMessages('Added new tool-call message:', event.toolName, 'callId:', event.toolCallId)
debugMessages('Current messages:', JSON.stringify(conv.messages))
scrollToBottom(true) scrollToBottom(true)
} else { } else {
console.warn('Tool call event missing toolName:', event) console.warn('Tool call event missing toolName:', event)
} }
} else if ((event as any).type === 'tool-result') { } else if (event.type === 'tool-result') {
if ((event as any).toolName && (event as any).toolCallId) { console.info(`TODO TOOL RESULT`, event)
setConversations((prev) => { // if (event.toolName && event.toolCallId) {
const updated = [...prev] // setConversations((prev) => {
const conv = updated.find((c) => c.id === conversationId) // const updated = [...prev]
if (conv) { // const conv = updated.find((c) => c.id === conversationId)
conv.messages.push({ // if (conv) {
role: 'tool-result', // conv.messages.push({
toolName: (event as any).toolName, // role: 'tool-result',
toolArgs: (event as any).args || {}, // toolName: event.toolName,
toolResult: (event as any).result, // toolArgs: event.args || {},
callId: (event as any).toolCallId, // toolResult: event.result,
}) // callId: event.toolCallId,
debugMessages('Added new tool-result message:', (event as any).toolName, 'callId:', (event as any).toolCallId) // })
debugMessages('Current messages:', JSON.stringify(conv.messages)) // debugMessages('Added new tool-result message:', event.toolName, 'callId:', event.toolCallId)
} // debugMessages('Current messages:', JSON.stringify(conv.messages))
return updated // }
}) // return updated
scrollToBottom(true) // })
} else { // scrollToBottom(true)
console.warn('Tool result event missing toolName or toolCallId:', event) // } else {
} // console.warn('Tool result event missing toolName or toolCallId:', event)
// }
} else if (event.type === 'text-delta') { } else if (event.type === 'text-delta') {
// Check if we have an existing reasoning message that needs to be finalized console.info(`TODO TEXT DELTA`, event)
let needsNewAssistantMessage = false
if (currentReasoningStartTime && !currentReasoningEndTime) {
currentReasoningEndTime = Date.now()
// Update reasoning end time and stop streaming // // Check if we have an existing reasoning message that needs to be finalized
setConversations((prev) => { // let needsNewAssistantMessage = false
const updated = [...prev] // if (currentReasoningStartTime && !currentReasoningEndTime) {
const conv = updated.find((c) => c.id === conversationId) // currentReasoningEndTime = Date.now()
if (conv && assistantMessageIndex >= 0) { //
const assistantMessage = conv.messages[assistantMessageIndex] // // Update reasoning end time and stop streaming
if (assistantMessage && hasContent(assistantMessage) && assistantMessage.role === 'assistant') { // setConversations((prev) => {
assistantMessage.isReasoningStreaming = false // const updated = [...prev]
assistantMessage.reasoningEndTime = currentReasoningEndTime // const conv = updated.find((c) => c.id === conversationId)
} // if (conv && assistantMessageIndex >= 0) {
} // const assistantMessage = conv.messages[assistantMessageIndex]
return updated // if (assistantMessage && hasContent(assistantMessage) && assistantMessage.role === 'assistant') {
}) // assistantMessage.isReasoningStreaming = false
// assistantMessage.reasoningEndTime = currentReasoningEndTime
// Reset reasoning state after reasoning ends // }
currentReasoningStartTime = undefined // }
currentReasoningEndTime = undefined // return updated
// Force creation of new assistant message for content // })
needsNewAssistantMessage = true //
assistantMessageCreated = false // // Reset reasoning state after reasoning ends
} // currentReasoningStartTime = undefined
// currentReasoningEndTime = undefined
// Create assistant message on first text delta if not already created OR if we just finished reasoning // // Force creation of new assistant message for content
if (!assistantMessageCreated || needsNewAssistantMessage) { // needsNewAssistantMessage = true
setConversations((prev) => { // assistantMessageCreated = false
const updated = [...prev] // }
const conv = updated.find((c) => c.id === conversationId) //
if (conv) { // // Create assistant message on first text delta if not already created OR if we just finished reasoning
conv.messages.push({ role: 'assistant', content: '' }) // if (!assistantMessageCreated || needsNewAssistantMessage) {
assistantMessageIndex = conv.messages.length - 1 // setConversations((prev) => {
debugMessages( // const updated = [...prev]
'Added new content assistant message at index', // const conv = updated.find((c) => c.id === conversationId)
assistantMessageIndex, // if (conv) {
'(after reasoning:', // conv.messages.push({ role: 'assistant', content: '' })
needsNewAssistantMessage, // assistantMessageIndex = conv.messages.length - 1
')' // debugMessages(
) // 'Added new content assistant message at index',
debugMessages('Current messages:', JSON.stringify(conv.messages)) // assistantMessageIndex,
} // '(after reasoning:',
return updated // needsNewAssistantMessage,
}) // ')'
assistantMessageCreated = true // )
} // debugMessages('Current messages:', JSON.stringify(conv.messages))
// }
aiResponse += event.textDelta // return updated
aiResponseRef.current = aiResponse // })
// assistantMessageCreated = true
//custom extraction of <chat-title> tag // }
const titleMatch = aiResponse.match(/<chat-title>(.*?)<\/chat-title>/) //
if (titleMatch) { // aiResponse += event.textDelta
const title = titleMatch[1].trim() // aiResponseRef.current = aiResponse
setConversations((prev) => { //
const updated = [...prev] // //custom extraction of <chat-title> tag
const conv = updated.find((c) => c.id === conversationId) // const titleMatch = aiResponse.match(/<chat-title>(.*?)<\/chat-title>/)
if (conv) { // if (titleMatch) {
conv.title = title // const title = titleMatch[1].trim()
} // setConversations((prev) => {
return updated // const updated = [...prev]
}) // const conv = updated.find((c) => c.id === conversationId)
aiResponse = aiResponse.replace(/<chat-title>.*?<\/chat-title>/, '').trim() // if (conv) {
} // conv.title = title
// }
setConversations((prev) => { // return updated
const updated = [...prev] // })
const conv = updated.find((c) => c.id === conversationId) // aiResponse = aiResponse.replace(/<chat-title>.*?<\/chat-title>/, '').trim()
if (conv) { // }
// Update the specific assistant message we created, not just the last message //
const assistantMessage = conv.messages[assistantMessageIndex] // setConversations((prev) => {
if (assistantMessage && hasContent(assistantMessage) && assistantMessage.role === 'assistant') { // const updated = [...prev]
assistantMessage.content = aiResponse // const conv = updated.find((c) => c.id === conversationId)
} // if (conv) {
} else { // // Update the specific assistant message we created, not just the last message
} // const assistantMessage = conv.messages[assistantMessageIndex]
return updated // if (assistantMessage && hasContent(assistantMessage) && assistantMessage.role === 'assistant') {
}) // assistantMessage.content = aiResponse
// }
scrollToBottom(true) // } else {
// }
// return updated
// })
//
// scrollToBottom(true)
} }
} catch (e) { } catch (e) {
console.error('Error in full stream processing:', e) console.error('Error in full stream processing:', e)
@ -355,8 +324,6 @@ export const useStreamResponse = ({
}) })
} }
debugMessages('Stream processing completed. Final message count:', assistantMessageCreated ? 'created' : 'none')
// Show final conversation state // Show final conversation state
setConversations((prev) => { setConversations((prev) => {
const conv = prev.find((c) => c.id === conversationId) const conv = prev.find((c) => c.id === conversationId)
@ -365,48 +332,36 @@ export const useStreamResponse = ({
} }
return prev return prev
}) })
//
// Final cleanup - ensure reasoning streaming is stopped // // Final cleanup - ensure reasoning streaming is stopped
if (assistantMessageCreated && currentReasoningStartTime) { // if (assistantMessageCreated && currentReasoningStartTime) {
if (!currentReasoningEndTime) { // if (!currentReasoningEndTime) {
currentReasoningEndTime = Date.now() // currentReasoningEndTime = Date.now()
} // }
//
setConversations((prev) => { // setConversations((prev) => {
const updated = [...prev] // const updated = [...prev]
const conv = updated.find((c) => c.id === conversationId) // const conv = updated.find((c) => c.id === conversationId)
if (conv && assistantMessageIndex >= 0) { // if (conv && assistantMessageIndex >= 0) {
const assistantMessage = conv.messages[assistantMessageIndex] // const assistantMessage = conv.messages[assistantMessageIndex]
if (assistantMessage && hasContent(assistantMessage) && assistantMessage.role === 'assistant') { // if (assistantMessage && hasContent(assistantMessage) && assistantMessage.role === 'assistant') {
assistantMessage.isReasoningStreaming = false // assistantMessage.isReasoningStreaming = false
assistantMessage.reasoningEndTime = currentReasoningEndTime // assistantMessage.reasoningEndTime = currentReasoningEndTime
} // }
} // }
return updated // return updated
}) // })
} // }
} catch (error: unknown) { } catch (error: unknown) {
if (controller.signal.aborted) { if (controller.signal.aborted) {
} else { } else {
console.error('Error generating response:', error) console.error('Error generating response:', error)
// Remove the assistant message if there was an error and we created one
if (assistantMessageCreated) {
setConversations((prev) => {
const updated = [...prev]
const conv = updated.find((c) => c.id === conversationId)
if (conv && assistantMessageIndex >= 0 && conv.messages[assistantMessageIndex]?.role === 'assistant') {
conv.messages.splice(assistantMessageIndex, 1)
}
return updated
})
}
} }
} finally { } finally {
setStreamStarted(false) setStreamStarted(false)
setController(new AbortController()) setController(new AbortController())
debugMessages('Stream response function completed') debugMessages('Stream response function completed')
} }
return aiResponse
} }
return { return {

View file

@ -15,7 +15,7 @@ export interface AssistantMessage extends BaseMessage {
type: 'content' type: 'content'
} }
export interface AssistantReasoningMessage extends BaseMessage { export interface ReasoningMessage extends BaseMessage {
role: 'assistant' role: 'assistant'
type: 'reasoning' type: 'reasoning'
reasoningStartTime: number reasoningStartTime: number
@ -38,7 +38,7 @@ export interface ToolResultMessage {
callId: string callId: string
} }
export type Message = UserMessage | SystemMessage | AssistantMessage | AssistantReasoningMessage | ToolCallMessage | ToolResultMessage export type Message = UserMessage | SystemMessage | AssistantMessage | ReasoningMessage | ToolCallMessage | ToolResultMessage
export interface Conversation { export interface Conversation {
id?: number id?: number