@huyooo/ai-chat-frontend-react 0.1.4 → 0.1.8

package/src/hooks/useChat.ts

@@ -1,259 +1,766 @@
 /**
  * useChat Hook
  * 管理聊天状态和与后端的通信
- * 使用 Adapter 模式解耦后端通信
  * 
- * 与 Vue 版本 useChat composable 保持一致
+ * 新架构：
+ * - 使用 Map 存储每个会话的独立状态
+ * - 多会话可同时进行，互不干扰
+ * - 切换 tab 不会停止正在进行的请求
+ * - ContentPart 数组存储消息内容，支持流式渲染和自定义 UI
  */
 
-import { useState, useCallback, useRef } from 'react'
+import { useState, useCallback, useRef, useMemo, useEffect } from 'react'
 import type {
   ChatAdapter,
-  ChatProgress,
+  ChatEvent,
   ChatMode,
   SessionRecord,
   MessageRecord,
+  AutoRunConfig,
 } from '@huyooo/ai-chat-bridge-electron/renderer'
-import { createNullAdapter } from '../adapter'
-import type { ChatMessage, SearchResult, ToolCall } from '../types'
+import type { 
+  ChatMessage,
+  ContentPart,
+  TextPart,
+  ThinkingPart,
+  SearchPart,
+  ToolCallPart,
+  ToolResultPart,
+  ErrorPart,
+  SearchResult,
+} from '../types'
 
 /** 生成唯一 ID */
 function generateId(): string {
   return Date.now().toString(36) + Math.random().toString(36).substr(2)
 }
 
+/** 获取消息的纯文本内容 */
+function extractTextContent(parts: ContentPart[]): string {
+  return parts
+    .filter((p): p is TextPart => p.type === 'text')
+    .map(p => p.text)
+    .join('')
+}
+
+/** 解析工具调用结果 */
+function parseToolResult(result: unknown): unknown | null {
+  if (result === undefined || result === null) return null
+  if (typeof result === 'string') {
+    try {
+      return JSON.parse(result)
+    } catch {
+      return result
+    }
+  }
+  return result
+}
+
 /** 转换存储的消息为显示格式 */
 function convertToMessage(record: MessageRecord): ChatMessage {
+  let parts: ContentPart[] = []
+  
+  if (record.steps) {
+    try {
+      const steps = JSON.parse(record.steps)
+      for (const step of steps) {
+        if (step.type === 'thinking') {
+          parts.push({
+            type: 'thinking',
+            text: step.text || '',
+            status: step.status || 'done',
+            duration: step.duration,
+          })
+        } else if (step.type === 'search') {
+          parts.push({
+            type: 'search',
+            query: step.query,
+            results: step.results,
+            status: step.status || 'done',
+          })
+        } else if (step.type === 'tool_call') {
+          parts.push({
+            type: 'tool_call',
+            id: step.id,
+            name: step.name,
+            args: step.args,
+            result: parseToolResult(step.result),
+            status: step.status || 'done',
+          })
+        } else if (step.type === 'text') {
+          parts.push({
+            type: 'text',
+            text: step.text || '',
+          })
+        } else if (step.type === 'error') {
+          parts.push({
+            type: 'error',
+            message: step.message || '',
+            category: step.category,
+          })
+        }
+      }
+    } catch {
+      // 解析失败，忽略 steps
+    }
+  }
+  
+  if (record.content && !parts.some(p => p.type === 'text')) {
+    parts.push({ type: 'text', text: record.content })
+  }
+  
+  if (parts.length === 0) {
+    parts.push({ type: 'text', text: '' })
+  }
+
   return {
     id: record.id,
     role: record.role,
-    content: record.content,
-    thinking: record.thinking || undefined,
-    thinkingComplete: true,
-    toolCalls: record.toolCalls ? JSON.parse(record.toolCalls) : undefined,
-    searchResults: record.searchResults ? JSON.parse(record.searchResults) : undefined,
-    searching: false,
+    parts,
+    model: record.model || undefined,
+    mode: record.mode || undefined,
+    webSearchEnabled: record.webSearchEnabled ?? undefined,
+    thinkingEnabled: record.thinkingEnabled ?? undefined,
+    loading: false,
     timestamp: record.timestamp,
   }
 }
 
+/** 会话状态 */
+interface SessionState {
+  messages: ChatMessage[]
+  isLoading: boolean
+  abortController: AbortController | null
+}
+
+/** 副作用定义 */
+export interface SideEffect {
+  type: string
+  success: boolean
+  data?: unknown
+  message?: string
+}
+
+/** 工具完成事件数据 */
+export interface ToolCompleteEvent {
+  name: string
+  result: unknown
+  /** 
+   * 工具声明的副作用列表
+   * 前端可根据此字段处理通知、刷新文件列表等
+   */
+  sideEffects?: SideEffect[]
+}
+
 export interface UseChatOptions {
-  /** Adapter 实例 */
-  adapter?: ChatAdapter
-  /** 默认模型 */
+  adapter: ChatAdapter
   defaultModel?: string
-  /** 默认模式 */
   defaultMode?: ChatMode
+  onToolComplete?: (event: ToolCompleteEvent) => void
+  autoRunConfig?: AutoRunConfig
 }
 
 /**
  * 聊天状态管理 Hook
+ * 
+ * 核心架构：
+ * - sessionStatesRef: Map<sessionId, SessionState> 存储每个会话的独立状态
+ * - 多会话可同时进行请求，互不干扰
+ * - 切换 tab 不会停止任何正在进行的请求
  */
