@veltra/ai 2.2.1 → 2.2.3

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/transports/openai.ts

@@ -1,12 +1,7 @@
+import { buildOpenAIBody, requestOpenAIStream } from '@veltra/utils'
+
 import type { ChatModelOption, ChatProvider } from '../../providers'
-import type {
-  ChatMessage,
-  ChatTokenUsage,
-  ChatTool,
-  ChatTransport,
-  ChatTransportHandlers,
-  ChatTransportRequest
-} from '../types'
+import type { ChatTransport, ChatTransportHandlers, ChatTransportRequest } from '../types'
 
 /** createOpenAITransport 的配置项（多 Provider） */
 export interface OpenAITransportOptions {
@@ -26,224 +21,6 @@ export type OpenAITransport = ChatTransport & {
   readonly defaultModel: string
 }
 
-interface OpenAIMessage {
-  role: string
-  content?: unknown
-  tool_calls?: unknown[]
-  tool_call_id?: string
-}
-
-function toOpenAIMessages(messages: ChatMessage[], systemPrompt?: string): OpenAIMessage[] {
-  const result: OpenAIMessage[] = []
-
-  if (systemPrompt) {
-    result.push({ role: 'system', content: systemPrompt })
-  }
-
-  for (const msg of messages) {
-    if (msg.role === 'user') {
-      if (msg.attachments?.length) {
-        const parts: unknown[] = []
-        if (msg.content) parts.push({ type: 'text', text: msg.content })
-        for (const att of msg.attachments) {
-          parts.push({ type: 'image_url', image_url: { url: att.dataUrl } })
-        }
-        result.push({ role: 'user', content: parts })
-      } else {
-        result.push({ role: 'user', content: msg.content })
-      }
-    } else if (msg.role === 'assistant') {
-      const item: OpenAIMessage = { role: 'assistant', content: msg.content || '' }
-      if (msg.toolCalls?.length) {
-        item.tool_calls = msg.toolCalls.map((call) => ({
-          id: call.id,
-          type: 'function',
-          function: { name: call.name, arguments: call.arguments }
-        }))
-      }
-      result.push(item)
-    } else if (msg.role === 'tool') {
-      result.push({ role: 'tool', tool_call_id: msg.toolCallId, content: msg.content })
-    }
-  }
-
-  return result
-}
-
-function toOpenAITools(tools: ChatTool[]): unknown[] {
-  return tools.map((tool) => ({
-    type: 'function',
-    function: { name: tool.name, description: tool.description, parameters: tool.parameters }
-  }))
-}
-
-interface AccumulatedToolCall {
-  id: string
-  name: string
-  arguments: string
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-/** 非负有限整数；非法或缺省返回 undefined（不把缺失当成 0） */
-function readCount(value: unknown): number | undefined {
-  if (typeof value !== 'number' || !Number.isFinite(value) || value < 0) return undefined
-  return Math.floor(value)
-}
-
-/**
- * 从 OpenAI 兼容 usage 对象解析。
- * 缓存字段只在源数据出现时写入；未命中可在「有命中 + prompt」时由差值得出。
- */
-function parseOpenAIUsage(raw: unknown): ChatTokenUsage | null {
-  if (!isRecord(raw)) return null
-
-  const promptTokens = readCount(raw.prompt_tokens) ?? readCount(raw.input_tokens)
-  const completionTokens = readCount(raw.completion_tokens) ?? readCount(raw.output_tokens)
-  if (promptTokens == null && completionTokens == null) return null
-
-  const prompt = promptTokens ?? 0
-  const completion = completionTokens ?? 0
-  const usage: ChatTokenUsage = {
-    promptTokens: prompt,
-    completionTokens: completion,
-    totalTokens: readCount(raw.total_tokens) ?? prompt + completion
-  }
-
-  const details = isRecord(raw.prompt_tokens_details) ? raw.prompt_tokens_details : undefined
-  const inputDetails = isRecord(raw.input_tokens_details) ? raw.input_tokens_details : undefined
-  const cacheHitTokens =
-    readCount(details?.cached_tokens) ??
-    readCount(inputDetails?.cached_tokens) ??
-    readCount(raw.prompt_cache_hit_tokens) ??
-    readCount(raw.cache_read_input_tokens) ??
-    readCount(raw.cached_tokens)
-  if (cacheHitTokens != null) usage.cacheHitTokens = cacheHitTokens
-
-  const cacheMissTokens =
-    readCount(raw.prompt_cache_miss_tokens) ??
-    (cacheHitTokens != null && promptTokens != null
-      ? Math.max(0, promptTokens - cacheHitTokens)
-      : undefined)
-  if (cacheMissTokens != null) usage.cacheMissTokens = cacheMissTokens
-
-  const cacheCreationTokens = readCount(raw.cache_creation_input_tokens)
-  if (cacheCreationTokens != null) usage.cacheCreationTokens = cacheCreationTokens
-
-  return usage
-}
-
-/**
- * 逐行解析 SSE 流。
- * 兼容 OpenAI 及 DeepSeek 等 reasoning_content 风格的兼容端点。
- */
-async function parseSSE(
-  body: ReadableStream<Uint8Array>,
-  signal: AbortSignal,
-  handlers: ChatTransportHandlers
-): Promise<void> {
-  const reader = body.getReader()
-  const decoder = new TextDecoder()
-  let buffer = ''
-
-  // 按 OpenAI 流式协议中 tool_calls 的 index 累积参数片段
-  const accumulated = new Map<number, AccumulatedToolCall>()
-  let lastIndex = -1
-
-  const flushToolCalls = () => {
-    if (!handlers.onToolCall) return
-    for (const call of accumulated.values()) {
-      if (call.id && call.name) {
-        handlers.onToolCall({ id: call.id, name: call.name, arguments: call.arguments })
-      }
-    }
-    accumulated.clear()
-  }
-
-  const handleData = (data: string) => {
-    if (data === '[DONE]') return
-
-    let chunk: unknown
-    try {
-      chunk = JSON.parse(data)
-    } catch {
-      return
-    }
-    if (!isRecord(chunk)) return
-
-    const usage = parseOpenAIUsage(chunk.usage)
-    if (usage) handlers.onUsage?.(usage)
-
-    const choices = chunk.choices
-    const first = Array.isArray(choices) ? choices[0] : undefined
-    const delta = isRecord(first) ? first.delta : undefined
-    if (!isRecord(delta)) return
-
-    if (typeof delta.content === 'string' && delta.content) {
-      handlers.onTextDelta(delta.content)
-    }
-
-    // 兼容 reasoning_content（DeepSeek）与 reasoning（部分 OpenAI 兼容端点）
-    const reasoning = delta.reasoning_content ?? delta.reasoning
-    if (typeof reasoning === 'string' && reasoning) {
-      handlers.onReasoningDelta?.(reasoning)
-    }
-
-    if (Array.isArray(delta.tool_calls)) {
-      for (const tc of delta.tool_calls) {
-        if (!isRecord(tc)) continue
-        const index = typeof tc.index === 'number' ? tc.index : 0
-        // 同一调用的参数分片共享 index；index 变大才说明前一个调用已完整，先抛出去
-        if (index > lastIndex && accumulated.size > 0) flushToolCalls()
-        lastIndex = Math.max(lastIndex, index)
-
-        let call = accumulated.get(index)
-        if (!call) {
-          call = { id: '', name: '', arguments: '' }
-          accumulated.set(index, call)
-        }
-        if (typeof tc.id === 'string') call.id = tc.id
-        const fn = isRecord(tc.function) ? tc.function : undefined
-        if (typeof fn?.name === 'string') call.name += fn.name
-        if (typeof fn?.arguments === 'string') call.arguments += fn.arguments
-      }
-    }
-  }
-
-  try {
-    // 递归泵取代替 while 循环，避免 await-in-loop
-    const pump = async (): Promise<void> => {
-      const { done, value } = await reader.read()
-      if (done || signal.aborted) return
-
-      buffer += decoder.decode(value, { stream: true })
-
-      let newlineIndex: number
-      while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
-        const line = buffer.slice(0, newlineIndex).trim()
-        buffer = buffer.slice(newlineIndex + 1)
-        if (line.startsWith('data:')) {
-          handleData(line.slice(5).trim())
-        }
-      }
-
-      return pump()
-    }
-
-    await pump()
-
-    if (buffer.trim().startsWith('data:')) {
-      handleData(buffer.trim().slice(5).trim())
-    }
-  } finally {
-    reader.releaseLock()
-  }
-
-  flushToolCalls()
-}
-
 /** 校验 providers 并展开扁平模型列表 */
 function flattenModels(providers: ChatProvider[]): {
   models: ChatModelOption[]
@@ -274,14 +51,10 @@ function flattenModels(providers: ChatProvider[]): {
   return { models, byModelId }
 }
 
-/** 缺省：写入 OpenAI 兼容的 reasoning_effort */
-function defaultApplyReasoning(level: string, body: Record<string, unknown>) {
-  body.reasoning_effort = level
-}
-
 /**
  * 创建 OpenAI 兼容协议的传输层（chat/completions SSE）。
- * 按 request.model 路由到对应 Provider 的 endpoint；手写 fetch + SSE，无第三方依赖。
+ * 按 request.model 路由到对应 Provider 的 endpoint；
+ * 请求体构造、fetch、SSE 解析与错误处理复用 `@veltra/utils` 通用层。
  */
 export function createOpenAITransport(options: OpenAITransportOptions): OpenAITransport {
   const { providers, headers: globalHeaders, body: globalBody } = options
@@ -301,64 +74,28 @@ export function createOpenAITransport(options: OpenAITransportOptions): OpenAITr
       return
     }
 
-    const extraStreamOptions = isRecord(globalBody?.stream_options)
-      ? globalBody.stream_options
-      : undefined
-    const requestBody: Record<string, unknown> = {
-      ...globalBody,
+    const requestBody = buildOpenAIBody({
       model: modelId,
+      messages,
+      systemPrompt,
+      tools,
       stream: true,
-      // 流式默认要末包 usage；OpenAI / DeepSeek 等兼容端点靠这个字段才会返回
-      stream_options: { ...extraStreamOptions, include_usage: true },
-      messages: toOpenAIMessages(messages, systemPrompt),
-      ...(tools?.length ? { tools: toOpenAITools(tools) } : {})
-    }
-
-    if (reasoningLevel) {
-      const apply = provider.applyReasoning ?? defaultApplyReasoning
-      apply(reasoningLevel, requestBody)
-    }
-
-    let response: Response
-    try {
-      response = await fetch(provider.endpoint, {
-        method: 'POST',
-        signal,
-        headers: {
-          'Content-Type': 'application/json',
-          ...(provider.apiKey ? { Authorization: `Bearer ${provider.apiKey}` } : {}),
-          ...globalHeaders,
-          ...provider.headers
-        },
-        body: JSON.stringify(requestBody)
-      })
-    } catch (error) {
-      if (!signal.aborted) {
-        handlers.onError?.(error instanceof Error ? error : new Error(String(error)))
-      }
-      return
-    }
-
-    if (!response.ok) {
-      const text = await response.text().catch(() => '')
-      handlers.onError?.(
-        new Error(`请求失败（${response.status}）：${text || response.statusText}`)
-      )
-      return
-    }
-
-    if (!response.body) {
-      handlers.onError?.(new Error('响应不包含可读取的流'))
-      return
-    }
-
-    try {
-      await parseSSE(response.body, signal, handlers)
-    } catch (error) {
-      if (!signal.aborted) {
-        handlers.onError?.(error instanceof Error ? error : new Error(String(error)))
-      }
-    }
+      reasoningLevel,
+      applyReasoning: provider.applyReasoning,
+      extraBody: globalBody
+    })
+
+    // fetch + SSE 解析 + 错误处理均由通用层完成；错误经 onError 报告，signal 中断静默
+    await requestOpenAIStream(
+      {
+        url: provider.endpoint,
+        apiKey: provider.apiKey,
+        headers: { ...globalHeaders, ...provider.headers },
+        body: requestBody,
+        signal
+      },
+      handlers
+    )
   }
 
   return Object.assign(send, { models, defaultModel })

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,

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-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'