@veltra/ai 2.2.0 → 2.2.2

package/src/chat/__test__/fixtures/bedrock/http.ts

@@ -0,0 +1,117 @@
+/**
+ * Vendored from bedrock web/src/api（自包含快照，避免测试依赖仓库外绝对路径）。
+ * 上游更新时同步此处；依赖面：@veltra/ai 类型 + ./http + ./types。
+ */
+import { storage, storageKey } from '@cat-kit/fe'
+import { HTTPClient, TokenPlugin, type HTTPClientPlugin } from '@cat-kit/http'
+
+import type { ApiEnvelope } from './types'
+
+const ACCESS_KEY = storageKey<string>('access_token')
+/** Legacy keys cleaned on set/clear (refresh is HttpOnly cookie from server). */
+const LEGACY_REFRESH_KEY = storageKey<string>('refresh_token')
+
+export function getAccessToken(): string | null {
+  return storage.local.get(ACCESS_KEY)
+}
+
+export function setAccessToken(access: string): void {
+  storage.local.set(ACCESS_KEY, access)
+  storage.local.remove(LEGACY_REFRESH_KEY)
+}
+
+export function clearTokens(): void {
+  storage.local.remove(ACCESS_KEY)
+  storage.local.remove(LEGACY_REFRESH_KEY)
+}
+
+function isApiEnvelope(body: unknown): body is ApiEnvelope {
+  if (body === null || typeof body !== 'object') return false
+  const o = body as Record<string, unknown>
+  return typeof o.code === 'number' && typeof o.message === 'string'
+}
+
+function envelopeErrorMessage(envelope: ApiEnvelope | undefined, fallback: string): string {
+  const msg = envelope?.message || fallback
+  return envelope?.request_id ? `${msg} [${envelope.request_id}]` : msg
+}
+
+/**
+ * Unwraps Bedrock `{ code, message, data?, request_id? }` envelopes.
+ * Successful calls resolve with `response.body === data`.
+ * Must run after TokenPlugin so 401 refresh/retry happens first.
+ */
+function BedrockEnvelopePlugin(): HTTPClientPlugin {
+  return {
+    name: 'bedrock-envelope',
+    afterRespond({ response }) {
+      const { code, body } = response
+
+      // Already unwrapped (e.g. TokenPlugin retry returned a processed response).
+      if (!isApiEnvelope(body)) {
+        if (code < 200 || code >= 300) {
+          throw new Error(`HTTP ${code}`)
+        }
+        return
+      }
+
+      if (code < 200 || code >= 300) {
+        throw new Error(envelopeErrorMessage(body, `HTTP ${code}`))
+      }
+      if (body.code !== 0) {
+        throw new Error(envelopeErrorMessage(body, 'request failed'))
+      }
+
+      return { ...response, body: body.data }
+    }
+  }
+}
+
+const envelopePlugin = BedrockEnvelopePlugin()
+
+/** Bare client for login/refresh (no Bearer injection). credentials so Set-Cookie / Cookie work. */
+export const bareHttp = new HTTPClient('/api/v1', {
+  timeout: 30_000,
+  credentials: true,
+  plugins: [envelopePlugin]
+})
+
+let onAuthExpired: (() => void) | null = null
+
+export function setOnAuthExpired(cb: (() => void) | null): void {
+  onAuthExpired = cb
+}
+
+function expireSession(): void {
+  clearTokens()
+  onAuthExpired?.()
+}
+
+/** 401 → POST /auth/refresh (cookie) → write new access_token; TokenPlugin retries the request. */
+async function refreshAccessToken(): Promise<void> {
+  try {
+    const { body } = await bareHttp.post<{ access_token: string }>('/auth/refresh', {})
+    if (!body?.access_token) {
+      throw new Error('refresh failed')
+    }
+    setAccessToken(body.access_token)
+  } catch (err) {
+    expireSession()
+    throw err
+  }
+}
+
+export const http = new HTTPClient('/api/v1', {
+  timeout: 30_000,
+  credentials: true,
+  plugins: [
+    TokenPlugin({
+      getter: () => getAccessToken(),
+      authType: 'Bearer',
+      maxRetries: 1,
+      onRefresh: refreshAccessToken,
+      shouldRefresh: (response) => response.code === 401
+    }),
+    envelopePlugin
+  ]
+})

package/src/chat/__test__/fixtures/bedrock/types.ts