-export function useChat(options: UseChatOptions = {}) {
+export function useChat(options: UseChatOptions) {
   const {
-    adapter = createNullAdapter(),
+    adapter,
     defaultModel = 'anthropic/claude-opus-4.5',
     defaultMode = 'agent',
+    onToolComplete,
+    // autoRunConfig 现在从数据库读取，不再从 props 传入
   } = options
 
-  // 会话状态
+  // ==================== 会话状态存储 ====================
+  const sessionStatesRef = useRef(new Map<string, SessionState>())
+  const [stateVersion, setStateVersion] = useState(0)
+
+  // ==================== 自动运行配置（从数据库读取） ====================
+  // 默认配置
+  const DEFAULT_AUTO_RUN_CONFIG: AutoRunConfig = {
+    mode: 'run-everything',
+  }
+
+  const [autoRunConfig, setAutoRunConfig] = useState<AutoRunConfig>(DEFAULT_AUTO_RUN_CONFIG)
+  const autoRunConfigRef = useRef(autoRunConfig)
+  autoRunConfigRef.current = autoRunConfig
+
+  /** 从数据库加载自动运行配置 */
+  const loadAutoRunConfig = useCallback(async () => {
+    if (!adapter.getAllSettings) return
+    
+    try {
+      const settings = await adapter.getAllSettings()
+      const configJson = settings['autoRunConfig']
+      
+      if (configJson) {
+        const config = JSON.parse(configJson) as AutoRunConfig
+        // 合并配置，确保新增字段有默认值
+        setAutoRunConfig({ ...DEFAULT_AUTO_RUN_CONFIG, ...config })
+      }
+    } catch (error) {
+      console.error('[useChat] 加载 autoRunConfig 失败:', error)
+    }
+  }, [adapter])
+
+  /** 保存自动运行配置到数据库 */
+  const saveAutoRunConfig = useCallback(async (config: AutoRunConfig) => {
+    if (!adapter.setSetting) return
+    
+    try {
+      await adapter.setSetting('autoRunConfig', JSON.stringify(config))
+      setAutoRunConfig(config)
+    } catch (error) {
+      console.error('[useChat] 保存 autoRunConfig 失败:', error)
+      throw error
+    }
+  }, [adapter])
+
+  // 初始化时加载配置
+  useEffect(() => {
+    loadAutoRunConfig()
+  }, [loadAutoRunConfig])
+
+  // 强制重新渲染
+  const forceUpdate = useCallback(() => setStateVersion(v => v + 1), [])
+
+  // 获取或创建会话状态
+  const getSessionState = useCallback((sessionId: string): SessionState => {
+    if (!sessionStatesRef.current.has(sessionId)) {
+      sessionStatesRef.current.set(sessionId, {
+        messages: [],
+        isLoading: false,
+        abortController: null,
+      })
+    }
+    return sessionStatesRef.current.get(sessionId)!
+  }, [])
+
+  // ==================== 全局状态 ====================
   const [sessions, setSessions] = useState<SessionRecord[]>([])
   const [currentSessionId, setCurrentSessionId] = useState<string | null>(null)
-  const [messages, setMessages] = useState<ChatMessage[]>([])
+  const currentSessionIdRef = useRef<string | null>(null)
+  
+  // 同步 ref
+  currentSessionIdRef.current = currentSessionId
 
   // 配置状态
-  const [mode, setModeState] = useState<ChatMode>(defaultMode)
-  const [model, setModelState] = useState(defaultModel)
-  const [webSearch, setWebSearchState] = useState(true)
-  const [thinking, setThinkingState] = useState(true)
-
-  // 加载状态
-  const [isLoading, setIsLoading] = useState(false)
+  const [modeState, setModeState] = useState<ChatMode>(defaultMode)
+  const [modelState, setModelState] = useState(defaultModel)
+  const [webSearchState, setWebSearchState] = useState(true)
+  const [thinkingState, setThinkingState] = useState(true)
 
-  // 取消控制器
-  const abortControllerRef = useRef<AbortController | null>(null)
-
-  // 用于在回调中访问最新状态
+  // refs for async access
+  const modeRef = useRef(modeState)
+  const modelRef = useRef(modelState)
+  const webSearchRef = useRef(webSearchState)
+  const thinkingRef = useRef(thinkingState)
   const sessionsRef = useRef(sessions)
-  const messagesRef = useRef(messages)
-  const currentSessionIdRef = useRef(currentSessionId)
-  const modeRef = useRef(mode)
-  const modelRef = useRef(model)
-  const webSearchRef = useRef(webSearch)
-  const thinkingRef = useRef(thinking)
 
-  // 同步 ref
+  modeRef.current = modeState
+  modelRef.current = modelState
+  webSearchRef.current = webSearchState
+  thinkingRef.current = thinkingState
   sessionsRef.current = sessions
-  messagesRef.current = messages
-  currentSessionIdRef.current = currentSessionId
-  modeRef.current = mode
-  modelRef.current = model
-  webSearchRef.current = webSearch
-  thinkingRef.current = thinking
 
-  /** 加载会话列表 */
+  // ==================== 计算属性 ====================
+  const messages = useMemo(() => {
+    // 触发 stateVersion 依赖
+    void stateVersion
+    if (!currentSessionId) return []
+    const state = sessionStatesRef.current.get(currentSessionId)
+    return state?.messages || []
+  }, [currentSessionId, stateVersion])
+
+  const isLoading = useMemo(() => {
+    void stateVersion
+    if (!currentSessionId) return false
+    const state = sessionStatesRef.current.get(currentSessionId)
+    return state?.isLoading || false
+  }, [currentSessionId, stateVersion])
+
+  // ==================== 会话管理 ====================
   const loadSessions = useCallback(async () => {
     try {
       const list = await adapter.getSessions()
       setSessions(list)
-      // 如果有会话且没有当前会话，选择最新的
       if (list.length > 0 && !currentSessionIdRef.current) {
-        const firstSession = list[0]
-        setCurrentSessionId(firstSession.id)
-        const savedMessages = await adapter.getMessages(firstSession.id)
-        setMessages(savedMessages.map(convertToMessage))
-        setModeState(firstSession.mode)
-        setModelState(firstSession.model)
+        setCurrentSessionId(list[0].id)
+        // 加载消息
+        const state = getSessionState(list[0].id)
+        if (state.messages.length === 0) {
+          const savedMessages = await adapter.getMessages(list[0].id)
+          state.messages = savedMessages.map(convertToMessage)
+          forceUpdate()
+        }
+        // 同步配置
+        setModeState(list[0].mode)
+        setModelState(list[0].model)
+        setWebSearchState(list[0].webSearchEnabled)
+        setThinkingState(list[0].thinkingEnabled)
       }
     } catch (error) {
       console.error('加载会话失败:', error)
     }
-  }, [adapter])
+  }, [adapter, getSessionState, forceUpdate])
 
