@huyooo/ai-chat-frontend-vue 0.1.6 → 0.1.7

package/src/composables/useChat.ts

@@ -1,63 +1,254 @@
 /**
  * useChat Composable
  * 管理聊天状态和与后端的通信
- * 使用 Adapter 模式解耦后端通信
+ * 
+ * 新架构：
+ * - 使用 Map 存储每个会话的独立状态
+ * - 多会话可同时进行，互不干扰
+ * - 切换 tab 不会停止正在进行的请求
+ * - ContentPart 数组存储消息内容，支持流式渲染和自定义 UI
  */
 
-import { ref, shallowRef } from 'vue'
+import { ref, shallowRef, computed, reactive, onMounted, onUnmounted } from 'vue'
 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
+    }
+  }
+  
+  // 添加文本内容（如果 parts 中没有 text）
+  if (record.content && !parts.some(p => p.type === 'text')) {
+    parts.push({
+      type: 'text',
+      text: record.content,
+    })
+  }
+  
+  // 如果没有任何 parts，至少添加一个空文本
+  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
 }
 
 /**
  * 聊天状态管理 Composable
+ * 
+ * 核心架构：
+ * - sessionStates: Map<sessionId, SessionState> 存储每个会话的独立状态
+ * - 多会话可同时进行请求，互不干扰
+ * - 切换 tab 不会停止任何正在进行的请求
+ * - 通过 computed 属性暴露当前会话的状态
  */
-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
 
-  // 会话状态
+  // ==================== 会话状态存储 ====================
+  // 每个会话的独立状态 Map
+  const sessionStates = reactive(new Map<string, SessionState>())
+
+  // 获取或创建会话状态
+  function getSessionState(sessionId: string): SessionState {
+    if (!sessionStates.has(sessionId)) {
+      sessionStates.set(sessionId, {
+        messages: [],
+        isLoading: false,
+        abortController: null,
+      })
+    }
+    return sessionStates.get(sessionId)!
+  }
+
+  // ==================== 全局状态 ====================
   const sessions = ref<SessionRecord[]>([])
   const currentSessionId = ref<string | null>(null)
-  const messages = ref<ChatMessage[]>([])
+
+  // ==================== 自动运行配置（从数据库读取） ====================
+  // 默认配置
+  const DEFAULT_AUTO_RUN_CONFIG: AutoRunConfig = {
+    mode: 'run-everything',
+  }
+
+  const autoRunConfig = ref<AutoRunConfig>({ ...DEFAULT_AUTO_RUN_CONFIG })
+
+  /** 从数据库加载自动运行配置 */
+  async function loadAutoRunConfig() {
+    if (!adapter.getAllSettings) return
+    
+    try {
+      const settings = await adapter.getAllSettings()
+      const configJson = settings['autoRunConfig']
+      
+      if (configJson) {
+        const config = JSON.parse(configJson) as AutoRunConfig
+        // 合并配置，确保新增字段有默认值
+        autoRunConfig.value = { ...DEFAULT_AUTO_RUN_CONFIG, ...config }
+      }
+    } catch (error) {
+      console.error('[useChat] 加载 autoRunConfig 失败:', error)
+    }
+  }
+
+  /** 保存自动运行配置到数据库 */
+  async function saveAutoRunConfig(config: AutoRunConfig) {
+    if (!adapter.setSetting) return
+    
+    try {
+      // 创建纯对象副本用于序列化
+      const plainConfig: AutoRunConfig = {
+        mode: config.mode,
+      }
+      await adapter.setSetting('autoRunConfig', JSON.stringify(plainConfig))
+    } catch (error) {
+      console.error('[useChat] 保存 autoRunConfig 失败:', error)
+      throw error
+    }
+  }
+
+  // 初始化时加载配置
+  onMounted(() => {
+    loadAutoRunConfig()
+  })
 
   // 配置状态
   const mode = ref<ChatMode>(defaultMode)