@@ -0,0 +1,15 @@
+/**
+ * Vendored from bedrock web/src/api（自包含快照，避免测试依赖仓库外绝对路径）。
+ * 上游更新时同步此处；依赖面：@veltra/ai 类型 + ./http + ./types。
+ */
+/**
+ * bedrock web 端 API 类型的最小子集（仅本仿真测试消费的 PageResult）。
+ * 来源：bedrock 仓 web/src/api/types.ts，同步以字段演化为准。
+ */
+export interface PageResult<T> {
+  items: T[]
+  total: number
+  page: number
+  page_size: number
+  total_pages: number
+}

package/src/chat/__test__/fold.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it } from 'vite-plus/test'
 
 import { createFoldState, foldSessionEvent } from '../fold'
 import type { ChatSessionEvent } from '../session'
@@ -45,6 +45,31 @@ describe('foldSessionEvent', () => {
     })
   })
 
+  it('history 的 assistant/message 不把流式消息降级为 done、不用更短快照覆盖内容', () => {
+    // 断线补拉：直播已流式输出，历史快照落后（甚至为空）
+    const lagging = foldAll([
+      { type: 'assistant/chunk', messageId: 'a1', seq: 1, delta: '命令输出' },
+      { type: 'assistant/message', messageId: 'a1', content: '', history: true }
+    ])
+    expect(lagging.messages[0]).toMatchObject({ content: '命令输出', status: 'streaming' })
+
+    // 断线期间服务端推进更多：历史快照比直播长时采用历史（直播漏了增量）
+    const ahead = foldAll([
+      { type: 'assistant/chunk', messageId: 'a1', seq: 1, delta: '命令' },
+      { type: 'assistant/message', messageId: 'a1', content: '命令输出为 slow-done', history: true }
+    ])
+    expect(ahead.messages[0]).toMatchObject({
+      content: '命令输出为 slow-done',
+      status: 'streaming'
+    })
+
+    // 已终态的消息不受 history 标记影响，正常被历史回放覆盖（首挂载播种路径）
+    const seeded = foldAll([
+      { type: 'assistant/message', messageId: 'a2', content: '历史答复', history: true }
+    ])
+    expect(seeded.messages[0]).toMatchObject({ content: '历史答复', status: 'done' })
+  })
+
   it('tool/call 追加 pending 的 ChatToolCall 并保留 view', () => {
     const view = { preview: 'ls' }
     const state = foldAll([

package/src/chat/__test__/session.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest'
+import { describe, expect, it, vi } from 'vite-plus/test'
 
 import { createFoldState, foldSessionEvent } from '../fold'
 import * as chat from '../index'

package/src/chat/__test__/use-chat.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest'
+import { describe, expect, it, vi } from 'vite-plus/test'
 import { effectScope, nextTick, reactive } from 'vue'
 
 import * as toolsModule from '../../tools'
@@ -765,7 +765,7 @@ describe('useChat session', () => {
     spy.mockRestore()
   })
 
-  it('abort 调 session.cancel；running 由事件与 onDisconnect 驱动', async () => {
+  it('abort 调 session.cancel；running 由事件驱动，断线不翻转', async () => {
     const { chat, adapter } = await setupSession()
     expect(chat.running.value).toBe(false)
 
@@ -782,11 +782,14 @@ describe('useChat session', () => {
     adapter.emit({ type: 'error', code: 'x', message: '失败' })
     expect(chat.running.value).toBe(false)
 
+    // 断线 ≠ 停止：running 保持乐观，由重连回放的 prompted / idle 收敛。
+    // 曾在此翻转 running=false，步骤间隙断线会让过程块在「已完成 / 思考中」间跳。
     adapter.emit({ type: 'running', running: true })
     adapter.disconnect()
     await vi.waitFor(() => {
-      expect(chat.running.value).toBe(false)
+      expect(adapter.fetchHistory).toHaveBeenCalled()
     })
+    expect(chat.running.value).toBe(true)
   })
 
   it('队列只认 snapshot；enqueue / startQueued / removeQueued / regenerate 为 no-op', async () => {

package/src/chat/fold.ts

@@ -161,12 +161,27 @@ export function foldSessionEvent(state: ChatFoldState, event: ChatSessionEvent):
       break
     }
     case 'assistant/message': {
+      const current = next.messages.find((m) => m.id === event.messageId)
+      if (event.history && current && current.status === 'streaming') {
+        // 历史快照命中直播流式中的消息：快照可能落后（甚至为空），不能把消息
+        // 降级为 done 或用更短内容覆盖 —— 否则断线补拉会让消息在「完成 / 思考中」
+        // 之间来回翻转；终态由直播的 durable 帧（message_text / step 收尾）落定。
+        const longer = (a: string | undefined, b: string | undefined) =>
+          (b?.length ?? 0) > (a?.length ?? 0) ? b : a
+        next.messages = patchMessage(next.messages, event.messageId, {
+          role: 'assistant',
+          content: longer(current.content, event.content),
+          reasoning: longer(current.reasoning, event.reasoning),
+          toolCalls: event.toolCalls ?? current.toolCalls
+        })
+        break
+      }
       next.messages = patchMessage(next.messages, event.messageId, {
         role: 'assistant',
         status: 'done',
         content: event.content,
         reasoning: event.reasoning,
-        toolCalls: event.toolCalls ?? next.messages.find((m) => m.id === event.messageId)?.toolCalls
+        toolCalls: event.toolCalls ?? current?.toolCalls
       })
       break
     }

package/src/chat/session.ts

@@ -1,36 +1,43 @@
 import type { AskQuestionItem } from '../tools'
 import type { ChatAttachment, ChatJob, ChatQueuedMessage, ChatToolCall } from './types'
 
-/** 归一化后的服务端会话事件（协议无关） */
+/** 归一化后的服务端会话事件（协议无关）。
+ * seq 为持久帧序号：瞬态/历史回放事件省略（不参与乱序门），durable 终态事件携带。 */
 export type ChatSessionEvent =
   | {
       type: 'user/message'
       messageId: string
-      seq: number
+      seq?: number
       content: string
       attachments?: ChatAttachment[]
     }
   | {
       type: 'assistant/chunk'
       messageId: string
-      seq: number
+      seq?: number
       delta: string
       reasoningDelta?: string
     }
   | {
       type: 'assistant/message'
       messageId: string
-      seq: number
+      seq?: number
       content: string
       reasoning?: string
       toolCalls?: ChatToolCall[]
+      /**
+       * 历史回放（REST 拉取/断线补拉）来源标记。
+       * 历史快照可能落后于直播流：fold 对流式中的消息不降级为 done、不用更短的
+       * 快照覆盖内容；直播（durable 终态帧）始终是状态权威。
+       */
+      history?: boolean
     }
   | {
       type: 'tool/call'
       callId: string
       name: string
       arguments: string
-      seq: number
+      seq?: number
       view?: unknown
     }
   | {
@@ -39,7 +46,7 @@ export type ChatSessionEvent =
       status: 'success' | 'error' | 'rejected'
       result?: string
       error?: string
-      seq: number
+      seq?: number
       view?: unknown
     }
   | {

package/src/chat/transports/__test__/openai.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, describe, expect, it, vi } from 'vite-plus/test'
 
 import type { ChatTransportHandlers } from '../../types'
 import { createOpenAITransport } from '../openai'

package/src/chat/use-chat-session.ts

@@ -58,14 +58,13 @@ export function createSessionRuntime(surface: SessionChatSurface) {
       fold = createFoldState()
       syncFold(fold, surface)
       let disposed = false
+      // 断线 ≠ 会话停止：不注册 onDisconnect 把 running 置 false（保持乐观，由
+      // 重连回放的 prompted / step_started / idle 帧收敛）。曾在此置 false ——
+      // 步骤间隙断线会把过程块折叠成「已完成」，重连随即又展开，消息列表在
+      // 「完成 / 思考中」之间来回跳。
       const dispose = transport.open({
         onEvent(event) {
           if (!disposed) apply(event)
-        },
-        onDisconnect() {
-          if (disposed) return
-          fold = { ...fold, running: false }
-          surface.running.value = false
         }
       })
       opened = true

package/src/components/ai-chat/__test__/ai-chat.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest'
+import { describe, expect, it, vi } from 'vite-plus/test'
 import {
   createApp,
   defineComponent,
@@ -515,6 +515,43 @@ describe('UAiChat', () => {
     unmount()
   })
 
+  it('工具循环最终答案流式中过程保持展开，停跑后才折叠', async () => {
+    let round = 0
+    let releaseAnswer: (() => void) | undefined
+    const transport: ChatTransport = async (_req, handlers) => {
+      round++
+      if (round === 1) {
+        handlers.onToolCall?.({ id: 'c1', name: 'calculate', arguments: '{"expression":"1+1"}' })
+      } else {
+        handlers.onTextDelta('答案是 2')
+        await new Promise<void>((resolve) => {
+          releaseAnswer = resolve
+        })
+      }
+    }
+    const tools: ChatTool[] = [
+      { name: 'calculate', description: '计算', parameters: {}, execute: () => ({ value: 2 }) }
+    ]
+    const { host, chat, unmount } = mountAiChat({ transport, tools })
+
+    chat.value?.send('1+1 等于几')
+
+    // 最终答案流式中（仍在运行）：过程不折叠，工具卡片留在展开列表
+    await vi.waitFor(() => {
+      expect(host.querySelector('.md-stub')?.textContent).toContain('答案是 2')
+    })
+    expect(host.querySelector('.u-ai-chat__process')).toBeFalsy()
+    expect(host.querySelector('.u-ai-chat__tool-call')).toBeTruthy()
+
+    // 停跑且末条消息落定后：过程收进「已完成」折叠块
+    releaseAnswer?.()
+    await vi.waitFor(() => {
+      expect(host.querySelector('.u-ai-chat__process-title')?.textContent).toBe('已完成')
+    })
+    expect(host.querySelector('.u-ai-chat__tool-call')).toBeFalsy()
+    unmount()
+  })
+
   it('单轮无工具对话不出现「已完成」过程块', async () => {
     const transport: ChatTransport = (_req, handlers) => {
       handlers.onReasoningDelta?.('想一下')

package/src/components/ai-chat/__test__/tool-icons.test.ts

@@ -1,5 +1,5 @@
 import { EditPen, Folder, Internet, QuestionFilled, Terminal, Tools } from '@veltra/icons/normal'
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it } from 'vite-plus/test'
 import { defineComponent, h } from 'vue'
 
 import { FALLBACK_TOOL_ICON, resolveToolIcon } from '../tool-icons'

package/src/components/ai-chat/message-list.vue

@@ -17,7 +17,7 @@
           @regenerate="emit('regenerate')"
         />
 
-        <!-- 最终答案开始输出后，本轮之前的思考/工具调用过程收进「已完成」折叠块 -->
+        <!-- 本轮落定（结束 / 失败 / 中止）后，之前的思考/工具调用过程收进「已完成」折叠块 -->
         <TurnProcess
           v-if="turn.processCollapsed"
           :messages="turn.processMsgs"
@@ -200,11 +200,12 @@ const turns = computed<ChatTurn[]>(() => {
     const processMsgs = turn.assistants.slice(0, -1)
     const answerMsg = turn.assistants[turn.assistants.length - 1]
     const isLastTurn = index === grouped.length - 1
-    // 该轮结束（非最后一轮 / 答案进入终态）或最终答案开始输出时折叠过程。
-    // content 只增不减，折叠后不会回弹；regenerate 删除本轮 assistant 重跑，条件自然复位
+    // 该轮落定（非最后一轮 / 停跑且末条消息进入终态）才折叠过程，运行中始终展开。
+    // 不能以 answerMsg.content 判断：工具循环每步追加一条空 assistant 消息，answerMsg
+    // 指随后移使 content 空/非空交替，折叠态会来回翻转；断连时 running 短暂变 false
+    // 但消息仍是 streaming，不会误折叠；regenerate 删除本轮 assistant 重跑，条件自然复位
     const processCollapsed =
-      processMsgs.length > 0 &&
-      (!isLastTurn || !!answerMsg?.content || (!props.running && isFinalStatus(answerMsg)))
+      processMsgs.length > 0 && (!isLastTurn || (!props.running && isFinalStatus(answerMsg)))
     return {
       key: turn.key,
       userMsg: turn.userMsg,

package/src/components/ai-orb/__test__/ai-orb.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vite-plus/test'
 import { createApp, h, nextTick } from 'vue'
 
 import UAiOrb from '../ai-orb.vue'

package/src/tools/ask-question/__test__/ask-question.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, it, vi } from 'vitest'
+import { describe, expect, it, vi } from 'vite-plus/test'
 import { createApp, defineComponent, h, nextTick, ref } from 'vue'
 
 import type { ChatMessage, ChatTransport } from '../../../chat/types'