-  /** 切换会话 */
   const switchSession = useCallback(async (sessionId: string) => {
     if (currentSessionIdRef.current === sessionId) return
 
     setCurrentSessionId(sessionId)
+    
+    // 无状态架构：不需要同步历史到后端
+    // 发送消息时会传递历史，后端不维护状态
 
-    try {
-      const savedMessages = await adapter.getMessages(sessionId)
-      setMessages(savedMessages.map(convertToMessage))
-
-      // 更新配置
-      const session = sessionsRef.current.find((s) => s.id === sessionId)
-      if (session) {
-        setModeState(session.mode)
-        setModelState(session.model)
+    const state = getSessionState(sessionId)
+
+    if (state.messages.length === 0) {
+      try {
+        const savedMessages = await adapter.getMessages(sessionId)
+        state.messages = savedMessages.map(convertToMessage)
+        forceUpdate()
+      } catch (error) {
+        console.error('加载消息失败:', error)
+        state.messages = []
+        forceUpdate()
       }
-    } catch (error) {
-      console.error('加载消息失败:', error)
-      setMessages([])
     }
-  }, [adapter])
 
-  /** 创建新会话 */
+    const session = sessionsRef.current.find((s) => s.id === sessionId)
+    if (session) {
+      setModeState(session.mode)
+      setModelState(session.model)
+      setWebSearchState(session.webSearchEnabled)
+      setThinkingState(session.thinkingEnabled)
+    }
+  }, [adapter, getSessionState, forceUpdate])
+
   const createNewSession = useCallback(async () => {
     try {
       const session = await adapter.createSession({
         title: '新对话',
         model: modelRef.current,
         mode: modeRef.current,
+        webSearchEnabled: webSearchRef.current,
+        thinkingEnabled: thinkingRef.current,
       })
       setSessions(prev => [session, ...prev])
+      
+      sessionStatesRef.current.set(session.id, {
+        messages: [],
+        isLoading: false,
+        abortController: null,
+      })
+      
       setCurrentSessionId(session.id)
-      setMessages([])
+      forceUpdate()
     } catch (error) {
       console.error('创建会话失败:', error)
     }
-  }, [adapter])
+  }, [adapter, forceUpdate])
 
-  /** 删除会话 */
   const deleteSession = useCallback(async (sessionId: string) => {
     try {
+      const state = sessionStatesRef.current.get(sessionId)
+      if (state?.isLoading && state.abortController) {
+        state.abortController.abort()
+        adapter.cancel()
+      }
+      
       await adapter.deleteSession(sessionId)
       setSessions(prev => prev.filter((s) => s.id !== sessionId))
+      sessionStatesRef.current.delete(sessionId)
 
-      // 如果删除的是当前会话，切换到下一个
       if (currentSessionIdRef.current === sessionId) {
-        const remaining = sessionsRef.current.filter((s) => s.id !== sessionId)
-        if (remaining.length > 0) {
-          await switchSession(remaining[0].id)
+        const remainingSessions = sessionsRef.current.filter(s => s.id !== sessionId)
+        if (remainingSessions.length > 0) {
+          setCurrentSessionId(remainingSessions[0].id)
         } else {
           setCurrentSessionId(null)
-          setMessages([])
         }
       }
+      forceUpdate()
     } catch (error) {
       console.error('删除会话失败:', error)
     }
-  }, [adapter, switchSession])
+  }, [adapter, forceUpdate])
+
+  const hideSession = useCallback(async (sessionId: string, hidden: boolean) => {
+    try {
+      await adapter.updateSession(sessionId, { hidden })
+      setSessions(prev => prev.map((s) =>
+        s.id === sessionId ? { ...s, hidden } : s
+      ))
+    } catch (error) {
+      console.error('更新会话隐藏状态失败:', error)
+    }
+  }, [adapter])
+
+  const clearAllSessions = useCallback(async () => {
+    try {
+      for (const [, state] of sessionStatesRef.current) {
+        if (state.isLoading && state.abortController) {
+          state.abortController.abort()
+        }
+      }
+      adapter.cancel()
+      
+      for (const session of sessionsRef.current) {
+        await adapter.deleteSession(session.id)
+      }
+      setSessions([])
+      sessionStatesRef.current.clear()
+      await createNewSession()
+    } catch (error) {
+      console.error('清空所有会话失败:', error)
+    }
+  }, [adapter, createNewSession])
+
+  const hideOtherSessions = useCallback(async () => {
+    if (!currentSessionIdRef.current) return
+    try {
+      for (const session of sessionsRef.current) {
+        if (session.id !== currentSessionIdRef.current && !session.hidden) {
+          await adapter.updateSession(session.id, { hidden: true })
+        }
+      }
+      setSessions(prev => prev.map((s) =>
+        s.id === currentSessionIdRef.current ? s : { ...s, hidden: true }
+      ))
+    } catch (error) {
+      console.error('隐藏其他会话失败:', error)
+    }
+  }, [adapter])
+
+  const exportCurrentSession = useCallback((): string | null => {
+    if (!currentSessionIdRef.current) return null
+    const session = sessionsRef.current.find((s) => s.id === currentSessionIdRef.current)
+    if (!session) return null
+
+    const state = sessionStatesRef.current.get(currentSessionIdRef.current)
+    const msgs = state?.messages || []
+
+    return JSON.stringify({
+      session: {
+        id: session.id,
+        title: session.title,
+        model: session.model,
+        mode: session.mode,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+      },
+      messages: msgs.map((msg) => ({
+        id: msg.id,
+        role: msg.role,
+        parts: msg.parts,
+        model: msg.model,
+        mode: msg.mode,
+        timestamp: msg.timestamp,
+      })),
+      exportedAt: new Date().toISOString(),
+    }, null, 2)
+  }, [])
 
