From f0edca0f510785d7f52a4d1c970c53a8a83cd7cf Mon Sep 17 00:00:00 2001 From: Ryan Wang Date: Thu, 12 Nov 2026 12:10:01 +0800 Subject: [PATCH] Make workbench test state transitions explicit --- .../workbench/streaming-tests.test.ts | 133 +++++++++++++- .../workbench/use-chat-workbench.ts | 166 ++++++++++-------- ui/src/composables/workbench/use-rag-test.ts | 75 +++++--- .../workbench/use-workbench-models.test.ts | 49 +++++- .../workbench/use-workbench-models.ts | 99 +++++++---- ...model-test-workbench-message-state.test.ts | 109 ++++++++++++ .../model-test-workbench-message-state.ts | 48 +++++ ui/src/utils/model-test-workbench.ts | 1 + ui/src/views/ModelTestWorkbenchView.vue | 2 + .../components/workbench/ChatMessageItem.vue | 17 +- 10 files changed, 556 insertions(+), 143 deletions(-) create mode 100644 ui/src/utils/model-test-workbench-message-state.test.ts create mode 100644 ui/src/utils/model-test-workbench-message-state.ts diff --git a/ui/src/composables/workbench/streaming-tests.test.ts b/ui/src/composables/workbench/streaming-tests.test.ts index 5425d9ca..e8c7affd 100644 --- a/ui/src/composables/workbench/streaming-tests.test.ts +++ b/ui/src/composables/workbench/streaming-tests.test.ts @@ -1,6 +1,6 @@ import { ModelOptionModelTypeEnum, type ModelOption } from '@/api/generated' import { useLanguageGenerationSettings } from '@/composables/workbench/use-language-generation-settings' -import { EXAMPLE_PROMPTS } from '@/utils/model-test-workbench' +import { EXAMPLE_PROMPTS, type WorkbenchMessage } from '@/utils/model-test-workbench' import { useChat } from '@halo-dev/ai-foundation-sdk' import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest' import { computed, createApp, ref, shallowRef, type App } from 'vue' @@ -99,6 +99,114 @@ describe('useChatWorkbench', () => { expect(chat.isStreaming.value).toBe(false) }) + it('does not let a stopped request clear the state of a newer request', async () => { + const first = deferred() + const second = deferred() + const { result: chat } = withSetup(() => createChatWorkbench()) + chatInstances[0].sendMessage + .mockReturnValueOnce(first.promise) + .mockReturnValueOnce(second.promise) + + const sendingFirst = chat.sendMessage('First') + chat.stopGeneration() + const sendingSecond = chat.sendMessage('Second') + + first.reject(new Error('stale failure')) + await sendingFirst + + expect(chat.isStreaming.value).toBe(true) + expect(chat.messages.value[1]).toMatchObject({ state: 'stopped' }) + expect(chat.messages.value[3]).toMatchObject({ state: 'streaming' }) + + second.resolve() + await sendingSecond + + expect(chat.isStreaming.value).toBe(false) + expect(chat.messages.value[3]).toMatchObject({ state: 'done' }) + }) + + it('submits an external tool result only once while the continuation is pending', async () => { + const pending = deferred() + const { result: chat } = withSetup(() => createChatWorkbench()) + chatInstances[0].addToolOutput.mockReturnValue(pending.promise) + const target: WorkbenchMessage = { + id: 'assistant-1', + role: 'assistant', + content: '', + state: 'done', + toolEvents: [ + { + id: 'event-1', + type: 'tool-call', + summary: 'external tool', + toolCallId: 'call-1', + toolName: 'external_tool', + externalStatus: 'pending', + }, + ], + } + chat.messages.value = [target] + + const first = chat.handleExternalToolResult({ + messageId: target.id, + eventId: 'event-1', + resultText: '{"ok":true}', + }) + const second = chat.handleExternalToolResult({ + messageId: target.id, + eventId: 'event-1', + resultText: '{"ok":true}', + }) + + expect(chat.externalToolSubmittingKeys.value).toEqual(['assistant-1:event-1']) + expect(chatInstances[0].addToolOutput).toHaveBeenCalledTimes(1) + + pending.resolve() + await Promise.all([first, second]) + + expect(chat.externalToolSubmittingKeys.value).toEqual([]) + expect(chatInstances[0].addToolOutput).toHaveBeenCalledTimes(1) + }) + + it('resumes an approved tool message with a new request id and stops it', async () => { + const pending = deferred() + const { result: chat } = withSetup(() => createChatWorkbench()) + chatInstances[0].addToolApprovalResponse.mockReturnValue(pending.promise) + const target: WorkbenchMessage = { + id: 'assistant-1', + role: 'assistant', + content: 'approval needed', + state: 'done', + requestId: 'request-1', + toolEvents: [ + { + id: 'event-1', + type: 'tool-approval-request', + approvalId: 'approval-1', + approvalStatus: 'pending', + summary: 'approval', + }, + ], + } + chat.messages.value = [target] + + const approving = chat.handleToolApproval({ + messageId: target.id, + eventId: 'event-1', + approved: true, + }) + + expect(target.state).toBe('streaming') + expect(target.requestId).not.toBe('request-1') + + chat.stopGeneration() + pending.resolve() + await approving + + expect(target.state).toBe('stopped') + expect(chat.isStreaming.value).toBe(false) + }) + it('configures the dedicated tool input stream test from its example prompt', () => { const settings = useLanguageGenerationSettings() const { result: chat } = withSetup(() => @@ -171,6 +279,29 @@ describe('useRagTest', () => { expect(rag.isRagTesting.value).toBe(false) }) + it('marks the RAG message as stopped immediately and keeps it stopped when the stream resolves', async () => { + const pending = deferred() + const { result: rag } = withSetup(() => + useRagTest({ + selectedModel: computed(() => languageModel), + settings: useLanguageGenerationSettings(), + }), + ) + chatInstances[0].sendMessage.mockReturnValue(pending.promise) + + const running = rag.runRagTest() + expect(rag.ragMessages.value[1]).toMatchObject({ state: 'streaming' }) + + rag.stopRagTest() + expect(rag.ragMessages.value[1]).toMatchObject({ state: 'stopped' }) + expect(rag.isRagTesting.value).toBe(false) + + pending.resolve() + await running + + expect(rag.ragMessages.value[1]).toMatchObject({ state: 'stopped' }) + }) + it('surfaces RAG streaming failures and clears the loading state', async () => { const { result: rag } = withSetup(() => useRagTest({ diff --git a/ui/src/composables/workbench/use-chat-workbench.ts b/ui/src/composables/workbench/use-chat-workbench.ts index 574cdb5f..88c0999a 100644 --- a/ui/src/composables/workbench/use-chat-workbench.ts +++ b/ui/src/composables/workbench/use-chat-workbench.ts @@ -17,6 +17,11 @@ import { executeWorkbenchAgentTool, isWorkbenchAgentTool, } from '@/utils/model-test-workbench-agent-tools' +import { + applyAssistantMessageEvent, + beginAssistantMessage, + resumeAssistantMessage, +} from '@/utils/model-test-workbench-message-state' import { haloMessageToWorkbench, workbenchFilesFromParts, @@ -49,6 +54,8 @@ export function useChatWorkbench(options: UseChatWorkbenchOptions) { const input = shallowRef('') const chatFiles = shallowRef([]) const isStreaming = shallowRef(false) + const externalToolSubmittingKeys = shallowRef([]) + let activeRequestId: string | undefined let activeModelName: string | undefined let activeWorkbenchId: string | undefined let activeParameters: ReturnType | undefined @@ -109,9 +116,11 @@ export function useChatWorkbench(options: UseChatWorkbenchOptions) { ]) } }, - onFinish: ({ terminal }) => { - if (activeWorkbenchId && terminal.errorText) { - appendAssistantError(activeWorkbenchId, `请求失败: ${terminal.errorText}`) + onFinish: ({ message, terminal }) => { + if (!terminal.errorText) return + const target = messages.value.find((item) => item.id === message.id) + if (target) { + appendAssistantError(target.id, `请求失败: ${terminal.errorText}`, target.requestId) } }, }) @@ -159,33 +168,39 @@ export function useChatWorkbench(options: UseChatWorkbenchOptions) { const model = activeModels.value.find((item) => item.name === modelName) if (!model) return + const requestId = utils.id.uuid() const assistantMessage = targetMessage || createAssistantMessage(model) assistantMessage.uiMessage = createAssistantUIMessage( assistantMessage.uiMessage?.id || assistantMessage.id, ) - resetAssistantMessage(assistantMessage) + beginAssistantMessage(assistantMessage, requestId) if (!targetMessage) messages.value.push(assistantMessage) - activeModelName = modelName - activeWorkbenchId = assistantMessage.id - activeParameters = parameters + setActiveRequest(requestId, modelName, assistantMessage.id, parameters) uiChat.setMessages( workbenchMessagesToHalo(messages.value.filter((item) => item !== assistantMessage)), ) - isStreaming.value = true try { await uiChat.sendMessage(undefined, { body: uiMessageRequestBody(parameters) }) if (uiChat.error.value) { - appendAssistantError(assistantMessage.id, `请求失败: ${uiChat.error.value.message}`) + appendAssistantError( + assistantMessage.id, + `请求失败: ${uiChat.error.value.message}`, + requestId, + ) return } - finishAssistantMessage(assistantMessage.id, 'done') + finishAssistantMessage(assistantMessage.id, requestId) } catch (error) { if ((error as Error).name !== 'AbortError') { - appendAssistantError(assistantMessage.id, `请求失败: ${(error as Error).message}`) + appendAssistantError( + assistantMessage.id, + `请求失败: ${(error as Error).message}`, + requestId, + ) } } finally { - resetActiveRequest() + resetActiveRequest(requestId) } } @@ -209,38 +224,25 @@ export function useChatWorkbench(options: UseChatWorkbenchOptions) { uiChat.setMessages(workbenchMessagesToHalo(messages.value)) targetMessage.uiMessage = createAssistantUIMessage(messageId) - resetAssistantMessage(targetMessage) - activeModelName = model.name - activeWorkbenchId = targetMessage.id - activeParameters = parameters - isStreaming.value = true + const requestId = utils.id.uuid() + beginAssistantMessage(targetMessage, requestId) + setActiveRequest(requestId, model.name, targetMessage.id, parameters) try { await uiChat.regenerate({ messageId, body: uiMessageRequestBody(parameters) }) if (uiChat.error.value) { - appendAssistantError(targetMessage.id, `请求失败: ${uiChat.error.value.message}`) + appendAssistantError(targetMessage.id, `请求失败: ${uiChat.error.value.message}`, requestId) return } - finishAssistantMessage(targetMessage.id, 'done') + finishAssistantMessage(targetMessage.id, requestId) } catch (error) { if ((error as Error).name !== 'AbortError') { - appendAssistantError(targetMessage.id, `请求失败: ${(error as Error).message}`) + appendAssistantError(targetMessage.id, `请求失败: ${(error as Error).message}`, requestId) } } finally { - resetActiveRequest() + resetActiveRequest(requestId) } } - function resetAssistantMessage(message: WorkbenchMessage) { - message.content = '' - message.reasoningContent = undefined - message.reasoningState = undefined - message.toolEvents = undefined - message.toolInputStreamDiagnostics = undefined - message.transientData = undefined - message.warnings = undefined - message.state = 'streaming' - } - function createAssistantMessage(model: ModelOption): WorkbenchMessage { return { id: utils.id.uuid(), @@ -274,11 +276,10 @@ export function useChatWorkbench(options: UseChatWorkbenchOptions) { } const parameters = settings.buildValidatedParameters() if (!parameters) return - activeModelName = model.name - activeWorkbenchId = message.id - activeParameters = parameters + const requestId = utils.id.uuid() + resumeAssistantMessage(message, requestId) + setActiveRequest(requestId, model.name, message.id, parameters) uiChat.setMessages(workbenchMessagesToHalo(messages.value)) - isStreaming.value = true try { await uiChat.addToolApprovalResponse( { @@ -291,15 +292,15 @@ export function useChatWorkbench(options: UseChatWorkbenchOptions) { { body: uiMessageRequestBody(parameters) }, ) if (uiChat.error.value) { - appendAssistantError(message.id, `请求失败: ${uiChat.error.value.message}`) + appendAssistantError(message.id, `请求失败: ${uiChat.error.value.message}`, requestId) return } syncMessageFromUiChat(message) - finishAssistantMessage(message.id, 'done') + finishAssistantMessage(message.id, requestId) } catch (error) { - appendAssistantError(message.id, `请求失败: ${(error as Error).message}`) + appendAssistantError(message.id, `请求失败: ${(error as Error).message}`, requestId) } finally { - resetActiveRequest() + resetActiveRequest(requestId) } } @@ -344,7 +345,8 @@ export function useChatWorkbench(options: UseChatWorkbenchOptions) { eventId: string, payload: { type: 'tool-result'; result: unknown } | { type: 'tool-error'; errorText: string }, ) { - if (isStreaming.value) return + const submissionKey = `${messageId}:${eventId}` + if (isStreaming.value || externalToolSubmittingKeys.value.includes(submissionKey)) return const model = selectedModel.value if (!model?.name) return const message = messages.value.find((item) => item.id === messageId) @@ -362,24 +364,34 @@ export function useChatWorkbench(options: UseChatWorkbenchOptions) { } const parameters = settings.buildValidatedParameters() if (!parameters) return - uiChat.setMessages(workbenchMessagesToHalo(messages.value)) - await uiChat.addToolOutput( - payload.type === 'tool-result' - ? { toolCallId: event.toolCallId, output: payload.result } - : { toolCallId: event.toolCallId, state: 'output-error', errorText: payload.errorText }, - ) - syncMessageFromUiChat(message) - const updatedEvent = message.toolEvents?.find((item) => item.id === eventId) - if (updatedEvent) { - updatedEvent.externalStatus = payload.type === 'tool-result' ? 'completed' : 'failed' - message.toolEvents = [...(message.toolEvents || [])] + externalToolSubmittingKeys.value = [...externalToolSubmittingKeys.value, submissionKey] + try { + uiChat.setMessages(workbenchMessagesToHalo(messages.value)) + await uiChat.addToolOutput( + payload.type === 'tool-result' + ? { toolCallId: event.toolCallId, output: payload.result } + : { toolCallId: event.toolCallId, state: 'output-error', errorText: payload.errorText }, + ) + syncMessageFromUiChat(message) + const updatedEvent = message.toolEvents?.find((item) => item.id === eventId) + if (updatedEvent) { + updatedEvent.externalStatus = payload.type === 'tool-result' ? 'completed' : 'failed' + message.toolEvents = [...(message.toolEvents || [])] + } + await streamResponse(model.name, parameters) + } catch (error) { + appendAssistantError(messageId, `请求失败: ${(error as Error).message}`) + } finally { + externalToolSubmittingKeys.value = externalToolSubmittingKeys.value.filter( + (key) => key !== submissionKey, + ) } - await streamResponse(model.name, parameters) } function syncActiveSnapshot(uiMessages: readonly unknown[]) { if (!activeWorkbenchId) return const target = messages.value.find((item) => item.id === activeWorkbenchId) + if (target?.requestId && target.requestId !== activeRequestId) return const assistant = [...uiMessages] .reverse() .find((item): item is HaloUIMessage> => { @@ -414,23 +426,17 @@ export function useChatWorkbench(options: UseChatWorkbenchOptions) { if (message) message.warnings = [...(message.warnings || []), ...warnings] } - function appendAssistantError(messageId: string, content: string) { + function appendAssistantError(messageId: string, content: string, requestId?: string) { + if (requestId && requestId !== activeRequestId) return const message = messages.value.find((item) => item.id === messageId) if (!message) return - const normalizedContent = content.trim() - if (message.state === 'error' && message.content.includes(normalizedContent)) return - message.content = message.content.trim() - ? `${message.content.trim()}\n\n${normalizedContent}` - : normalizedContent - message.state = 'error' - if (message.reasoningState === 'streaming') message.reasoningState = 'done' + applyAssistantMessageEvent(message, { type: 'fail', content }) } - function finishAssistantMessage(messageId: string, state: WorkbenchMessage['state']) { + function finishAssistantMessage(messageId: string, requestId?: string) { + if (requestId && requestId !== activeRequestId) return const message = messages.value.find((item) => item.id === messageId) - if (message?.state !== 'streaming') return - message.state = state - if (message.reasoningState === 'streaming') message.reasoningState = 'done' + if (message) applyAssistantMessageEvent(message, { type: 'finish' }) } function parseExternalToolResult(value: string): { value?: unknown; error?: string } { @@ -466,23 +472,38 @@ export function useChatWorkbench(options: UseChatWorkbenchOptions) { } } - function resetActiveRequest() { + function setActiveRequest( + requestId: string, + modelName: string, + messageId: string, + parameters: ReturnType, + ) { + activeRequestId = requestId + activeModelName = modelName + activeWorkbenchId = messageId + activeParameters = parameters + isStreaming.value = true + } + + function resetActiveRequest(requestId?: string) { + if (requestId !== undefined && requestId !== activeRequestId) return isStreaming.value = false + activeRequestId = undefined activeModelName = undefined activeWorkbenchId = undefined activeParameters = undefined } function stopGeneration() { + const requestId = activeRequestId uiChat.stop() - const streamingMessage = [...messages.value] - .reverse() - .find((item) => item.state === 'streaming') + const streamingMessage = requestId + ? messages.value.find((item) => item.requestId === requestId) + : [...messages.value].reverse().find((item) => item.state === 'streaming') if (streamingMessage) { - streamingMessage.state = 'stopped' - if (streamingMessage.reasoningState === 'streaming') streamingMessage.reasoningState = 'done' + applyAssistantMessageEvent(streamingMessage, { type: 'stop' }) } - resetActiveRequest() + resetActiveRequest(requestId) } function clearMessages() { @@ -520,6 +541,7 @@ export function useChatWorkbench(options: UseChatWorkbenchOptions) { input, chatFiles, isStreaming, + externalToolSubmittingKeys, sendMessage, regenerate, handleToolApproval, diff --git a/ui/src/composables/workbench/use-rag-test.ts b/ui/src/composables/workbench/use-rag-test.ts index 5b0ffb6b..2894fc61 100644 --- a/ui/src/composables/workbench/use-rag-test.ts +++ b/ui/src/composables/workbench/use-rag-test.ts @@ -9,6 +9,10 @@ import { workbenchMessageMetadataSchema, type WorkbenchMessage, } from '@/utils/model-test-workbench' +import { + applyAssistantMessageEvent, + beginAssistantMessage, +} from '@/utils/model-test-workbench-message-state' import { cloneWorkbenchMessage, haloMessageToWorkbench, @@ -55,6 +59,7 @@ export function useRagTest({ selectedModel, settings }: UseRagTestOptions) { const ragMessages = ref([]) const ragError = shallowRef('') const isRagTesting = shallowRef(false) + let activeRequestId: string | undefined let activeModelName: string | undefined let activeWorkbenchId: string | undefined @@ -75,10 +80,11 @@ export function useRagTest({ selectedModel, settings }: UseRagTestOptions) { generateId: () => activeWorkbenchId || utils.id.uuid(), messageMetadataSchema: workbenchMessageMetadataSchema, dataPartSchemas: workbenchDataPartSchemas, - onFinish: ({ terminal }) => { - if (activeWorkbenchId && terminal.errorText) { - appendAssistantError(activeWorkbenchId, terminal.errorText) - } + onFinish: ({ message, terminal }) => { + if (!terminal.errorText) return + const target = ragMessages.value.find((item) => item.id === message.id) + if (!target || (target.requestId && target.requestId !== activeRequestId)) return + appendAssistantError(target.id, terminal.errorText, target.requestId) }, }) @@ -147,7 +153,10 @@ export function useRagTest({ selectedModel, settings }: UseRagTestOptions) { rerankFailurePolicy: 'USE_RETRIEVED_ORDER', }, } + const requestId = utils.id.uuid() + beginAssistantMessage(assistantMessage, requestId) isRagTesting.value = true + activeRequestId = requestId activeModelName = model.name activeWorkbenchId = assistantMessageId ragUiChat.setMessages( @@ -156,21 +165,24 @@ export function useRagTest({ selectedModel, settings }: UseRagTestOptions) { try { await ragUiChat.sendMessage(undefined, { body: requestBody }) if (ragUiChat.error.value) { - appendAssistantError(assistantMessageId, ragUiChat.error.value.message) + appendAssistantError(assistantMessageId, ragUiChat.error.value.message, requestId) return } - finishAssistantMessage(assistantMessageId, 'done') + finishAssistantMessage(assistantMessageId, requestId) } catch (error) { if ((error as Error).name === 'AbortError') { - finishAssistantMessage(assistantMessageId, 'stopped') + stopAssistantMessage(assistantMessageId, requestId) return } ragError.value = `请求失败: ${(error as Error).message}` - appendAssistantError(assistantMessageId, ragError.value) + appendAssistantError(assistantMessageId, ragError.value, requestId) } finally { - isRagTesting.value = false - activeModelName = undefined - activeWorkbenchId = undefined + if (activeRequestId === requestId) { + isRagTesting.value = false + activeRequestId = undefined + activeModelName = undefined + activeWorkbenchId = undefined + } } } @@ -188,6 +200,7 @@ export function useRagTest({ selectedModel, settings }: UseRagTestOptions) { function syncActiveSnapshot(uiMessages: readonly unknown[]) { if (!activeWorkbenchId) return const index = ragMessages.value.findIndex((item) => item.id === activeWorkbenchId) + if (index >= 0 && ragMessages.value[index]?.requestId !== activeRequestId) return const assistant = [...uiMessages] .reverse() .find((item): item is HaloUIMessage> => { @@ -207,31 +220,39 @@ export function useRagTest({ selectedModel, settings }: UseRagTestOptions) { ragMessages.value.splice(index, 1, message) } - function finishAssistantMessage(messageId: string, state: WorkbenchMessage['state']) { + function finishAssistantMessage(messageId: string, requestId: string) { + updateAssistantMessage(messageId, (message) => { + if (message.requestId !== requestId) return + applyAssistantMessageEvent(message, { type: 'finish' }) + }) + } + + function stopAssistantMessage(messageId: string, requestId: string) { updateAssistantMessage(messageId, (message) => { - if (message.state !== 'streaming') return - message.state = state - if (message.reasoningState === 'streaming') message.reasoningState = 'done' + if (message.requestId !== requestId) return + applyAssistantMessageEvent(message, { type: 'stop' }) }) } - function appendAssistantError(messageId: string, content: string) { + function appendAssistantError(messageId: string, content: string, requestId?: string) { updateAssistantMessage(messageId, (message) => { - const normalizedContent = content.trim() - if (message.state === 'error' && message.content.includes(normalizedContent)) return - message.content = message.content.trim() - ? `${message.content.trim()}\n\n${normalizedContent}` - : normalizedContent - message.state = 'error' - if (message.reasoningState === 'streaming') message.reasoningState = 'done' + if (requestId && message.requestId !== requestId) return + applyAssistantMessageEvent(message, { type: 'fail', content }) }) } function stopRagTest() { + const requestId = activeRequestId ragUiChat.stop() - isRagTesting.value = false - activeModelName = undefined - activeWorkbenchId = undefined + if (activeWorkbenchId && requestId) { + stopAssistantMessage(activeWorkbenchId, requestId) + } + if (activeRequestId === requestId) { + isRagTesting.value = false + activeRequestId = undefined + activeModelName = undefined + activeWorkbenchId = undefined + } } function clearRagMessages() { @@ -254,4 +275,4 @@ export function useRagTest({ selectedModel, settings }: UseRagTestOptions) { clearRagMessages, stopRagTest, } -} \ No newline at end of file +} diff --git a/ui/src/composables/workbench/use-workbench-models.test.ts b/ui/src/composables/workbench/use-workbench-models.test.ts index 9e447e87..af6fc5a8 100644 --- a/ui/src/composables/workbench/use-workbench-models.test.ts +++ b/ui/src/composables/workbench/use-workbench-models.test.ts @@ -24,21 +24,27 @@ describe('useWorkbenchModels', () => { scopes.splice(0).forEach((scope) => scope.stop()) }) - function createWorkbench(selectedName: string, initialModels?: ModelOption[]) { + function createWorkbench( + selectedName: string, + initialModels?: ModelOption[], + initialMode?: WorkbenchTestMode, + ) { const modelOptions = shallowRef(initialModels) const selectedModelName = shallowRef(selectedName) + const modeQuery = shallowRef(initialMode) vi.mocked(useModelOptionsFetch).mockReturnValue({ data: modelOptions, isLoading: shallowRef(!initialModels), isFetching: shallowRef(!initialModels), refetch: vi.fn(), } as never) - vi.mocked(useRouteQuery).mockReturnValue(selectedModelName as never) + vi.mocked(useRouteQuery).mockImplementation(((key: string) => + key === 'mode' ? modeQuery : selectedModelName) as never) const scope = effectScope() scopes.push(scope) const models = scope.run(useWorkbenchModels)! - return { models, modelOptions } + return { models, modelOptions, modeQuery } } it('preserves the route model until model options finish loading', async () => { @@ -140,6 +146,41 @@ describe('useWorkbenchModels', () => { expect(models.selectedModelName.value).toBeUndefined() }) + + it('keeps an explicit rag mode when a language model is linked', async () => { + const { models } = createWorkbench('deepseek-chat', [model('deepseek-chat')], 'rag') + + await nextTick() + + expect(models.testMode.value).toBe('rag') + expect(models.selectedModelName.value).toBe('deepseek-chat') + }) + + it('treats an explicit mode as authoritative when the linked model has another type', async () => { + const { models } = createWorkbench( + 'deepseek-chat', + [model('deepseek-chat'), model('embedding-first', ModelOptionModelTypeEnum.Embedding)], + 'embedding', + ) + + await nextTick() + + expect(models.testMode.value).toBe('embedding') + expect(models.selectedModelName.value).toBe('embedding-first') + }) + + it('mirrors mode changes into the route and clears the chat mode', async () => { + const { models, modeQuery } = createWorkbench('language-first', [model('language-first')]) + + await nextTick() + expect(modeQuery.value).toBeUndefined() + + models.testMode.value = 'embedding' + expect(modeQuery.value).toBe('embedding') + + models.testMode.value = 'chat' + expect(modeQuery.value).toBeUndefined() + }) }) function model( @@ -152,4 +193,4 @@ function model( displayName: name, modelType, } -} \ No newline at end of file +} diff --git a/ui/src/composables/workbench/use-workbench-models.ts b/ui/src/composables/workbench/use-workbench-models.ts index 68d71e8e..a1bad6bb 100644 --- a/ui/src/composables/workbench/use-workbench-models.ts +++ b/ui/src/composables/workbench/use-workbench-models.ts @@ -1,14 +1,34 @@ import { ModelOptionModelTypeEnum, type ModelOption } from '@/api/generated' import { useModelOptionsFetch } from '@/composables/use-model-options-fetch' import { useRouteQuery } from '@vueuse/router' -import { computed, shallowRef, watch, type ComputedRef, type ShallowRef } from 'vue' +import { + computed, + shallowRef, + watch, + type ComputedRef, + type ShallowRef, + type WritableComputedRef, +} from 'vue' export type WorkbenchTestMode = 'chat' | 'embedding' | 'rerank' | 'image' | 'rag' | 'decision' +const workbenchTestModes: WorkbenchTestMode[] = [ + 'chat', + 'embedding', + 'rerank', + 'image', + 'rag', + 'decision', +] + +export function isWorkbenchTestMode(value: string | undefined): value is WorkbenchTestMode { + return workbenchTestModes.includes(value as WorkbenchTestMode) +} + export interface WorkbenchModels { availableOnly: ShallowRef selectedModelName: ReturnType> - testMode: ShallowRef + testMode: WritableComputedRef decisionModels: ComputedRef chatModels: ComputedRef embeddingModels: ComputedRef @@ -44,7 +64,14 @@ export function useWorkbenchModels(): WorkbenchModels { available: availableOnly, }) const selectedModelName = useRouteQuery('model') - const testMode = shallowRef('chat') + const modeQuery = useRouteQuery('mode') + const hasExplicitMode = computed(() => isWorkbenchTestMode(modeQuery.value)) + const testMode = computed({ + get: () => (isWorkbenchTestMode(modeQuery.value) ? modeQuery.value : 'chat'), + set: (mode) => { + modeQuery.value = mode === 'chat' ? undefined : mode + }, + }) const modelsByType = (type: ModelOptionModelTypeEnum) => computed(() => @@ -74,45 +101,47 @@ export function useWorkbenchModels(): WorkbenchModels { activeModels.value.find((model) => model.name === selectedModelName.value), ) + function ensureSelectedModel() { + const candidates = activeModels.value + if (!candidates.some((model) => model.name === selectedModelName.value)) { + selectedModelName.value = candidates[0]?.name + } + } + + function inferModeFromSelectedModel(items: ModelOption[]) { + if (hasExplicitMode.value) return + const selected = items.find((item) => item.name === selectedModelName.value) + switch (selected?.modelType) { + case ModelOptionModelTypeEnum.Decision: + testMode.value = 'decision' + break + case ModelOptionModelTypeEnum.Embedding: + testMode.value = 'embedding' + break + case ModelOptionModelTypeEnum.Rerank: + testMode.value = 'rerank' + break + case ModelOptionModelTypeEnum.ImageGeneration: + testMode.value = 'image' + break + case ModelOptionModelTypeEnum.Language: + if (testMode.value !== 'rag') { + testMode.value = 'chat' + } + } + } + watch( modelOptions, (items) => { if (!items) return - const selected = items.find((item) => item.name === selectedModelName.value) - switch (selected?.modelType) { - case ModelOptionModelTypeEnum.Decision: - testMode.value = 'decision' - break - case ModelOptionModelTypeEnum.Embedding: - testMode.value = 'embedding' - break - case ModelOptionModelTypeEnum.Rerank: - testMode.value = 'rerank' - break - case ModelOptionModelTypeEnum.ImageGeneration: - testMode.value = 'image' - break - case ModelOptionModelTypeEnum.Language: - if (testMode.value !== 'rag') { - testMode.value = 'chat' - } - } - const candidates = activeModels.value - if (!candidates.length) { - selectedModelName.value = undefined - } else if (!candidates.some((item) => item.name === selectedModelName.value)) { - selectedModelName.value = candidates[0].name - } + inferModeFromSelectedModel(items) + ensureSelectedModel() }, { immediate: true }, ) - watch(testMode, () => { - const candidates = activeModels.value - if (!candidates.some((model) => model.name === selectedModelName.value)) { - selectedModelName.value = candidates[0]?.name - } - }) + watch(testMode, ensureSelectedModel) return { availableOnly, @@ -130,4 +159,4 @@ export function useWorkbenchModels(): WorkbenchModels { isFetching, refetch, } -} \ No newline at end of file +} diff --git a/ui/src/utils/model-test-workbench-message-state.test.ts b/ui/src/utils/model-test-workbench-message-state.test.ts new file mode 100644 index 00000000..bbe58945 --- /dev/null +++ b/ui/src/utils/model-test-workbench-message-state.test.ts @@ -0,0 +1,109 @@ +import { describe, expect, it } from 'vitest' +import type { WorkbenchMessage } from './model-test-workbench' +import { + applyAssistantMessageEvent, + beginAssistantMessage, + resumeAssistantMessage, +} from './model-test-workbench-message-state' + +function message(): WorkbenchMessage { + return { + id: 'message-1', + role: 'assistant', + content: 'old content', + reasoningContent: 'old reasoning', + reasoningState: 'streaming', + toolEvents: [{ id: 'event-1', type: 'tool-call', summary: 'stale event' }], + toolInputStreamDiagnostics: [], + transientData: { stale: true }, + warnings: [{ message: 'old warning' }], + } +} + +describe('model test workbench message state', () => { + it('resets a message into a streaming request', () => { + const target = message() + + beginAssistantMessage(target, 'request-1') + + expect(target).toMatchObject({ + content: '', + reasoningContent: undefined, + reasoningState: undefined, + toolEvents: undefined, + toolInputStreamDiagnostics: undefined, + transientData: undefined, + warnings: undefined, + state: 'streaming', + requestId: 'request-1', + }) + }) + + it('resumes a completed message without clearing content or tool state', () => { + const target = { ...message(), state: 'done' as const, requestId: 'request-1' } + + resumeAssistantMessage(target, 'request-2') + + expect(target).toMatchObject({ + content: 'old content', + toolEvents: [{ id: 'event-1', type: 'tool-call', summary: 'stale event' }], + state: 'streaming', + requestId: 'request-2', + }) + }) + + it('finishes a streaming message and closes reasoning', () => { + const target = { ...message(), state: 'streaming' as const } + + expect(applyAssistantMessageEvent(target, { type: 'finish' })).toBe(true) + expect(target.state).toBe('done') + expect(target.reasoningState).toBe('done') + }) + + it('does not finish a message twice', () => { + const target = { ...message(), state: 'done' as const } + + expect(applyAssistantMessageEvent(target, { type: 'finish' })).toBe(false) + expect(target.state).toBe('done') + }) + + it('stops a streaming message', () => { + const target = { ...message(), state: 'streaming' as const } + + expect(applyAssistantMessageEvent(target, { type: 'stop' })).toBe(true) + expect(target.state).toBe('stopped') + expect(target.reasoningState).toBe('done') + }) + + it('does not stop a completed message', () => { + const target = { ...message(), state: 'done' as const } + + expect(applyAssistantMessageEvent(target, { type: 'stop' })).toBe(false) + expect(target.state).toBe('done') + }) + + it('appends an error and closes reasoning', () => { + const target = { ...message(), content: 'partial', state: 'streaming' as const } + + expect(applyAssistantMessageEvent(target, { type: 'fail', content: '请求失败' })).toBe(true) + expect(target.content).toBe('partial\n\n请求失败') + expect(target.state).toBe('error') + expect(target.reasoningState).toBe('done') + }) + + it('ignores duplicate and empty errors', () => { + const target = { ...message(), content: '请求失败', state: 'error' as const } + + expect(applyAssistantMessageEvent(target, { type: 'fail', content: '请求失败' })).toBe(false) + expect(applyAssistantMessageEvent(target, { type: 'fail', content: ' ' })).toBe(false) + expect(target.content).toBe('请求失败') + }) + + it('allows a late error after the message completed', () => { + const target = { ...message(), content: 'answer', state: 'done' as const } + + expect(applyAssistantMessageEvent(target, { type: 'fail', content: '请求失败' })).toBe(true) + expect(target.content).toBe('answer\n\n请求失败') + expect(target.state).toBe('error') + }) +}) diff --git a/ui/src/utils/model-test-workbench-message-state.ts b/ui/src/utils/model-test-workbench-message-state.ts new file mode 100644 index 00000000..30a2c836 --- /dev/null +++ b/ui/src/utils/model-test-workbench-message-state.ts @@ -0,0 +1,48 @@ +import type { WorkbenchMessage } from './model-test-workbench' + +export type AssistantMessageEvent = + | { type: 'finish' } + | { type: 'stop' } + | { type: 'fail'; content: string } + +export function beginAssistantMessage(message: WorkbenchMessage, requestId?: string) { + message.content = '' + message.reasoningContent = undefined + message.reasoningState = undefined + message.toolEvents = undefined + message.toolInputStreamDiagnostics = undefined + message.transientData = undefined + message.warnings = undefined + message.state = 'streaming' + message.requestId = requestId +} + +export function resumeAssistantMessage(message: WorkbenchMessage, requestId: string) { + message.requestId = requestId + message.state = 'streaming' +} + +export function applyAssistantMessageEvent( + message: WorkbenchMessage, + event: AssistantMessageEvent, +): boolean { + if (event.type === 'fail') { + const content = event.content.trim() + if (!content) return false + const current = message.content.trim() + if (message.state === 'error' && current.includes(content)) return false + message.content = current ? `${current}\n\n${content}` : content + message.state = 'error' + endReasoning(message) + return true + } + + if (message.state !== 'streaming') return false + message.state = event.type === 'finish' ? 'done' : 'stopped' + endReasoning(message) + return true +} + +function endReasoning(message: WorkbenchMessage) { + if (message.reasoningState === 'streaming') message.reasoningState = 'done' +} diff --git a/ui/src/utils/model-test-workbench.ts b/ui/src/utils/model-test-workbench.ts index ac1b4322..810b63ad 100644 --- a/ui/src/utils/model-test-workbench.ts +++ b/ui/src/utils/model-test-workbench.ts @@ -23,6 +23,7 @@ export interface WorkbenchMessage { toolInputStreamDiagnostics?: ToolInputStreamDiagnostic[] modelName?: string modelDisplayName?: string + requestId?: string state?: 'streaming' | 'done' | 'error' | 'stopped' warnings?: WorkbenchWarning[] sourceReferences?: WorkbenchSourceReference[] diff --git a/ui/src/views/ModelTestWorkbenchView.vue b/ui/src/views/ModelTestWorkbenchView.vue index 966990c0..446c66c4 100644 --- a/ui/src/views/ModelTestWorkbenchView.vue +++ b/ui/src/views/ModelTestWorkbenchView.vue @@ -101,6 +101,7 @@ const { input, chatFiles, isStreaming, + externalToolSubmittingKeys, sendMessage, regenerate: handleRegenerate, handleToolApproval, @@ -285,6 +286,7 @@ function distanceToConversationBottom(element: HTMLElement) { :key="message.id" :message="message" :index="index" + :submitting-event-ids="externalToolSubmittingKeys" @regenerate="handleRegenerate" @tool-approval="handleToolApproval" @external-tool-result="handleExternalToolResult" diff --git a/ui/src/views/components/workbench/ChatMessageItem.vue b/ui/src/views/components/workbench/ChatMessageItem.vue index 65dfde62..29d57487 100644 --- a/ui/src/views/components/workbench/ChatMessageItem.vue +++ b/ui/src/views/components/workbench/ChatMessageItem.vue @@ -20,6 +20,7 @@ import ToolInputStreamDiagnostics from './ToolInputStreamDiagnostics.vue' const props = defineProps<{ message: WorkbenchMessage index: number + submittingEventIds?: string[] }>() const emit = defineEmits<{ @@ -111,6 +112,10 @@ function handleExternalToolError(eventId: string) { }) } +function isEventSubmitting(eventId: string) { + return props.submittingEventIds?.includes(`${props.message.id}:${eventId}`) ?? false +} + function sourceSubtitle(source: WorkbenchSourceReference) { if (source.type === 'source-url') { return source.url || 'URL' @@ -306,8 +311,9 @@ function filePreviewUrl(file: WorkbenchFileReference) { >