@veltra/ai 2.1.6 → 2.1.8

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

@@ -1,7 +1,14 @@
 import { describe, expect, it, vi } from 'vitest'
-import { nextTick, reactive } from 'vue'
+import { effectScope, nextTick, reactive } from 'vue'
 
+import * as toolsModule from '../../tools'
 import type { AiChatEmits, AiChatProps } from '../../types'
+import {
+  createServerTransport,
+  isServerTransport,
+  type ChatSessionAdapter,
+  type ChatSessionEvent
+} from '../session'
 import type {
   ChatMessage,
   ChatTool,
@@ -635,3 +642,263 @@ describe('useChat', () => {
     expect(chat.lastTurnUsage.value).toBeNull()
   })
 })
+
+function createFakeAdapter(options?: {
+  history?: ChatSessionEvent[]
+}): ChatSessionAdapter & {
+  emit: (event: ChatSessionEvent) => void
+  disconnect: () => void
+  unsubscribed: () => boolean
+} {
+  let listener: { onEvent(event: ChatSessionEvent): void; onDisconnect?(): void } | undefined
+  let unsubscribed = false
+
+  const adapter: ChatSessionAdapter = {
+    subscribe(handlers) {
+      listener = handlers
+      return () => {
+        unsubscribed = true
+        listener = undefined
+      }
+    },
+    send: vi.fn(async () => {}),
+    cancel: vi.fn(async () => {}),
+    respond: vi.fn(async () => {}),
+    fetchHistory: vi.fn(async () => ({ events: options?.history ?? [], hasMore: false })),
+    selectModel: vi.fn(async () => {})
+  }
+
+  return Object.assign(adapter, {
+    emit(event: ChatSessionEvent) {
+      listener?.onEvent(event)
+    },
+    disconnect() {
+      listener?.onDisconnect?.()
+    },
+    unsubscribed: () => unsubscribed
+  })
+}
+
+async function setupSession(options?: {
+  history?: ChatSessionEvent[]
+  tools?: AiChatProps['tools']
+  models?: AiChatProps['models']
+  model?: string
+}) {
+  const adapter = createFakeAdapter({ history: options?.history })
+  const props = reactive<AiChatProps>({
+    transport: createServerTransport(adapter),
+    tools: options?.tools,
+    models: options?.models,
+    model: options?.model
+  })
+  const emit = createEmit()
+  const chat = useChat({ props, emit })
+  await vi.waitFor(() => {
+    expect(adapter.fetchHistory).toHaveBeenCalled()
+  })
+  return { adapter, props, emit, chat }
+}
+
+describe('useChat session', () => {
+  it('函数 transport 时 isServerTransport 为 false', () => {
+    const emit = createEmit()
+    const transport = textTransport('x')
+    useChat({ props: { transport }, emit })
+    expect(isServerTransport(transport)).toBe(false)
+  })
+
+  it('open + fetchHistory 播种 messages；函数 transport 不调用 open/fetchHistory', async () => {
+    const { chat, adapter } = await setupSession({
+      history: [{ type: 'user/message', messageId: 'u1', seq: 1, content: '历史' }]
+    })
+    expect(isServerTransport(createServerTransport(adapter))).toBe(true)
+    expect(chat.messages.value).toEqual([{ id: 'u1', role: 'user', content: '历史' }])
+
+    const fnTransport = textTransport('ok')
+    const fetchHistory = vi.fn()
+    const open = vi.fn()
+    useChat({
+      props: { transport: Object.assign(fnTransport, { open, fetchHistory }) },
+      emit: createEmit()
+    })
+    await Promise.resolve()
+    expect(open).not.toHaveBeenCalled()
+    expect(fetchHistory).not.toHaveBeenCalled()
+  })
+
+  it('transport 更换或卸载时调用 disposer', async () => {
+    const adapter1 = createFakeAdapter()
+    const adapter2 = createFakeAdapter()
+    const props = reactive<AiChatProps>({ transport: createServerTransport(adapter1) })
+    const scope = effectScope()
+    scope.run(() => {
+      useChat({ props, emit: createEmit() })
+    })
+    await vi.waitFor(() => expect(adapter1.fetchHistory).toHaveBeenCalled())
+    expect(adapter1.unsubscribed()).toBe(false)
+
+    props.transport = createServerTransport(adapter2)
+    await vi.waitFor(() => expect(adapter2.fetchHistory).toHaveBeenCalled())
+    expect(adapter1.unsubscribed()).toBe(true)
+
+    scope.stop()
+    expect(adapter2.unsubscribed()).toBe(true)
+  })
+
+  it('send 只调 session.send，不带全量历史、不执行 execute、不注入内置工具', async () => {
+    const spy = vi.spyOn(toolsModule, 'createBuiltinTools')
+    const execute = vi.fn()
+    const { chat, adapter } = await setupSession({
+      tools: [{ name: 'add', description: '加法', parameters: {}, execute }]
+    })
+    spy.mockClear()
+
+    chat.send('hello')
+    expect(adapter.send).toHaveBeenCalledWith('hello', undefined)
+    expect(chat.messages.value).toHaveLength(0)
+
+    adapter.emit({ type: 'user/message', messageId: 'u1', seq: 1, content: 'hello' })
+    adapter.emit({ type: 'tool/call', callId: 'c1', name: 'add', arguments: '{"a":1}', seq: 2 })
+    expect(execute).not.toHaveBeenCalled()
+    expect(spy).not.toHaveBeenCalled()
+    spy.mockRestore()
+  })
+
+  it('abort 调 session.cancel；running 由事件与 onDisconnect 驱动', async () => {
+    const { chat, adapter } = await setupSession()
+    expect(chat.running.value).toBe(false)
+
+    adapter.emit({ type: 'running', running: true })
+    expect(chat.running.value).toBe(true)
+
+    chat.abort()
+    expect(adapter.cancel).toHaveBeenCalledTimes(1)
+
+    adapter.emit({ type: 'finish' })
+    expect(chat.running.value).toBe(false)
+
+    adapter.emit({ type: 'running', running: true })
+    adapter.emit({ type: 'error', code: 'x', message: '失败' })
+    expect(chat.running.value).toBe(false)
+
+    adapter.emit({ type: 'running', running: true })
+    adapter.disconnect()
+    await vi.waitFor(() => {
+      expect(chat.running.value).toBe(false)
+    })
+  })
+
+  it('队列只认 snapshot；enqueue / startQueued / removeQueued / regenerate 为 no-op', async () => {
+    const { chat, adapter } = await setupSession()
+    adapter.emit({ type: 'queue/snapshot', items: [{ id: 'q1', content: '排队' }] })
+    expect(chat.queue.value).toEqual([{ id: 'q1', content: '排队' }])
+
+    chat.enqueue('本地')
+    chat.startQueued('q1')
+    expect(chat.removeQueued('q1')).toBeUndefined()
+    expect(chat.queue.value).toEqual([{ id: 'q1', content: '排队' }])
+    expect(adapter.send).not.toHaveBeenCalled()
+
+    adapter.emit({ type: 'user/message', messageId: 'u1', seq: 1, content: '问' })
+    adapter.emit({ type: 'assistant/message', messageId: 'a1', seq: 2, content: '答' })
+    chat.regenerate()
+    expect(chat.messages.value).toHaveLength(2)
+    expect(adapter.send).not.toHaveBeenCalled()
+  })
+
+  it('clear 只清本地渲染面，不调 cancel', async () => {
+    const { chat, adapter } = await setupSession()
+    adapter.emit({ type: 'user/message', messageId: 'u1', seq: 1, content: 'hi' })
+    adapter.emit({
+      type: 'jobs/snapshot',
+      jobs: [{ id: 'j1', kind: 'bash', label: '跑', status: 'running' }]
+    })
+    adapter.emit({
+      type: 'projection',
+      key: 'tokenUsage',
+      seq: 2,
+      value: { promptTokens: 1, completionTokens: 2, totalTokens: 3 }
+    })
+    adapter.emit({ type: 'projection', key: 'title', seq: 3, value: '标题' })
+    adapter.emit({ type: 'projection', key: 'other', seq: 4, value: 1 })
+
+    expect(chat.jobs.value).toHaveLength(1)
+    expect(chat.title.value).toBe('标题')
+    expect(chat.projections.value.other).toBe(1)
+    expect(chat.tokenUsage.value?.totalTokens).toBe(3)
+
+    chat.clear()
+    expect(adapter.cancel).not.toHaveBeenCalled()
+    expect(chat.messages.value).toHaveLength(0)
+    expect(chat.queue.value).toHaveLength(0)
+    expect(chat.jobs.value).toHaveLength(0)
+    expect(chat.tokenUsage.value).toBeNull()
+    expect(chat.projections.value).toEqual({})
+    expect(chat.title.value).toBeNull()
+  })
+
+  it('approval 与 question 走 session.respond，不执行客户端工具', async () => {
+    const execute = vi.fn()
+    const { chat, adapter } = await setupSession({
+      tools: [{ name: 'del', description: '删', parameters: {}, execute }]
+    })
+
+    adapter.emit({ type: 'tool/call', callId: 'c1', name: 'del', arguments: '{}', seq: 1 })
+    adapter.emit({
+      type: 'approval/requested',
+      approvalId: 'ap1',
+      toolName: 'del',
+      callId: 'c1',
+      rpcId: 'rpc-call'
+    })
+    expect(chat.messages.value[0]?.toolCalls?.[0]?.status).toBe('awaiting-confirm')
+    chat.respondToolCall('c1', true)
+    await vi.waitFor(() => {
+      expect(adapter.respond).toHaveBeenCalledWith('rpc-call', true, undefined)
+    })
+    expect(execute).not.toHaveBeenCalled()
+
+    adapter.emit({
+      type: 'approval/requested',
+      approvalId: 'ap2',
+      toolName: 'del',
+      rpcId: 'rpc-banner'
+    })
+    expect(chat.pendingApprovals.value.some((a) => a.rpcId === 'rpc-banner' && !a.callId)).toBe(
+      true
+    )
+    chat.respondSession('rpc-banner', false)
+    await vi.waitFor(() => {
+      expect(adapter.respond).toHaveBeenCalledWith('rpc-banner', false, undefined)
+    })
+
+    adapter.emit({
+      type: 'question/requested',
+      rpcId: 'rpc-q',
+      questions: [{ question: '选一个', options: ['A', 'B'] }]
+    })
+    expect(chat.pendingQuestion.value?.rpcId).toBe('rpc-q')
+    chat.respondSession('rpc-q', true, [{ question: '选一个', answer: 'A' }])
+    await vi.waitFor(() => {
+      expect(adapter.respond).toHaveBeenCalledWith('rpc-q', true, [
+        { question: '选一个', answer: 'A' }
+      ])
+    })
+  })
+
+  it('已 open 时模型切换走 selectModel(providerId, modelId)', async () => {
+    const { chat, adapter } = await setupSession({
+      models: [
+        { id: 'm1', providerId: 'p1' },
+        { id: 'm2', providerId: 'p1' }
+      ],
+      model: 'm1'
+    })
+    expect(adapter.selectModel).not.toHaveBeenCalled()
+
+    chat.model.value = 'm2'
+    await nextTick()
+    expect(adapter.selectModel).toHaveBeenCalledWith('p1', 'm2')
+  })
+})