-  /** 删除当前会话 */
   const deleteCurrentSession = useCallback(async () => {
     if (currentSessionIdRef.current) {
       await deleteSession(currentSessionIdRef.current)
     }
   }, [deleteSession])
 
-  /** 更新消息 */
-  const updateMessage = useCallback((index: number, progress: ChatProgress) => {
-    setMessages(prev => {
-      const newMessages = [...prev]
-      const msg = { ...newMessages[index] }
-      if (!msg) return prev
-
-      switch (progress.type) {
-        case 'thinking': {
-          const thinkingData = progress.data as { content: string; isComplete: boolean }
-          if (thinkingData.content) {
-            msg.thinking = (msg.thinking || '') + thinkingData.content
+  // ==================== 消息更新 ====================
+  const updateSessionMessage = useCallback((
+    sessionId: string, 
+    messageIndex: number, 
+    event: ChatEvent
+  ) => {
+    const state = sessionStatesRef.current.get(sessionId)
+    if (!state) return
+
+    const msg = state.messages[messageIndex]
+    if (!msg) return
+
+    const updatedMsg = { ...msg }
+    let parts = [...updatedMsg.parts]
+
+    switch (event.type) {
+      case 'thinking_start': {
+        parts.push({ type: 'thinking', text: '', status: 'running' })
+        break
+      }
+
+      case 'thinking_delta': {
+        const data = event.data as { content: string }
+        const lastThinkingIndex = parts.findLastIndex(
+          p => p.type === 'thinking' && p.status === 'running'
+        )
+        if (lastThinkingIndex >= 0) {
+          const part = parts[lastThinkingIndex] as ThinkingPart
+          parts[lastThinkingIndex] = { ...part, text: part.text + data.content }
+        } else {
+          parts.push({ type: 'thinking', text: data.content, status: 'running' })
+        }
+        break
+      }
+
+      case 'thinking_end': {
+        const data = event.data as { duration: number }
+        const lastThinkingIndex = parts.findLastIndex(
+          p => p.type === 'thinking' && p.status === 'running'
+        )
+        if (lastThinkingIndex >= 0) {
+          const part = parts[lastThinkingIndex] as ThinkingPart
+          parts[lastThinkingIndex] = {
+            ...part,
+            status: 'done',
+            duration: Math.round(data.duration / 1000),
           }
-          msg.thinkingComplete = thinkingData.isComplete
-          break
         }
+        break
+      }
 
-        case 'search_start':
-          msg.searching = true
-          break
+      case 'search_start': {
+        const data = event.data as { query?: string }
+        parts.push({ type: 'search', query: data.query, status: 'running' })
+        break
+      }
 
-        case 'search_result': {
-          msg.searching = false
-          const searchData = progress.data as { results: SearchResult[] }
-          msg.searchResults = searchData.results || []
-          break
+      case 'search_result': {
+        const data = event.data as { results: SearchResult[] }
+        const lastSearchIndex = parts.findLastIndex(p => p.type === 'search')
+        if (lastSearchIndex >= 0) {
+          const part = parts[lastSearchIndex] as SearchPart
+          parts[lastSearchIndex] = { ...part, results: data.results, status: 'done' }
+        }
+        break
+      }
+
+      case 'search_end': {
+        const lastSearchIndex = parts.findLastIndex(
+          p => p.type === 'search' && p.status === 'running'
+        )
+        if (lastSearchIndex >= 0) {
+          const part = parts[lastSearchIndex] as SearchPart
+          parts[lastSearchIndex] = { ...part, status: 'done' }
         }
+        break
+      }
 
-        case 'tool_call': {
-          const toolData = progress.data as { name: string; args: Record<string, unknown> }
-          if (!msg.toolCalls) msg.toolCalls = []
-          msg.toolCalls = [...msg.toolCalls, {
-            name: toolData.name,
-            args: toolData.args,
-            status: 'running' as const,
-          }]
+      case 'tool_approval_request': {
+        const data = event.data as { id: string; name: string; args: Record<string, unknown> }
+        
+        // 如果当前模式是自动执行，直接批准（处理发送消息后切换模式的情况）
+        if (autoRunConfigRef.current.mode === 'run-everything') {
+          adapter.respondToolApproval?.(data.id, true)
+          // 不创建 pending 状态，等待 tool_call_start 事件
           break
         }
+        
+        // manual 模式：创建 pending 状态等待用户确认
+        const existingIndex = parts.findLastIndex(
+          p => p.type === 'tool_call' && (p as ToolCallPart).id === data.id
+        )
+        if (existingIndex >= 0) {
+          // 更新现有 part 为 pending
+          const part = parts[existingIndex] as ToolCallPart
+          parts[existingIndex] = { ...part, status: 'pending', result: null }
+        } else {
+          // 创建新的 pending part
+          parts.push({
+            type: 'tool_call',
+            id: data.id,
+            name: data.name,
+            args: data.args,
+            status: 'pending',
+            result: null,
+          })
+        }
+        break
+      }
 
-        case 'tool_result': {
-          const resultData = progress.data as { name: string; result: string }
-          if (msg.toolCalls) {
-            msg.toolCalls = msg.toolCalls.map((t: ToolCall) => {
-              if (t.name === resultData.name && t.status === 'running') {
-                return { ...t, result: resultData.result, status: 'success' as const }
-              }
-              return t
-            })
-          }
-          break
+      case 'tool_call_start': {
+        const data = event.data as { id: string; name: string; args: Record<string, unknown> }
+        // 检查是否已存在 pending 状态的 part
+        const existingIndex = parts.findLastIndex(
+          p => p.type === 'tool_call' && (p as ToolCallPart).id === data.id
+        )
+        if (existingIndex >= 0) {
+          // 更新现有 part 为 running
+          const part = parts[existingIndex] as ToolCallPart
+          parts[existingIndex] = { ...part, status: 'running', result: null }
+        } else {
+          // 创建新的 running part
+          parts.push({
+            type: 'tool_call',
+            id: data.id,
+            name: data.name,
+            args: data.args,
+            status: 'running',
+            result: null,
+          })
         }
+        break
+      }
 
-        case 'text_delta':
-          msg.content = (msg.content || '') + (progress.data as string)
-          break
+      case 'tool_call_result': {
+        const data = event.data as { id: string; name: string; result: string; success: boolean }
+        
+        let parsedResult: unknown = data.result
+        try {
+          parsedResult = JSON.parse(data.result)
+        } catch {
+          // 保持原始字符串
+        }
 
-        case 'text':
-          if (!msg.content) {
-            msg.content = progress.data as string
+        // 判断状态：检查是否是跳过或取消操作
+        const isSkipped = typeof parsedResult === 'object' && parsedResult !== null && 
+          'skipped' in parsedResult && (parsedResult as { skipped?: boolean }).skipped === true
+        const isCancelled = typeof parsedResult === 'object' && parsedResult !== null && 
+          'cancelled' in parsedResult && (parsedResult as { cancelled?: boolean }).cancelled === true
+        const status: 'done' | 'error' | 'cancelled' | 'skipped' = 
+          isSkipped ? 'skipped' : (isCancelled ? 'cancelled' : (data.success ? 'done' : 'error'))
+
+        // 查找对应的 tool_call
+        const toolCallIndex = parts.findIndex(
+          p => p.type === 'tool_call' && (p as ToolCallPart).id === data.id
+        )
+        
+        if (toolCallIndex >= 0) {
+          // 更新 tool_call，添加 result，而不是转换为 tool_result
+          const toolCall = parts[toolCallIndex] as ToolCallPart
+          parts[toolCallIndex] = {
+            ...toolCall,
+            result: parsedResult,
+            status,
           }
-          break
+        } else {
+          // 如果没有对应的 tool_call，创建一个新的 tool_call（而不是 tool_result）
+          parts.push({
+            type: 'tool_call',
+            id: data.id,
+            name: data.name,
+            args: {},
+            result: parsedResult,
+            status,
+          })
+        }
+        
+        // 移除可能存在的独立 tool_result（如果有的话）
+        const existingResultIndex = parts.findIndex(
+          p => p.type === 'tool_result' && (p as ToolResultPart).id === data.id
+        )
+        if (existingResultIndex >= 0) {
+          parts.splice(existingResultIndex, 1)
+        }
 
-        case 'error':
-          msg.content = (msg.content || '') + `\n\n❌ 错误: ${progress.data}`
-          break
+        if (onToolComplete) {
+          // 从事件数据中获取副作用声明
+          const sideEffects = (data as { sideEffects?: SideEffect[] }).sideEffects
+          onToolComplete({
+            name: data.name,
+            result: parsedResult,
+            sideEffects,
+          })
+        }
+        break
       }
 
-      newMessages[index] = msg
-      return newMessages
-    })
-  }, [])
+      case 'text_delta': {
+        const data = event.data as { content: string }
+        
+        parts = parts.map(p => 
+          p.type === 'search' && p.status === 'running' 
+            ? { ...p, status: 'done' as const } 
+            : p
+        )
+        
+        // 查找最后一个 text part
+        const lastTextIndex = parts.findLastIndex(p => p.type === 'text')
+        
+        // 检查最后一个 part 是否是已完成的工具调用/搜索/思考
+        // 如果是，说明这是新一轮的文本输出，应该创建新的 text part
+        const lastPart = parts[parts.length - 1]
+        const shouldCreateNew = lastPart && (
+          (lastPart.type === 'tool_call' && ['done', 'error', 'skipped', 'cancelled'].includes((lastPart as ToolCallPart).status)) ||
+          (lastPart.type === 'search' && (lastPart as SearchPart).status === 'done') ||
+          (lastPart.type === 'thinking' && (lastPart as ThinkingPart).status === 'done')
+        )
+        
+        if (shouldCreateNew || lastTextIndex < 0) {
+          // 创建新的 text part
+          parts.push({ type: 'text', text: data.content })
+        } else {
+          // 追加到现有的 text part
+          const part = parts[lastTextIndex] as TextPart
+          parts[lastTextIndex] = { ...part, text: part.text + data.content }
+        }
+        break
+      }
 
-  /** 发送消息 */
-  const sendMessage = useCallback(async (text: string, images?: string[]) => {
-    if (!text.trim() || isLoading) return
+      case 'error': {
+        const data = event.data as { category?: string; message: string; retryable?: boolean }
+        
+        parts = parts.map(p => {
+          if (p.type === 'thinking' && p.status === 'running') return { ...p, status: 'done' as const }
+          if (p.type === 'search' && p.status === 'running') return { ...p, status: 'done' as const }
+          if (p.type === 'tool_call' && p.status === 'running') return { ...p, status: 'error' as const }
+          return p
+        })
+        
+        parts.push({
+          type: 'error',
+          message: data.message,
+          category: data.category,
+          retryable: data.retryable,
+        })
+        
+        updatedMsg.loading = false
+        updatedMsg.error = data
+        break
+      }
+
+      case 'abort': {
+        parts = parts.map(p => {
+          if (p.type === 'thinking' && p.status === 'running') return { ...p, status: 'done' as const }
+          if (p.type === 'search' && p.status === 'running') return { ...p, status: 'done' as const }
+          if (p.type === 'tool_call' && p.status === 'running') return { ...p, status: 'cancelled' as const }
+          return p
+        })
+        updatedMsg.loading = false
+        updatedMsg.aborted = true
+        break
+      }
 
-    // 如果没有当前会话，先创建
+      case 'done':
+        updatedMsg.loading = false
+        break
+    }
+
+    updatedMsg.parts = parts
+    state.messages = [...state.messages]
+    state.messages[messageIndex] = updatedMsg
+    forceUpdate()
+  }, [onToolComplete, forceUpdate])
+
+  // ==================== 发送消息 ====================
+  const sendMessage = useCallback(async (text: string, images?: string[]) => {
+    if (!text.trim()) return
+    
     let sessionId = currentSessionIdRef.current
+    
+    if (sessionId) {
+      const currentState = sessionStatesRef.current.get(sessionId)
+      if (currentState?.isLoading) {
+        console.warn('[useChat] 当前会话正在进行中，请等待完成')
+        return
+      }
+    }
+
     if (!sessionId) {
       try {
         const session = await adapter.createSession({
@@ -262,6 +769,11 @@ export function useChat(options: UseChatOptions = {}) {
           mode: modeRef.current,
         })
         setSessions(prev => [session, ...prev])
+        sessionStatesRef.current.set(session.id, {
+          messages: [],
+          isLoading: false,
+          abortController: null,
+        })
         setCurrentSessionId(session.id)
         sessionId = session.id
       } catch (error) {
@@ -270,19 +782,18 @@ export function useChat(options: UseChatOptions = {}) {
       }
     }
 
-    // 添加用户消息
+    const state = getSessionState(sessionId)
+
     const userMsg: ChatMessage = {
       id: generateId(),
       role: 'user',
-      content: text,
+      parts: [{ type: 'text', text }],
       images,
       timestamp: new Date(),
     }
-    
-    const currentMessages = messagesRef.current
-    setMessages([...currentMessages, userMsg])
+    state.messages = [...state.messages, userMsg]
+    forceUpdate()
 
-    // 保存用户消息
     try {
       await adapter.saveMessage({
         sessionId,
@@ -290,8 +801,7 @@ export function useChat(options: UseChatOptions = {}) {
         content: text,
       })
 
-      // 更新会话标题（如果是第一条消息）
-      if (currentMessages.length === 0) {
+      if (state.messages.length === 1) {
         const title = text.slice(0, 20) + (text.length > 20 ? '...' : '')
         await adapter.updateSession(sessionId, { title })
         setSessions(prev => prev.map((s) =>
@@ -302,162 +812,270 @@ export function useChat(options: UseChatOptions = {}) {
       console.error('保存消息失败:', error)
     }
 
-    // 创建助手消息
-    const assistantMsgIndex = currentMessages.length + 1
+    const assistantMsgIndex = state.messages.length
+    const assistantMsgId = generateId() // 保存消息 ID 用于后续更新
     const assistantMsg: ChatMessage = {
-      id: generateId(),
+      id: assistantMsgId,
       role: 'assistant',
-      content: '',
-      toolCalls: [],
-      thinkingComplete: false,
-      searching: false,
+      parts: [],
+      model: modelRef.current,
+      mode: modeRef.current,
+      webSearchEnabled: webSearchRef.current,
+      thinkingEnabled: thinkingRef.current,
       loading: true,
       timestamp: new Date(),
     }
-    setMessages(prev => [...prev, assistantMsg])
+    state.messages = [...state.messages, assistantMsg]
+    
+    // 创建本次请求专用的 abortController（避免多请求竞态条件）
+    const requestAbortController = new AbortController()
+    state.isLoading = true
+    state.abortController = requestAbortController
+    forceUpdate()
+    
+    const sendModel = modelRef.current
+    const sendMode = modeRef.current
+    const sendWebSearch = webSearchRef.current
+    const sendThinking = thinkingRef.current
+
+    // 【关键】立即保存助手消息到数据库（初始状态）
+    try {
+      await adapter.saveMessage({
+        id: assistantMsgId,
+        sessionId,
+        role: 'assistant',
+        content: '',
+        model: sendModel,
+        mode: sendMode,
+        webSearchEnabled: sendWebSearch,
+        thinkingEnabled: sendThinking,
+        steps: '[]',
+      })
+    } catch (error) {
+      console.error('创建助手消息失败:', error)
+    }
 
-    setIsLoading(true)
-    abortControllerRef.current = new AbortController()
+    // 增量保存函数
+    const saveMessageProgress = async () => {
+      const msg = state.messages[assistantMsgIndex]
+      if (!msg) return
+      try {
+        await adapter.updateMessage?.({
+          id: assistantMsgId,
+          content: extractTextContent(msg.parts),
+          steps: JSON.stringify(msg.parts),
+        })
+      } catch (error) {
+        console.error('更新消息失败:', error)
+      }
+    }
 
     try {
-      // 使用异步迭代器接收消息流
-      for await (const progress of adapter.sendMessage(
+      // 构建历史消息（不包括刚添加的用户消息和助手占位消息）
+      const history = state.messages.slice(0, -2).map(msg => ({
+        role: msg.role as 'user' | 'assistant' | 'system' | 'tool',
+        content: extractTextContent(msg.parts),
+      }))
+      
+      for await (const event of adapter.sendMessage(
         text,
         {
-          mode: modeRef.current,
-          model: modelRef.current,
-          enableWebSearch: webSearchRef.current,
-          thinkingMode: thinkingRef.current ? 'enabled' : 'disabled',
+          mode: sendMode,
+          model: sendModel,
+          enableWebSearch: sendWebSearch,
+          thinkingMode: sendThinking ? 'enabled' : 'disabled',
+          autoRunConfig,
+          history, // 传递历史消息
         },
-        images
+        images,
+        sessionId // 传递 sessionId 用于事件过滤
       )) {
-        // 检查是否被取消
-        if (abortControllerRef.current?.signal.aborted) break
+        // 使用本次请求专用的 abortController 检查（避免被新请求覆盖）
+        if (requestAbortController.signal.aborted) break
 
-        updateMessage(assistantMsgIndex, progress)
+        updateSessionMessage(sessionId, assistantMsgIndex, event)
 
-        if (progress.type === 'done' || progress.type === 'error') {
+        // 【关键】在重要事件后增量保存到数据库
+        const shouldSave = 
+          event.type === 'thinking_end' ||
+          event.type === 'tool_call_result' ||
+          event.type === 'text_delta' ||
+          event.type === 'done' ||
+          event.type === 'error' ||
+          event.type === 'abort'
+        
+        if (shouldSave) {
+          await saveMessageProgress()
+        }
+
+        if (event.type === 'done' || event.type === 'error') {
           break
         }
       }
     } catch (error) {
       console.error('发送消息失败:', error)
-      updateMessage(assistantMsgIndex, {
+      updateSessionMessage(sessionId, assistantMsgIndex, {
         type: 'error',
-        data: error instanceof Error ? error.message : String(error),
+        data: { message: error instanceof Error ? error.message : String(error) },
       })
     } finally {
-      setIsLoading(false)
-
-      // 标记加载完成并保存
-      setMessages(prev => {
-        const newMessages = [...prev]
-        const finalMsg = newMessages[assistantMsgIndex]
-        if (finalMsg) {
-          newMessages[assistantMsgIndex] = { ...finalMsg, loading: false }
-
-          // 保存助手消息
-          if (sessionId) {
-            adapter.saveMessage({
-              sessionId,
-              role: 'assistant',
-              content: finalMsg.content,
-              thinking: finalMsg.thinking,
-              toolCalls: finalMsg.toolCalls ? JSON.stringify(finalMsg.toolCalls) : undefined,
-              searchResults: finalMsg.searchResults
-                ? JSON.stringify(finalMsg.searchResults)
-                : undefined,
-            }).catch((e: Error) => console.error('保存助手消息失败:', e))
-          }
-        }
-        return newMessages
-      })
+      state.isLoading = false
+      
+      const finalMsg = state.messages[assistantMsgIndex]
+      if (finalMsg) {
+        state.messages = [...state.messages]
+        state.messages[assistantMsgIndex] = { ...finalMsg, loading: false }
+      }
 
-      abortControllerRef.current = null
+      // 【关键】最终保存一次，确保所有内容都被持久化
+      await saveMessageProgress()
+
+      state.abortController = null
+      forceUpdate()
     }
-  }, [adapter, isLoading, updateMessage])
+  }, [adapter, getSessionState, updateSessionMessage, forceUpdate])
 
-  /** 取消请求 */
+  // ==================== 其他方法 ====================
   const cancelRequest = useCallback(() => {
+    if (!currentSessionIdRef.current) return
+    const state = sessionStatesRef.current.get(currentSessionIdRef.current)
+    if (state) {
+      state.abortController?.abort()
+      state.isLoading = false
+      forceUpdate()
+    }
     adapter.cancel()
-    abortControllerRef.current?.abort()
-    setIsLoading(false)
-  }, [adapter])
+  }, [adapter, forceUpdate])
 
-  /** 复制消息 */
   const copyMessage = useCallback(async (messageId: string) => {
-    const msg = messagesRef.current.find((m) => m.id === messageId)
+    if (!currentSessionIdRef.current) return
+    const state = sessionStatesRef.current.get(currentSessionIdRef.current)
+    if (!state) return
+
+    const msg = state.messages.find((m) => m.id === messageId)
     if (!msg) return
 
     try {
-      await navigator.clipboard.writeText(msg.content)
-      setMessages(prev => prev.map((m) =>
+      const textContent = extractTextContent(msg.parts)
+      await navigator.clipboard.writeText(textContent)
+      
+      state.messages = state.messages.map((m) =>
         m.id === messageId ? { ...m, copied: true } : m
-      ))
+      )
+      forceUpdate()
+      
       setTimeout(() => {
-        setMessages(prev => prev.map((m) =>
-          m.id === messageId ? { ...m, copied: false } : m
-        ))
+        const s = sessionStatesRef.current.get(currentSessionIdRef.current!)
+        if (s) {
+          s.messages = s.messages.map((m) =>
+            m.id === messageId ? { ...m, copied: false } : m
+          )
+          forceUpdate()
+        }
       }, 2000)
     } catch (err) {
       console.error('复制失败:', err)
     }
-  }, [])
+  }, [forceUpdate])
 
-  /** 重新生成消息 */
   const regenerateMessage = useCallback((messageIndex: number) => {
-    const currentMsgs = messagesRef.current
-    if (messageIndex > 0 && currentMsgs[messageIndex - 1]?.role === 'user') {
-      const userMsg = currentMsgs[messageIndex - 1]
-      setMessages(prev => prev.slice(0, messageIndex - 1))
-      sendMessage(userMsg.content, userMsg.images)
+    if (!currentSessionIdRef.current) return
+    const state = sessionStatesRef.current.get(currentSessionIdRef.current)
+    if (!state) return
+
+    if (messageIndex > 0 && state.messages[messageIndex - 1]?.role === 'user') {
+      const userMsg = state.messages[messageIndex - 1]
+      const userText = extractTextContent(userMsg.parts)
+      state.messages = state.messages.slice(0, messageIndex - 1)
+      forceUpdate()
+      sendMessage(userText, userMsg.images)
     }
-  }, [sendMessage])
+  }, [sendMessage, forceUpdate])
+
+  /** 从指定索引重新发送消息（编辑后重发） */
+  const resendFromIndex = useCallback((index: number, text: string) => {
+    if (!currentSessionIdRef.current) return
+    const state = sessionStatesRef.current.get(currentSessionIdRef.current)
+    if (!state) return
+
+    state.messages = state.messages.slice(0, index)
+    forceUpdate()
+    sendMessage(text)
+  }, [sendMessage, forceUpdate])
 
-  /** 设置工作目录 */
   const setWorkingDirectory = useCallback((dir: string) => {
-    if (adapter.setWorkingDir) {
-      adapter.setWorkingDir(dir)
+    if (adapter.setCwd) {
+      adapter.setCwd(dir)
     }
   }, [adapter])
 
-  // 配置方法
-  const setMode = useCallback((value: ChatMode) => setModeState(value), [])
-  const setModel = useCallback((value: string) => setModelState(value), [])
-  const setWebSearch = useCallback((value: boolean) => setWebSearchState(value), [])
-  const setThinking = useCallback((value: boolean) => setThinkingState(value), [])
-
+  // ==================== 返回 ====================
   return {
-    // 状态
     sessions,
     currentSessionId,
     messages,
     isLoading,
-    mode,
-    model,
-    webSearch,
-    thinking,
+    mode: modeState,
+    model: modelState,
+    webSearch: webSearchState,
+    thinking: thinkingState,
 
-    // 会话方法
     loadSessions,
     switchSession,
     createNewSession,
     deleteSession,
     deleteCurrentSession,
+    hideSession,
+    clearAllSessions,
+    hideOtherSessions,
+    exportCurrentSession,
 
-    // 消息方法
     sendMessage,
     cancelRequest,
     copyMessage,
     regenerateMessage,
+    resendFromIndex,
 
-    // 配置方法
-    setMode,
-    setModel,
-    setWebSearch,
-    setThinking,
+    setMode: (value: ChatMode) => {
+      setModeState(value)
+      if (currentSessionIdRef.current) {
+        adapter.updateSession(currentSessionIdRef.current, { mode: value }).catch((e: Error) =>
+          console.error('更新会话 mode 失败:', e)
+        )
+      }
+    },
+    setModel: (value: string) => {
+      setModelState(value)
+      if (currentSessionIdRef.current) {
+        adapter.updateSession(currentSessionIdRef.current, { model: value }).catch((e: Error) =>
+          console.error('更新会话 model 失败:', e)
+        )
+      }
+    },
+    setWebSearch: (value: boolean) => {
+      setWebSearchState(value)
+      if (currentSessionIdRef.current) {
+        adapter.updateSession(currentSessionIdRef.current, { webSearchEnabled: value }).catch((e: Error) =>
+          console.error('更新会话 webSearchEnabled 失败:', e)
+        )
+      }
+    },
+    setThinking: (value: boolean) => {
+      setThinkingState(value)
+      if (currentSessionIdRef.current) {
+        adapter.updateSession(currentSessionIdRef.current, { thinkingEnabled: value }).catch((e: Error) =>
+          console.error('更新会话 thinkingEnabled 失败:', e)
+        )
+      }
+    },
 
-    // 工具方法
     setWorkingDirectory,
+
+    // 工具批准对话框
+
+    // 自动运行配置
+    autoRunConfig,
+    loadAutoRunConfig,
+    saveAutoRunConfig,
   }
 }