Skip to content

Open-source LLM knowledge platform: turn raw documents into a queryable RAG, an autonomous reasoning agent, and a self-maintaining Wiki.

fix(chat): surface truncated quick answers

hahahahahayesyeseys78d7d862e076
diff --git a/internal/application/service/chat_pipeline/chat_completion_stream.go b/internal/application/service/chat_pipeline/chat_completion_stream.go
index 9b466b2a4..26563a6ce 100644
--- a/internal/application/service/chat_pipeline/chat_completion_stream.go
+++ b/internal/application/service/chat_pipeline/chat_completion_stream.go
@@ -4,6 +4,7 @@ import (
"context"
"errors"
"fmt"
+ "strings"
"github.com/Tencent/WeKnora/internal/event"
"github.com/Tencent/WeKnora/internal/types"
@@ -11,6 +12,18 @@ import (
"github.com/google/uuid"
)
+const emptyTruncatedAnswerFallback = "Sorry, this answer hit the model's per-response output limit " +
+ "before any text was produced. Try narrowing the question, or raise max_completion_tokens."
+
+func isLengthFinishReason(reason string) bool {
+ switch strings.ToLower(strings.TrimSpace(reason)) {
+ case "length", "max_tokens", "max_output_tokens":
+ return true
+ default:
+ return false
+ }
+}
+
// PluginChatCompletionStream implements streaming chat completion functionality
// as a plugin that can be registered to EventManager
type PluginChatCompletionStream struct {
@@ -114,6 +127,7 @@ func (p *PluginChatCompletionStream) OnEvent(ctx context.Context,
answerID := fmt.Sprintf("%s-answer", uuid.New().String()[:8])
thinkingOpen := false
answerCompleted := false
+ answerProduced := false
closeThinking := func() {
if !thinkingOpen {
@@ -230,14 +244,23 @@ func (p *PluginChatCompletionStream) OnEvent(ctx context.Context,
response.Content += answerDecoder.Flush()
answerCompleted = true
}
+ if strings.TrimSpace(response.Content) != "" {
+ answerProduced = true
+ }
+ truncated := response.Done && isLengthFinishReason(response.FinishReason)
+ if truncated && !answerProduced {
+ response.Content = emptyTruncatedAnswerFallback
+ answerProduced = true
+ }
closeThinking()
eventBus.Emit(ctx, types.Event{
ID: answerID,
Type: types.EventType(event.EventAgentFinalAnswer),
SessionID: chatManage.SessionID,
Data: event.AgentFinalAnswerData{
- Content: response.Content,
- Done: response.Done,
+ Content: response.Content,
+ Done: response.Done,
+ Truncated: truncated,
},
})
}
diff --git a/internal/application/service/chat_pipeline/chat_completion_stream_test.go b/internal/application/service/chat_pipeline/chat_completion_stream_test.go
index 604c36f9d..a2c5788c5 100644
--- a/internal/application/service/chat_pipeline/chat_completion_stream_test.go
+++ b/internal/application/service/chat_pipeline/chat_completion_stream_test.go
@@ -44,6 +44,21 @@ func (b *syncEventBus) finalAnswerContents() []string {
return out
}
+func (b *syncEventBus) finalAnswerEvents() []event.AgentFinalAnswerData {
+ b.mu.Lock()
+ defer b.mu.Unlock()
+ var out []event.AgentFinalAnswerData
+ for _, evt := range b.events {
+ if evt.Type != types.EventType(event.EventAgentFinalAnswer) {
+ continue
+ }
+ if data, ok := evt.Data.(event.AgentFinalAnswerData); ok {
+ out = append(out, data)
+ }
+ }
+ return out
+}
+
// openStreamChat returns a buffered channel preloaded with chunks and never
// closes it, so the stream plugin blocks on the channel until ctx is cancelled
// — deterministically exercising the ctx.Done() branch.
@@ -153,3 +168,85 @@ func TestStreamIgnoresDuplicateTerminalAnswer(t *testing.T) {
}
require.Equal(t, []event.AgentFinalAnswerData{{Content: "hello"}, {Done: true}}, answerEvents)
}
+
+func TestStreamReportsEmptyLengthTruncation(t *testing.T) {
+ bus := &syncEventBus{}
+ model := &openStreamChat{closeStream: true, chunks: []types.StreamResponse{
+ {ResponseType: types.ResponseTypeThinking, Content: "planning"},
+ {ResponseType: types.ResponseTypeThinking, Done: true},
+ {ResponseType: types.ResponseTypeAnswer, Done: true, FinishReason: "length"},
+ }}
+
+ chatManage := &types.ChatManage{}
+ chatManage.SessionID = "sess-empty-length"
+ chatManage.EventBus = bus
+ plugin := &PluginChatCompletionStream{modelService: &stubModelService{model: model}}
+ require.Nil(t, plugin.OnEvent(
+ context.Background(), types.CHAT_COMPLETION_STREAM, chatManage,
+ func() *PluginError { return nil },
+ ))
+
+ want := event.AgentFinalAnswerData{
+ Content: "Sorry, this answer hit the model's per-response output limit before any text was produced. " +
+ "Try narrowing the question, or raise max_completion_tokens.",
+ Done: true,
+ Truncated: true,
+ }
+ require.Eventually(t, func() bool {
+ return len(bus.finalAnswerEvents()) == 1
+ }, 2*time.Second, 5*time.Millisecond)
+ require.Equal(t, []event.AgentFinalAnswerData{want}, bus.finalAnswerEvents())
+}
+
+func TestStreamMarksPartialLengthTruncation(t *testing.T) {
+ for _, finishReason := range []string{"length", "max_tokens", "max_output_tokens"} {
+ t.Run(finishReason, func(t *testing.T) {
+ bus := &syncEventBus{}
+ model := &openStreamChat{closeStream: true, chunks: []types.StreamResponse{
+ {ResponseType: types.ResponseTypeAnswer, Content: "partial answer"},
+ {ResponseType: types.ResponseTypeAnswer, Done: true, FinishReason: finishReason},
+ }}
+
+ chatManage := &types.ChatManage{}
+ chatManage.SessionID = "sess-partial-" + finishReason
+ chatManage.EventBus = bus
+ plugin := &PluginChatCompletionStream{modelService: &stubModelService{model: model}}
+ require.Nil(t, plugin.OnEvent(
+ context.Background(), types.CHAT_COMPLETION_STREAM, chatManage,
+ func() *PluginError { return nil },
+ ))
+
+ require.Eventually(t, func() bool {
+ return len(bus.finalAnswerEvents()) == 2
+ }, 2*time.Second, 5*time.Millisecond)
+ events := bus.finalAnswerEvents()
+ require.Equal(t, "partial answer", events[0].Content+events[1].Content)
+ require.False(t, events[0].Done)
+ require.False(t, events[0].Truncated)
+ require.True(t, events[1].Done)
+ require.True(t, events[1].Truncated)
+ require.NotContains(t, events[1].Content, emptyTruncatedAnswerFallback)
+ })
+ }
+}
+
+func TestStreamLeavesEmptyNaturalStopUnchanged(t *testing.T) {
+ bus := &syncEventBus{}
+ model := &openStreamChat{closeStream: true, chunks: []types.StreamResponse{
+ {ResponseType: types.ResponseTypeAnswer, Done: true, FinishReason: "stop"},
+ }}
+
+ chatManage := &types.ChatManage{}
+ chatManage.SessionID = "sess-empty-stop"
+ chatManage.EventBus = bus
+ plugin := &PluginChatCompletionStream{modelService: &stubModelService{model: model}}
+ require.Nil(t, plugin.OnEvent(
+ context.Background(), types.CHAT_COMPLETION_STREAM, chatManage,
+ func() *PluginError { return nil },
+ ))
+
+ require.Eventually(t, func() bool {
+ return len(bus.finalAnswerEvents()) == 1
+ }, 2*time.Second, 5*time.Millisecond)
+ require.Equal(t, []event.AgentFinalAnswerData{{Done: true}}, bus.finalAnswerEvents())
+}
diff --git a/internal/handler/session/qa.go b/internal/handler/session/qa.go
index 51cdcde03..a1a56bcf1 100644
--- a/internal/handler/session/qa.go
+++ b/internal/handler/session/qa.go
@@ -1281,6 +1281,9 @@ func (h *Handler) executeQA(reqCtx *qaRequestContext, mode qaMode, generateTitle
if data.IsFallback {
streamCtx.assistantMessage.IsFallback = true
}
+ if data.Truncated {
+ markQuickAnswerTruncated(streamCtx.assistantMessage)
+ }
if data.Done {
if completionHandled {
return nil
diff --git a/internal/handler/session/quick_answer_timeline.go b/internal/handler/session/quick_answer_timeline.go
index 1c6f15083..6d5191c95 100644
--- a/internal/handler/session/quick_answer_timeline.go
+++ b/internal/handler/session/quick_answer_timeline.go
@@ -128,3 +128,7 @@ func appendQuickAnswerToolCall(msg *types.Message, call types.ToolCall) {
}
step.ToolCalls = append(step.ToolCalls, call)
}
+
+func markQuickAnswerTruncated(msg *types.Message) {
+ ensureQuickAnswerStep(msg).Truncated = true
+}
diff --git a/internal/handler/session/quick_answer_timeline_test.go b/internal/handler/session/quick_answer_timeline_test.go
index 433893db5..ce652054c 100644
--- a/internal/handler/session/quick_answer_timeline_test.go
+++ b/internal/handler/session/quick_answer_timeline_test.go
@@ -109,3 +109,13 @@ func TestQuickAnswerReasoningAndTimelineShareOneStep(t *testing.T) {
assert.Equal(t, "思考中继续", msg.AgentSteps[0].ReasoningContent)
require.Len(t, msg.AgentSteps[0].ToolCalls, 1)
}
+
+func TestQuickAnswerTruncationPersistsOnSharedStep(t *testing.T) {
+ msg := &types.Message{}
+ appendQuickAnswerReasoning(msg, "思考中")
+ markQuickAnswerTruncated(msg)
+
+ require.Len(t, msg.AgentSteps, 1)
+ assert.Equal(t, "思考中", msg.AgentSteps[0].ReasoningContent)
+ assert.True(t, msg.AgentSteps[0].Truncated)
+}