package/src/chat/fold.ts

@@ -0,0 +1,260 @@
+import type { AskQuestionItem } from '../tools'
+import type { ChatSessionEvent } from './session'
+import type { ChatJob, ChatMessage, ChatQueuedMessage, ChatTokenUsage, ChatToolCall } from './types'
+
+function eventSeq(event: ChatSessionEvent): number | undefined {
+  return 'seq' in event ? event.seq : undefined
+}
+
+export interface ChatPendingApproval {
+  approvalId: string
+  toolName: string
+  callId?: string
+  reason?: string
+  rpcId: string
+}
+
+/** 历史回放与实时 onEvent 共用的折叠状态 */
+export interface ChatFoldState {
+  lastSeq: number | null
+  messages: ChatMessage[]
+  queue: ChatQueuedMessage[]
+  jobs: ChatJob[]
+  tokenUsage: ChatTokenUsage | null
+  projections: Record<string, unknown>
+  title: string | null
+  running: boolean
+  pendingApprovals: ChatPendingApproval[]
+  pendingQuestion: { questions: AskQuestionItem[]; rpcId: string } | null
+  error: { code: string; message: string } | null
+}
+
+export function createFoldState(): ChatFoldState {
+  return {
+    lastSeq: null,
+    messages: [],
+    queue: [],
+    jobs: [],
+    tokenUsage: null,
+    projections: {},
+    title: null,
+    running: false,
+    pendingApprovals: [],
+    pendingQuestion: null,
+    error: null
+  }
+}
+
+function mergeOptionalCount(a?: number, b?: number): number | undefined {
+  if (a == null && b == null) return undefined
+  return (a ?? 0) + (b ?? 0)
+}
+
+function addTokenUsage(a: ChatTokenUsage, b: ChatTokenUsage): ChatTokenUsage {
+  const usage: ChatTokenUsage = {
+    promptTokens: a.promptTokens + b.promptTokens,
+    completionTokens: a.completionTokens + b.completionTokens,
+    totalTokens: a.totalTokens + b.totalTokens
+  }
+  const cacheHitTokens = mergeOptionalCount(a.cacheHitTokens, b.cacheHitTokens)
+  if (cacheHitTokens != null) usage.cacheHitTokens = cacheHitTokens
+  const cacheMissTokens = mergeOptionalCount(a.cacheMissTokens, b.cacheMissTokens)
+  if (cacheMissTokens != null) usage.cacheMissTokens = cacheMissTokens
+  const cacheCreationTokens = mergeOptionalCount(a.cacheCreationTokens, b.cacheCreationTokens)
+  if (cacheCreationTokens != null) usage.cacheCreationTokens = cacheCreationTokens
+  return usage
+}
+
+function isTokenUsage(value: unknown): value is ChatTokenUsage {
+  if (value == null || typeof value !== 'object') return false
+  const usage = value as ChatTokenUsage
+  return (
+    typeof usage.promptTokens === 'number' &&
+    typeof usage.completionTokens === 'number' &&
+    typeof usage.totalTokens === 'number'
+  )
+}
+
+function replaceAt<T>(list: T[], idx: number, item: T): T[] {
+  const next = list.slice()
+  next[idx] = item
+  return next
+}
+
+function patchMessage(
+  messages: ChatMessage[],
+  id: string,
+  patch: Partial<ChatMessage>
+): ChatMessage[] {
+  const idx = messages.findIndex((m) => m.id === id)
+  if (idx < 0) {
+    return [...messages, { id, role: 'assistant', content: '', status: 'streaming', ...patch }]
+  }
+  return replaceAt(messages, idx, { ...messages[idx]!, ...patch })
+}
+
+function appendToolCall(messages: ChatMessage[], call: ChatToolCall): ChatMessage[] {
+  const idx = messages.findLastIndex((m) => m.role === 'assistant')
+  if (idx < 0) {
+    return [
+      ...messages,
+      {
+        id: `tool-host:${call.id}`,
+        role: 'assistant',
+        content: '',
+        status: 'streaming',
+        toolCalls: [call]
+      }
+    ]
+  }
+  const target = messages[idx]!
+  return replaceAt(messages, idx, { ...target, toolCalls: [...(target.toolCalls ?? []), call] })
+}
+
+function updateToolCall(
+  messages: ChatMessage[],
+  callId: string,
+  patch: Partial<ChatToolCall>
+): ChatMessage[] {
+  const idx = messages.findIndex((m) => m.toolCalls?.some((c) => c.id === callId))
+  if (idx < 0) return messages
+  const msg = messages[idx]!
+  const calls = (msg.toolCalls ?? []).slice()
+  const callIdx = calls.findIndex((c) => c.id === callId)
+  if (callIdx < 0) return messages
+  calls[callIdx] = { ...calls[callIdx]!, ...patch }
+  return replaceAt(messages, idx, { ...msg, toolCalls: calls })
+}
+
+/**
+ * 纯函数 fold：历史回放与实时 onEvent 走同一套。
+ * 后到的更小/重复 seq 不覆盖已应用事件。
+ */
+export function foldSessionEvent(state: ChatFoldState, event: ChatSessionEvent): ChatFoldState {
+  const seq = eventSeq(event)
+  if (seq != null && state.lastSeq != null && seq <= state.lastSeq) return state
+
+  const next: ChatFoldState = {
+    ...state,
+    lastSeq: seq ?? state.lastSeq,
+    projections: { ...state.projections }
+  }
+
+  switch (event.type) {
+    case 'user/message': {
+      if (next.messages.some((m) => m.id === event.messageId)) break
+      const userMessage: ChatMessage = { id: event.messageId, role: 'user', content: event.content }
+      if (event.attachments) userMessage.attachments = event.attachments
+      next.messages = [...next.messages, userMessage]
+      break
+    }
+    case 'assistant/chunk': {
+      const current = next.messages.find((m) => m.id === event.messageId)
+      next.messages = patchMessage(next.messages, event.messageId, {
+        role: 'assistant',
+        status: 'streaming',
+        content: (current?.content ?? '') + event.delta,
+        reasoning: event.reasoningDelta
+          ? (current?.reasoning ?? '') + event.reasoningDelta
+          : current?.reasoning
+      })
+      break
+    }
+    case 'assistant/message': {
+      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
+      })
+      break
+    }
+    case 'tool/call': {
+      const call: ChatToolCall = {
+        id: event.callId,
+        name: event.name,
+        arguments: event.arguments,
+        status: 'pending'
+      }
+      if (event.view !== undefined) call.view = event.view
+      next.messages = appendToolCall(next.messages, call)
+      break
+    }
+    case 'tool/result': {
+      const patch: Partial<ChatToolCall> = { status: event.status }
+      if (event.result !== undefined) patch.result = event.result
+      if (event.error !== undefined) patch.error = event.error
+      if (event.view !== undefined) patch.view = event.view
+      next.messages = updateToolCall(next.messages, event.callId, patch)
+      break
+    }
+    case 'queue/snapshot': {
+      next.queue = event.items.slice()
+      break
+    }
+    case 'jobs/snapshot': {
+      next.jobs = event.jobs.slice()
+      break
+    }
+    case 'projection': {
+      if (event.key === 'tokenUsage' && isTokenUsage(event.value)) {
+        next.tokenUsage = next.tokenUsage
+          ? addTokenUsage(next.tokenUsage, event.value)
+          : event.value
+      } else if (event.key === 'title' && typeof event.value === 'string') {
+        next.title = event.value
+      } else {
+        next.projections[event.key] = event.value
+      }
+      break
+    }
+    case 'running': {
+      next.running = event.running
+      break
+    }
+    case 'finish': {
+      next.running = false
+      break
+    }
+    case 'error': {
+      next.running = false
+      next.error = { code: event.code, message: event.message }
+      break
+    }
+    case 'approval/requested': {
+      if (event.callId) {
+        next.messages = updateToolCall(next.messages, event.callId, { status: 'awaiting-confirm' })
+      }
+      next.pendingApprovals = [
+        ...next.pendingApprovals,
+        {
+          approvalId: event.approvalId,
+          toolName: event.toolName,
+          callId: event.callId,
+          reason: event.reason,
+          rpcId: event.rpcId
+        }
+      ]
+      break
+    }
+    case 'approval/resolved': {
+      const hit = next.pendingApprovals.find((a) => a.approvalId === event.approvalId)
+      next.pendingApprovals = next.pendingApprovals.filter((a) => a.approvalId !== event.approvalId)
+      if (hit?.callId && event.outcome === 'rejected') {
+        next.messages = updateToolCall(next.messages, hit.callId, { status: 'rejected' })
+      }
+      break
+    }
+    case 'question/requested': {
+      next.pendingQuestion = { questions: event.questions, rpcId: event.rpcId }
+      break
+    }
+    case 'question/resolved': {
+      if (next.pendingQuestion?.rpcId === event.questionRpcId) next.pendingQuestion = null
+      break
+    }
+  }
+
+  return next
+}

package/src/chat/index.ts

@@ -1,3 +1,5 @@
 export * from './types'
 export * from './use-chat'
 export * from './transports'
+export * from './session'
+export * from './fold'