@@ -65,18 +256,24 @@ export function useChat(options: UseChatOptions = {}) {
   const webSearch = ref(true)
   const thinking = ref(true)
 
-  // 加载状态
-  const isLoading = ref(false)
+  // ==================== 计算属性 - 当前会话状态 ====================
+  const messages = computed(() => {
+    if (!currentSessionId.value) return []
+    const state = sessionStates.get(currentSessionId.value)
+    return state?.messages || []
+  })
 
-  // 取消标记
-  const abortController = shallowRef<AbortController | null>(null)
+  const isLoading = computed(() => {
+    if (!currentSessionId.value) return false
+    const state = sessionStates.get(currentSessionId.value)
+    return state?.isLoading || false
+  })
 
-  /** 加载会话列表 */
+  // ==================== 会话管理 ====================
   async function loadSessions() {
     try {
       const list = await adapter.getSessions()
       sessions.value = list
-      // 如果有会话且没有当前会话，选择最新的
       if (list.length > 0 && !currentSessionId.value) {
         await switchSession(list[0].id)
       }
@@ -85,57 +282,80 @@ export function useChat(options: UseChatOptions = {}) {
     }
   }
 
-  /** 切换会话 */
   async function switchSession(sessionId: string) {
     if (currentSessionId.value === sessionId) return
 
     currentSessionId.value = sessionId
+    
+    // 无状态架构：不需要同步历史到后端
+    // 发送消息时会传递历史，后端不维护状态
 
-    try {
-      const savedMessages = await adapter.getMessages(sessionId)
-      messages.value = savedMessages.map(convertToMessage)
+    // 获取或创建会话状态
+    const state = getSessionState(sessionId)
 
-      // 更新配置
-      const session = sessions.value.find((s) => s.id === sessionId)
-      if (session) {
-        mode.value = session.mode
-        model.value = session.model
+    // 如果消息为空，从数据库加载
+    if (state.messages.length === 0) {
+      try {
+        const savedMessages = await adapter.getMessages(sessionId)
+        state.messages = savedMessages.map(convertToMessage)
+      } catch (error) {
+        console.error('加载消息失败:', error)
+        state.messages = []
       }
-    } catch (error) {
-      console.error('加载消息失败:', error)
-      messages.value = []
+    }
+
+    // 同步会话配置
+    const session = sessions.value.find((s) => s.id === sessionId)
+    if (session) {
+      mode.value = session.mode
+      model.value = session.model
+      webSearch.value = session.webSearchEnabled
+      thinking.value = session.thinkingEnabled
     }
   }
 
-  /** 创建新会话 */
   async function createNewSession() {
     try {
       const session = await adapter.createSession({
         title: '新对话',
         model: model.value,
         mode: mode.value,
+        webSearchEnabled: webSearch.value,
+        thinkingEnabled: thinking.value,
       })
       sessions.value = [session, ...sessions.value]
+      
+      // 创建新会话的状态
+      sessionStates.set(session.id, {
+        messages: [],
+        isLoading: false,
+        abortController: null,
+      })
+      
       currentSessionId.value = session.id
-      messages.value = []
     } catch (error) {
       console.error('创建会话失败:', error)
     }
   }
 
-  /** 删除会话 */
   async function deleteSession(sessionId: string) {
     try {
+      // 如果该会话正在加载，先取消
+      const state = sessionStates.get(sessionId)
+      if (state?.isLoading && state.abortController) {
+        state.abortController.abort()
+        adapter.cancel()
+      }
+      
       await adapter.deleteSession(sessionId)
       sessions.value = sessions.value.filter((s) => s.id !== sessionId)
+      sessionStates.delete(sessionId)
 
-      // 如果删除的是当前会话，切换到下一个
       if (currentSessionId.value === sessionId) {
         if (sessions.value.length > 0) {
           await switchSession(sessions.value[0].id)
         } else {
           currentSessionId.value = null
-          messages.value = []
         }
       }
     } catch (error) {
@@ -143,88 +363,383 @@ export function useChat(options: UseChatOptions = {}) {
     }
   }
 
-  /** 删除当前会话 */
+  async function hideSession(sessionId: string, hidden: boolean) {
+    try {
+      await adapter.updateSession(sessionId, { hidden })
+      sessions.value = sessions.value.map((s) =>
+        s.id === sessionId ? { ...s, hidden } : s
+      )
+    } catch (error) {
+      console.error('更新会话隐藏状态失败:', error)
+    }
+  }
+
+  async function clearAllSessions() {
+    try {
+      // 取消所有正在进行的请求
+      for (const [, state] of sessionStates) {
+        if (state.isLoading && state.abortController) {
+          state.abortController.abort()
+        }
+      }
+      adapter.cancel()
+      
+      for (const session of sessions.value) {
+        await adapter.deleteSession(session.id)
+      }
+      sessions.value = []
+      sessionStates.clear()
+      await createNewSession()
+    } catch (error) {
+      console.error('清空所有会话失败:', error)
+    }
+  }
+
+  async function hideOtherSessions() {
+    if (!currentSessionId.value) return
+    try {
+      for (const session of sessions.value) {
+        if (session.id !== currentSessionId.value && !session.hidden) {
+          await adapter.updateSession(session.id, { hidden: true })
+        }
+      }
+      sessions.value = sessions.value.map((s) =>
+        s.id === currentSessionId.value ? s : { ...s, hidden: true }
+      )
+    } catch (error) {
+      console.error('隐藏其他会话失败:', error)
+    }
+  }
+
+  function exportCurrentSession(): string | null {
+    if (!currentSessionId.value) return null
+    const session = sessions.value.find((s) => s.id === currentSessionId.value)
+    if (!session) return null
+
+    const state = sessionStates.get(currentSessionId.value)
+    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)
+  }
+
   async function deleteCurrentSession() {
     if (currentSessionId.value) {
       await deleteSession(currentSessionId.value)
     }
   }
 
-  /** 更新消息 */
-  function updateMessage(index: number, progress: ChatProgress) {
-    const msg = messages.value[index]
+  // ==================== 消息更新 ====================
+  /**
+   * 更新指定会话的消息
+   * 注意：这个函数会更新特定 sessionId 的消息，不受当前会话切换影响
+   */
+  function updateSessionMessage(sessionId: string, messageIndex: number, event: ChatEvent) {
+    const state = sessionStates.get(sessionId)
+    if (!state) return
+
+    const msg = state.messages[messageIndex]
     if (!msg) return
 
-    switch (progress.type) {
-      case 'thinking': {
-        const thinkingData = progress.data as { content: string; isComplete: boolean }
-        if (thinkingData.content) {
-          msg.thinking = (msg.thinking || '') + thinkingData.content
+    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' })
         }
-        msg.thinkingComplete = thinkingData.isComplete
         break
       }
 
-      case 'search_start':
-        msg.searching = true
+      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),
+          }
+        }
         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 || []
+        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 'tool_call': {
-        const toolData = progress.data as { name: string; args: Record<string, unknown> }
-        if (!msg.toolCalls) msg.toolCalls = []
-        msg.toolCalls.push({
-          name: toolData.name,
-          args: toolData.args,
-          status: 'running',
-        })
+      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_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
+      case 'tool_approval_request': {
+        const data = event.data as { id: string; name: string; args: Record<string, unknown> }
+        
+        // 如果当前模式是自动执行，直接批准（处理发送消息后切换模式的情况）
+        if (autoRunConfig.value.mode === 'run-everything') {
+          adapter.respondToolApproval?.(data.id, true)
+          // 不创建 pending 状态，等待 tool_call_start 事件
+          break
+        }
+        
+        // manual 模式：创建 pending 状态等待用户确认
+        const existingIndex = parts.findIndex(
+          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 'text_delta':
-        msg.content = (msg.content || '') + (progress.data as string)
+      case 'tool_call_start': {
+        const data = event.data as { id: string; name: string; args: Record<string, unknown> }
+        // 检查是否已存在 pending 状态的 part
+        const existingIndex = parts.findIndex(
+          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 '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 {
+          // 保持原始字符串
+        }
+
+        // 判断状态：检查是否是跳过或取消操作
+        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,
+          }
+        } 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)
+        }
+
+        if (onToolComplete) {
+          // 从事件数据中获取副作用声明
+          const sideEffects = (data as { sideEffects?: SideEffect[] }).sideEffects
+          onToolComplete({
+            name: data.name,
+            result: parsedResult,
+            sideEffects,
+          })
+        }
         break
+      }
 
-      case 'text':
-        if (!msg.content) {
-          msg.content = progress.data as string
+      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
+      }
+
+      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 'error':
-        msg.content = (msg.content || '') + `\n\n❌ 错误: ${progress.data}`
+      case 'done':
+        updatedMsg.loading = false
         break
     }
 
-    // 触发响应式更新
-    messages.value = [...messages.value]
+    updatedMsg.parts = parts
+    state.messages = [...state.messages]
+    state.messages[messageIndex] = updatedMsg
   }
 
-  /** 发送消息 */
+  // ==================== 发送消息 ====================
   async function sendMessage(text: string, images?: string[]) {
-    if (!text.trim() || isLoading.value) return
-
-    // 如果没有当前会话，先创建
+    if (!text.trim()) return
+    
+    // 获取当前会话 ID
     let sessionId = currentSessionId.value
+    
+    // 检查当前会话是否正在加载
+    if (sessionId) {
+      const currentState = sessionStates.get(sessionId)
+      if (currentState?.isLoading) {
+        console.warn('[useChat] 当前会话正在进行中，请等待完成')
+        return
+      }
+    }
+
+    // 如果没有会话，创建新会话
     if (!sessionId) {
       try {
         const session = await adapter.createSession({
@@ -233,6 +748,11 @@ export function useChat(options: UseChatOptions = {}) {
           mode: mode.value,
         })
         sessions.value = [session, ...sessions.value]
+        sessionStates.set(session.id, {
+          messages: [],
+          isLoading: false,
+          abortController: null,
+        })
         currentSessionId.value = session.id
         sessionId = session.id
       } catch (error) {
@@ -241,15 +761,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(),
     }
-    messages.value = [...messages.value, userMsg]
+    state.messages = [...state.messages, userMsg]
 
     // 保存用户消息
     try {
@@ -259,8 +782,7 @@ export function useChat(options: UseChatOptions = {}) {
         content: text,
       })
 
-      // 更新会话标题（如果是第一条消息）
-      if (messages.value.length === 1) {
+      if (state.messages.length === 1) {
         const title = text.slice(0, 20) + (text.length > 20 ? '...' : '')
         await adapter.updateSession(sessionId, { title })
         sessions.value = sessions.value.map((s) =>
@@ -272,120 +794,212 @@ export function useChat(options: UseChatOptions = {}) {
     }
 
     // 创建助手消息
-    const assistantMsgIndex = messages.value.length
+    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: model.value,
+      mode: mode.value,
+      webSearchEnabled: webSearch.value,
+      thinkingEnabled: thinking.value,
       loading: true,
       timestamp: new Date(),
     }
-    messages.value = [...messages.value, assistantMsg]
+    state.messages = [...state.messages, assistantMsg]
 
-    isLoading.value = true
-    abortController.value = new AbortController()
+    // 创建本次请求专用的 abortController（避免多请求竞态条件）
+    const requestAbortController = new AbortController()
+    
+    // 设置加载状态
+    state.isLoading = true
+    state.abortController = requestAbortController
+    
+    // 保存当前配置（发送时的快照）
+    const sendModel = model.value
+    const sendMode = mode.value
+    const sendWebSearch = webSearch.value
+    const sendThinking = thinking.value
 
+    // 【关键】立即保存助手消息到数据库（初始状态）
+    // 这样即使后续取消或崩溃，消息也已存在
     try {
-      // 使用异步迭代器接收消息流
-      for await (const progress of adapter.sendMessage(
+      await adapter.saveMessage({
+        id: assistantMsgId, // 使用预生成的 ID
+        sessionId,
+        role: 'assistant',
+        content: '',
+        model: sendModel,
+        mode: sendMode,
+        webSearchEnabled: sendWebSearch,
+        thinkingEnabled: sendThinking,
+        steps: '[]', // 空数组
+      })
+    } catch (error) {
+      console.error('创建助手消息失败:', error)
+    }
+
+    // 增量保存函数：每个重要事件后更新数据库
+    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 {
+      // 创建纯对象副本，避免 Vue 响应式代理导致序列化问题
+      const cleanAutoRunConfig: AutoRunConfig = { ...autoRunConfig.value }
+      
+      // 构建历史消息（不包括刚添加的用户消息和助手占位消息）
+      // state.messages 已经包含了用户消息和助手占位消息，所以取到倒数第二个
+      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: mode.value,
-          model: model.value,
-          enableWebSearch: webSearch.value,
-          thinkingMode: thinking.value ? 'enabled' : 'disabled',
+          mode: sendMode,
+          model: sendModel,
+          enableWebSearch: sendWebSearch,
+          thinkingMode: sendThinking ? 'enabled' : 'disabled',
+          autoRunConfig: cleanAutoRunConfig,
+          history, // 传递历史消息
         },
-        images
+        images,
+        sessionId // 传递 sessionId 用于事件过滤
       )) {
-        // 检查是否被取消
-        if (abortController.value?.signal.aborted) break
+        // 使用本次请求专用的 abortController 检查（避免被新请求覆盖）
+        if (requestAbortController.signal.aborted) break
 
-        updateMessage(assistantMsgIndex, progress)
+        // 更新消息（直接更新该会话的状态，不受当前会话切换影响）
+        updateSessionMessage(sessionId, assistantMsgIndex, event)
 
-        if (progress.type === 'done' || progress.type === 'error') {
+        // 【关键】在重要事件后增量保存到数据库
+        // thinking_end: 思考完成
+        // tool_call_result: 工具调用结果返回
+        // text_delta: 有新的文本内容
+        // done/error/abort: 请求结束
+        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 {
-      isLoading.value = false
-
-      // 标记加载完成
-      const finalMsg = messages.value[assistantMsgIndex]
+      // 更新最终状态
+      state.isLoading = false
+      
+      const finalMsg = state.messages[assistantMsgIndex]
       if (finalMsg) {
-        finalMsg.loading = false
-        messages.value = [...messages.value]
-
-        // 保存助手消息
-        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))
-        }
+        state.messages = [...state.messages]
+        state.messages[assistantMsgIndex] = { ...finalMsg, loading: false }
       }
 
-      abortController.value = null
+      // 【关键】最终保存一次，确保所有内容都被持久化
+      await saveMessageProgress()
+
+      state.abortController = null
     }
   }
 
-  /** 取消请求 */
+  // ==================== 其他方法 ====================
   function cancelRequest() {
+    if (!currentSessionId.value) return
+    const state = sessionStates.get(currentSessionId.value)
+    if (state) {
+      state.abortController?.abort()
+      state.isLoading = false
+    }
     adapter.cancel()
-    abortController.value?.abort()
-    isLoading.value = false
   }
 
-  /** 复制消息 */
   async function copyMessage(messageId: string) {
-    const msg = messages.value.find((m) => m.id === messageId)
+    if (!currentSessionId.value) return
+    const state = sessionStates.get(currentSessionId.value)
+    if (!state) return
+
+    const msg = state.messages.find((m) => m.id === messageId)
     if (!msg) return
 
     try {
-      await navigator.clipboard.writeText(msg.content)
-      messages.value = messages.value.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
       )
       setTimeout(() => {
-        messages.value = messages.value.map((m) =>
-          m.id === messageId ? { ...m, copied: false } : m
-        )
+        const s = sessionStates.get(currentSessionId.value!)
+        if (s) {
+          s.messages = s.messages.map((m) =>
+            m.id === messageId ? { ...m, copied: false } : m
+          )
+        }
       }, 2000)
     } catch (err) {
       console.error('复制失败:', err)
     }
   }
 
-  /** 重新生成消息 */
   function regenerateMessage(messageIndex: number) {
-    if (messageIndex > 0 && messages.value[messageIndex - 1]?.role === 'user') {
-      const userMsg = messages.value[messageIndex - 1]
-      messages.value = messages.value.slice(0, messageIndex - 1)
-      sendMessage(userMsg.content, userMsg.images)
+    if (!currentSessionId.value) return
+    const state = sessionStates.get(currentSessionId.value)
+    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)
+      sendMessage(userText, userMsg.images)
     }
   }
 
-  /** 设置工作目录 */
+  /** 从指定索引重新发送消息（编辑后重发） */
+  function resendFromIndex(index: number, text: string) {
+    if (!currentSessionId.value) return
+    const state = sessionStates.get(currentSessionId.value)
+    if (!state) return
+
+    // 删除当前消息及后续消息
+    state.messages = state.messages.slice(0, index)
+    // 发送新消息
+    sendMessage(text)
+  }
+
   function setWorkingDirectory(dir: string) {
-    if (adapter.setWorkingDir) {
-      adapter.setWorkingDir(dir)
+    if (adapter.setCwd) {
+      adapter.setCwd(dir)
     }
   }
 
+  // ==================== 返回 ====================
   return {
     // 状态
     sessions,
@@ -403,20 +1017,58 @@ export function useChat(options: UseChatOptions = {}) {
     createNewSession,
     deleteSession,
     deleteCurrentSession,
+    hideSession,
+    clearAllSessions,
+    hideOtherSessions,
+    exportCurrentSession,
 
     // 消息方法
     sendMessage,
     cancelRequest,
     copyMessage,
     regenerateMessage,
+    resendFromIndex,
 
     // 配置方法
-    setMode: (value: ChatMode) => { mode.value = value },
-    setModel: (value: string) => { model.value = value },
-    setWebSearch: (value: boolean) => { webSearch.value = value },
-    setThinking: (value: boolean) => { thinking.value = value },
+    setMode: (value: ChatMode) => {
+      mode.value = value
+      if (currentSessionId.value) {
+        adapter.updateSession(currentSessionId.value, { mode: value }).catch((e: Error) =>
+          console.error('更新会话 mode 失败:', e)
+        )
+      }
+    },
+    setModel: (value: string) => {
+      model.value = value
+      if (currentSessionId.value) {
+        adapter.updateSession(currentSessionId.value, { model: value }).catch((e: Error) =>
+          console.error('更新会话 model 失败:', e)
+        )
+      }
+    },
+    setWebSearch: (value: boolean) => {
+      webSearch.value = value
+      if (currentSessionId.value) {
+        adapter.updateSession(currentSessionId.value, { webSearchEnabled: value }).catch((e: Error) =>
+          console.error('更新会话 webSearchEnabled 失败:', e)
+        )
+      }
+    },
+    setThinking: (value: boolean) => {
+      thinking.value = value
+      if (currentSessionId.value) {
+        adapter.updateSession(currentSessionId.value, { thinkingEnabled: value }).catch((e: Error) =>
+          console.error('更新会话 thinkingEnabled 失败:', e)
+        )
+      }
+    },
 
     // 工具方法
     setWorkingDirectory,
+
+    // 自动运行配置
+    autoRunConfig,
+    loadAutoRunConfig,
+    saveAutoRunConfig,
   }
 }