Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

fix(service): prevent goroutine leaks on SSE stream channel writes (#21179)

Sanderhoff-alt581f1a2cca67
diff --git a/internal/handler/agent.go b/internal/handler/agent.go
index 812641c81d..a048c741b2 100644
--- a/internal/handler/agent.go
+++ b/internal/handler/agent.go
@@ -496,7 +496,9 @@ func (h *AgentHandler) RunAgent(c *gin.Context) {
return
}
- events, err := h.chatRunner.RunAgent(c.Request.Context(), user.ID, canvasID, sessionID, version, userInput, nil)
+ ctx, cancel := context.WithCancel(c.Request.Context())
+ defer cancel()
+ events, err := h.chatRunner.RunAgent(ctx, user.ID, canvasID, sessionID, version, userInput, nil)
if err != nil {
ec, em := mapAgentError(err)
common.ResponseWithCodeData(c, ec, nil, em)
@@ -1347,7 +1349,9 @@ func (h *AgentHandler) AgentChatCompletions(c *gin.Context) {
// req.Files is already normalized to the 1D file list by the
// agentFiles unmarshaler. A nil/empty list reaches RunAgent as-is so
// its `len(files) > 0` guard sees a file-less run.
- events, err := h.chatRunner.RunAgent(c.Request.Context(), user.ID, req.AgentID, req.SessionID, "", userInput, req.Files)
+ ctx, cancel := context.WithCancel(c.Request.Context())
+ defer cancel()
+ events, err := h.chatRunner.RunAgent(ctx, user.ID, req.AgentID, req.SessionID, "", userInput, req.Files)
if err != nil {
common.Warn("agent chat completions: RunAgent failed",
append([]zap.Field{
diff --git a/internal/handler/agent_openai.go b/internal/handler/agent_openai.go
index 3a542b5f3a..aad880cbae 100644
--- a/internal/handler/agent_openai.go
+++ b/internal/handler/agent_openai.go
@@ -17,6 +17,7 @@
package handler
import (
+ "context"
"encoding/json"
"errors"
"net/http"
@@ -110,7 +111,8 @@ func (h *AgentHandler) handleOpenAICompat(c *gin.Context, user *entity.User, req
c.Request = c.Request.WithContext(service.WithAgentSessionID(c.Request.Context(), req.SessionID))
}
- runContext := service.WithOpenAICompatMessages(c.Request.Context(), req.Messages)
+ runContext, cancel := context.WithCancel(service.WithOpenAICompatMessages(c.Request.Context(), req.Messages))
+ defer cancel()
events, err := h.chatRunner.RunAgent(
runContext, user.ID, req.AgentID, req.SessionID, "", question, req.Files,
)
diff --git a/internal/handler/bot.go b/internal/handler/bot.go
index ab946081ac..520ffeaeac 100644
--- a/internal/handler/bot.go
+++ b/internal/handler/bot.go
@@ -169,8 +169,10 @@ func (h *BotHandler) AgentbotCompletion(c *gin.Context) {
body.Release = &release
}
}
+ ctx, cancel := context.WithCancel(c.Request.Context())
+ defer cancel()
events, ec, err := h.botService.AgentbotCompletion(
- c.Request.Context(), user.ID, agentID, body)
+ ctx, user.ID, agentID, body)
if err != nil {
common.ResponseWithCodeData(c, ec, nil, err.Error())
return
@@ -220,8 +222,10 @@ func (h *BotHandler) ChatbotCompletion(c *gin.Context) {
return
}
}
+ ctx, cancel := context.WithCancel(c.Request.Context())
+ defer cancel()
frames, ec, err := h.botService.ChatbotCompletion(
- c.Request.Context(), user.ID, dialogID, body)
+ ctx, user.ID, dialogID, body)
if err != nil {
if respondPermissionErrorIf(c, err, true) {
return
diff --git a/internal/handler/chat_session.go b/internal/handler/chat_session.go
index 7dad6110b2..66a49150e9 100644
--- a/internal/handler/chat_session.go
+++ b/internal/handler/chat_session.go
@@ -17,6 +17,7 @@
package handler
import (
+ "context"
"encoding/json"
"errors"
"fmt"
@@ -273,12 +274,14 @@ func (h *ChatSessionHandler) ChatCompletions(c *gin.Context) {
c.Header("Connection", "keep-alive")
c.Header("X-Accel-Buffering", "no")
+ ctx, cancel := context.WithCancel(c.Request.Context())
+ defer cancel()
+
streamChan := make(chan string, 32)
- reqCtx := c.Request.Context()
go func() {
defer close(streamChan)
_, _ = h.chatSessionService.ChatCompletions(
- reqCtx, userID,
+ ctx, userID,
req.ChatID, sessionID,
req.Messages, req.Question, req.Files,
req.LLMID, genConfig, kwargs,
@@ -288,12 +291,16 @@ func (h *ChatSessionHandler) ChatCompletions(c *gin.Context) {
}()
c.Stream(func(w io.Writer) bool {
- data, ok := <-streamChan
- if !ok {
+ select {
+ case <-ctx.Done():
return false
+ case data, ok := <-streamChan:
+ if !ok {
+ return false
+ }
+ _, err := c.Writer.Write([]byte(data))
+ return err == nil
}
- c.Writer.Write([]byte(data))
- return true
})
} else {
// The non-stream path computes the whole answer before its first
diff --git a/internal/handler/search.go b/internal/handler/search.go
index 7a1bba35dd..1a7057aaa0 100644
--- a/internal/handler/search.go
+++ b/internal/handler/search.go
@@ -17,6 +17,7 @@
package handler
import (
+ "context"
"net/http"
"ragflow/internal/common"
"strconv"
@@ -440,21 +441,30 @@ func (h *SearchHandler) Completion(c *gin.Context) {
adapter := &service.TenantStreamAdapter{Factory: h.modelFactory, TenantID: plan.UserID, ModelID: plan.ModelID}
+ ctx, cancel := context.WithCancel(c.Request.Context())
+ defer cancel()
+ c.Request = c.Request.WithContext(ctx)
+
hadError := false
- for delta := range h.askService.StreamWithOptions(c.Request.Context(), adapter, plan.UserID, plan.Question, plan.DatasetIDs, plan.Options) {
+ for delta := range h.askService.StreamWithOptions(ctx, adapter, plan.UserID, plan.Question, plan.DatasetIDs, plan.Options) {
+ var ok bool
switch delta.Kind {
case service.AskDeltaAnswer:
- writer.Write(c, sseAnswer(delta.Value, nil, false))
+ ok = writer.Write(c, sseAnswer(delta.Value, nil, false))
case service.AskDeltaMarker:
- writer.Write(c, sseMarker(delta.Value))
+ ok = writer.Write(c, sseMarker(delta.Value))
case service.AskDeltaError:
hadError = true
- writer.Write(c, sseError(delta.Value))
+ ok = writer.Write(c, sseError(delta.Value))
case service.AskDeltaFinal:
- writer.Write(c, sseAnswer(delta.Value, delta.Refs, true))
+ ok = writer.Write(c, sseAnswer(delta.Value, delta.Refs, true))
+ }
+ if !ok || ctx.Err() != nil {
+ cancel()
+ break
}
}
- if !hadError {
+ if !hadError && ctx.Err() == nil {
writer.Write(c, "data: {\"code\": 0, \"message\": \"success\", \"data\": true}\n\n")
}
}
diff --git a/internal/handler/searchbot.go b/internal/handler/searchbot.go
index df2d73d944..ae20d85891 100644
--- a/internal/handler/searchbot.go
+++ b/internal/handler/searchbot.go
@@ -17,6 +17,7 @@
package handler
import (
+ "context"
"encoding/json"
"fmt"
"io"
@@ -313,24 +314,32 @@ func (h *SearchBotHandler) Ask(c *gin.Context) {
h.sseWriter.Write(c, sseError("model factory not configured"))
return
}
- ctx := c.Request.Context()
+ ctx, cancel := context.WithCancel(c.Request.Context())
+ defer cancel()
+ c.Request = c.Request.WithContext(ctx)
+ hadError := false
adapter := &service.TenantStreamAdapter{Factory: h.modelFactory, TenantID: user.ID, ModelID: modelID}
for delta := range h.askSvc.StreamWithOptions(ctx, adapter, user.ID, req.Question, filtered, options) {
+ var ok bool
switch delta.Kind {
case service.AskDeltaAnswer:
- h.sseWriter.Write(c, sseAnswer(delta.Value, nil, false))
+ ok = h.sseWriter.Write(c, sseAnswer(delta.Value, nil, false))
case service.AskDeltaMarker:
- h.sseWriter.Write(c, sseMarker(delta.Value))
+ ok = h.sseWriter.Write(c, sseMarker(delta.Value))
case service.AskDeltaError:
- h.sseWriter.Write(c, sseError(delta.Value))
+ hadError = true
+ ok = h.sseWriter.Write(c, sseError(delta.Value))
case service.AskDeltaFinal:
- h.sseWriter.Write(c, sseAnswer(delta.Value, delta.Refs, true))
+ ok = h.sseWriter.Write(c, sseAnswer(delta.Value, delta.Refs, true))
+ }
+ if !ok || ctx.Err() != nil {
+ cancel()
+ break
}
}
- c.Stream(func(w io.Writer) bool {
- fmt.Fprintf(w, "data: {\"code\": 0, \"message\": \"success\", \"data\": true}\n\n")
- return false
- })
+ if !hadError && ctx.Err() == nil {
+ h.sseWriter.Write(c, "data: {\"code\": 0, \"message\": \"success\", \"data\": true}\n\n")
+ }
}
@@ -523,17 +532,22 @@ func sseMarker(marker string) string {
}
type SSEWriter interface {
- Write(c *gin.Context, data string)
+ Write(c *gin.Context, data string) bool
}
// ginSSEWriter is the production SSEWriter backed by gin.Context.Stream.
type ginSSEWriter struct{}
-func (w *ginSSEWriter) Write(c *gin.Context, data string) {
- c.Stream(func(w io.Writer) bool {
- fmt.Fprint(w, data)
+func (w *ginSSEWriter) Write(c *gin.Context, data string) bool {
+ if c.Request.Context().Err() != nil {
+ return false
+ }
+ var writeErr error
+ clientGone := c.Stream(func(w io.Writer) bool {
+ _, writeErr = fmt.Fprint(w, data)
return false
})
+ return !clientGone && writeErr == nil && c.Request.Context().Err() == nil
}
// toRetrievalServiceRequest maps the handler DTO to the service DTO.
diff --git a/internal/handler/searchbot_test.go b/internal/handler/searchbot_test.go
index 2f4273dae6..e815a21731 100644
--- a/internal/handler/searchbot_test.go
+++ b/internal/handler/searchbot_test.go
@@ -486,8 +486,9 @@ type bufferSSEWriter struct {
buf strings.Builder
}
-func (w *bufferSSEWriter) Write(_ *gin.Context, data string) {
+func (w *bufferSSEWriter) Write(_ *gin.Context, data string) bool {
w.buf.WriteString(data)
+ return true
}
func (w *bufferSSEWriter) String() string { return w.buf.String() }
@@ -680,3 +681,53 @@ func TestSseError_Format(t *testing.T) {
t.Errorf("missing empty reference array: %s", s)
}
}
+
+type closeNotifyRecorder struct {
+ *httptest.ResponseRecorder
+ closed chan bool
+}
+
+func newCloseNotifyRecorder() *closeNotifyRecorder {
+ return &closeNotifyRecorder{
+ ResponseRecorder: httptest.NewRecorder(),
+ closed: make(chan bool, 1),
+ }
+}
+
+func (c *closeNotifyRecorder) CloseNotify() <-chan bool {
+ return c.closed
+}
+
+func (c *closeNotifyRecorder) Close() {
+ c.closed <- true
+}
+
+func TestGinSSEWriter_WriteMultipleDeltasAndDisconnect(t *testing.T) {
+ gin.SetMode(gin.ReleaseMode)
+ rec := newCloseNotifyRecorder()
+ c, _ := gin.CreateTestContext(rec)
+ c.Request = httptest.NewRequest("GET", "/", nil)
+
+ writer := &ginSSEWriter{}
+
+ if !writer.Write(c, "data: delta1\n\n") {
+ t.Fatal("expected first write to succeed")
+ }
+ if !writer.Write(c, "data: delta2\n\n") {
+ t.Fatal("expected second write to succeed")
+ }
+
+ // Simulate client disconnect
+ rec.Close()
+ if writer.Write(c, "data: delta3\n\n") {
+ t.Fatal("expected write to fail after client disconnect")
+ }
+
+ body := rec.Body.String()
+ if !strings.Contains(body, "delta1") || !strings.Contains(body, "delta2") {
+ t.Fatalf("expected body to contain delta1 and delta2, got: %q", body)
+ }
+ if strings.Contains(body, "delta3") {
+ t.Fatalf("expected delta3 to not be written after disconnect, got: %q", body)
+ }
+}
diff --git a/internal/service/bot_completion.go b/internal/service/bot_completion.go
index 8e013a5085..a0ca1b395f 100644
--- a/internal/service/bot_completion.go
+++ b/internal/service/bot_completion.go
@@ -479,6 +479,19 @@ func (s *BotService) streamChatbotTurn(
// no-delta fallback.
var rawAnswer, fullAnswer string
var finalRef map[string]any
+
+ sendFrame := func(frame ChatbotSSEFrame) bool {
+ if ctx.Err() != nil {
+ return false
+ }
+ select {
+ case out <- frame:
+ return true
+ case <-ctx.Done():
+ return false
+ }
+ }
+
for res := range results {
if res.Final {
completedAt := float64(time.Now().UnixNano()) / 1e9
@@ -496,15 +509,16 @@ func (s *BotService) streamChatbotTurn(
}
errored := strings.HasPrefix(fullAnswer, "**ERROR**")
// Save the completed answer before delivering the final SSE frame.
- // The question was saved before generation; failures leave it intact.
- if !errored && ctx.Err() == nil {
+ if !errored {
persisted := rawAnswer
if persisted == "" {
persisted = fullAnswer
}
- if pErr := s.persistChatbotTurn(ctx, session, question, persisted, messageID, finalRef, completedAt); pErr != nil {
+ saveCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ if pErr := s.persistChatbotTurn(saveCtx, session, question, persisted, messageID, finalRef, completedAt); pErr != nil {
common.Error("bot: ChatbotCompletion session update failed", pErr, zap.String("dialog_id", session.DialogID), zap.String("session_id", session.ID))
}
+ cancel()
}
finalData := ""
if rawAnswer == "" || errored {
@@ -515,11 +529,13 @@ func (s *BotService) streamChatbotTurn(
// client would see a silently truncated answer.
finalData = fullAnswer
}
- out <- ChatbotSSEFrame{
+ if !sendFrame(ChatbotSSEFrame{
Data: finalData,
Reference: referenceOrEmpty(finalRef),
SessionID: session.ID,
Final: true,
+ }) {
+ return
}
continue
}
@@ -531,12 +547,14 @@ func (s *BotService) streamChatbotTurn(
} else {
rawAnswer += "</think>"
}
- out <- ChatbotSSEFrame{
+ if !sendFrame(ChatbotSSEFrame{
Data: "",
Reference: map[string]any{},
SessionID: session.ID,
StartToThink: res.StartToThink,
EndToThink: res.EndToThink,
+ }) {
+ return
}
continue
}
@@ -568,14 +586,16 @@ func (s *BotService) streamChatbotTurn(
// carries the retrieval reference.
finalRef = res.Reference
}
- out <- ChatbotSSEFrame{
+ if !sendFrame(ChatbotSSEFrame{
Data: delta,
Reference: map[string]any{},
SessionID: session.ID,
+ }) {
+ return
}
}
- out <- ChatbotSSEFrame{Done: true}
+ sendFrame(ChatbotSSEFrame{Done: true})
}()
return out
}
diff --git a/internal/service/bot_completion_history_test.go b/internal/service/bot_completion_history_test.go
index e141b4ade9..5890a270d8 100644
--- a/internal/service/bot_completion_history_test.go
+++ b/internal/service/bot_completion_history_test.go
@@ -26,6 +26,7 @@ package service
import (
"bytes"
+ "context"
"encoding/json"
"errors"
"fmt"
@@ -34,6 +35,7 @@ import (
"strings"
"sync"
"testing"
+ "time"
"ragflow/internal/agent/canvas"
"ragflow/internal/common"
@@ -968,3 +970,53 @@ func TestStreamChatbotTurn_ReasoningFieldForwardedAsStreamText(t *testing.T) {
t.Errorf("persisted assistant content = %v, want <think>推理中</think>结论", got)
}
}
+
+func TestStreamChatbotTurn_ContextCancellationUnblocksFullChannel(t *testing.T) {
+ db := setupServiceTestDB(t)
+ pushServiceDB(t, db)
+
+ seedStreamTurnSession(t, "sess-cancel-leak", "q_leak", "msg-leak")
+ svc := NewBotService(nil)
+
+ ctx, cancel := context.WithCancel(context.Background())
+
+ results := make(chan AsyncChatResult, 30)
+ for i := 0; i < 30; i++ {
+ results <- AsyncChatResult{Answer: fmt.Sprintf("chunk-%d", i)}
+ }
+ close(results)
+
+ sess := &entity.API4Conversation{ID: "sess-cancel-leak", DialogID: "dlg-s1", UserID: "tenant-1"}
+
+ // Cancel context to simulate client disconnect while channel buffer is full
+ cancel()
+
+ frames := svc.streamChatbotTurn(ctx, sess, "q_leak", "msg-leak", results)
+
+ // Do NOT drain concurrently. streamChatbotTurn should detect ctx.Done()
+ // and close frames promptly.
+ timeout := time.After(2 * time.Second)
+ for {
+ select {
+ case _, ok := <-frames:
+ if !ok {
+ goto verified
+ }
+ case <-timeout:
+ t.Fatal("streamChatbotTurn leaked: did not terminate when context was cancelled")
+ }
+ }
+
+verified:
+ // The user question is preserved in history; failure/cancellation leaves it intact.
+ row, err := dao.NewAPI4ConversationDAO().GetBySessionID(context.Background(), dao.DB, "sess-cancel-leak", "dlg-s1")
+ if err != nil {
+ t.Fatalf("re-read session: %v", err)
+ }
+ if row != nil {
+ turns := parseChatbotTurns(row.Message)
+ if len(turns) != 1 || turns[0]["id"] != "msg-leak" {
+ t.Fatalf("expected user turn to be preserved in history, got: %+v", turns)
+ }
+ }
+}
diff --git a/internal/service/chat_pipeline.go b/internal/service/chat_pipeline.go
index 388842d7a5..6c2109b683 100644
--- a/internal/service/chat_pipeline.go
+++ b/internal/service/chat_pipeline.go
@@ -312,15 +312,27 @@ func (s *ChatPipelineService) AsyncChat(
timer := common.NewTimer()
timer.Start()
+ sendResult := func(res AsyncChatResult) bool {
+ if ctx.Err() != nil {
+ return false
+ }
+ select {
+ case out <- res:
+ return true
+ case <-ctx.Done():
+ return false
+ }
+ }
+
// === Phase 2: Resolve LLM Model Config + max_tokens ===
common.Info("Phase 2: Resolve LLM Model Config + max_tokens")
timer.Enter(common.PhaseCheckLLM)
llmModelConfig, _, _, _, err := s.getLLMModelConfig(ctx, chat)
if err != nil {
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: fmt.Sprintf("**ERROR**: %s", err.Error()),
Final: true,
- }
+ })
return
}
modelMaxTokens := 8192
@@ -358,10 +370,10 @@ func (s *ChatPipelineService) AsyncChat(
timer.Enter(common.PhaseBindModels)
kbs, embModel, rerankModel, chatModel, ttsModel, err := s.getModels(ctx, chat)
if err != nil {
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: fmt.Sprintf("**ERROR**: %s", err.Error()),
Final: true,
- }
+ })
return
}
@@ -531,11 +543,11 @@ func (s *ChatPipelineService) AsyncChat(
s.enrichChunksWithMetadata(ctx, kbinfos, chat.TenantID, metadataFields)
}
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: ansStr,
Reference: ans["reference"].(map[string]interface{}),
Final: true,
- }
+ })
return
}
common.Info("SQL retrieval: no valid result, falling back to vector search")
@@ -608,10 +620,10 @@ func (s *ChatPipelineService) AsyncChat(
optional, _ := pMap["optional"].(bool)
if !optional {
// Required parameter missing => fail fast
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: fmt.Sprintf("**ERROR**: Miss parameter: %s", key),
Final: true,
- }
+ })
return
}
// Optional parameter missing => erase placeholder from system prompt
@@ -782,10 +794,10 @@ func (s *ChatPipelineService) AsyncChat(
}
if err != nil {
common.Warn("Retrieval failed", zap.Error(err))
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: fmt.Sprintf("**ERROR**: %s", err.Error()),
Final: true,
- }
+ })
return
}
}
@@ -899,17 +911,19 @@ func (s *ChatPipelineService) AsyncChat(
if !quote {
finalReference = map[string]interface{}{}
}
- out <- AsyncChatResult{
+ if !sendResult(AsyncChatResult{
Answer: emptyResp,
Reference: map[string]interface{}{},
+ }) {
+ return
}
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: emptyResp,
Reference: finalReference,
AudioBinary: s.synthesizeTTS(ctx, ttsModel, emptyResp),
Prompt: fmt.Sprintf("\n\n### Query:\n%s", strings.Join(questions, " ")),
Final: true,
- }
+ })
return
}
}
@@ -1030,10 +1044,10 @@ func (s *ChatPipelineService) AsyncChat(
}
if len(llmMessages) < 2 {
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: "**ERROR**: message_fit_in has bug",
Final: true,
- }
+ })
return
}
@@ -1053,10 +1067,10 @@ func (s *ChatPipelineService) AsyncChat(
citationTokens = graph.NumTokensFromString(prompt4citation)
}
if adjusted, ok, err := clampChatConfigMaxTokens(chatCfg, modelMaxTokens, usedTokenCount+citationTokens); err != nil {
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: fmt.Sprintf("**ERROR**: %s", err.Error()),
Final: true,
- }
+ })
return
} else if ok {
common.Debug("Adjusted max_tokens", zap.Int("max_tokens in chat", adjusted))
@@ -1072,10 +1086,10 @@ func (s *ChatPipelineService) AsyncChat(
timer.Enter(common.PhaseGenerateAnswer)
chatDriver := s.buildChatDriver(ctx, chat, chatModel)
if chatDriver == nil {
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: "**ERROR**: No chat model available for this chat.",
Final: true,
- }
+ })
return
}
chatMessages := s.buildChatMessages(prompt+prompt4citation, llmMessages[1:])
@@ -1122,32 +1136,36 @@ func (s *ChatPipelineService) AsyncChat(
var fullAnswer string
thinkState := &ThinkStreamState{}
var answerFilter, reasoningFilter citationStreamFilter
- emit := func(result AsyncChatResult) {
+ emit := func(result AsyncChatResult) bool {
if !result.Final && result.Answer != "" {
result.AudioBinary = s.synthesizeTTS(ctx, ttsModel, result.Answer)
}
- out <- result
+ return sendResult(result)
}
- send := func(result AsyncChatResult) {
+ send := func(result AsyncChatResult) bool {
if !quote {
// Flush before a boundary so buffered text stays in its section.
if result.StartToThink || result.EndToThink || result.Final {
if text := reasoningFilter.flush(); text != "" {
- emit(AsyncChatResult{Reasoning: text, Reference: map[string]interface{}{}, CreatedAt: float64(time.Now().Unix())})
+ if !emit(AsyncChatResult{Reasoning: text, Reference: map[string]interface{}{}, CreatedAt: float64(time.Now().Unix())}) {
+ return false
+ }
}
if text := answerFilter.flush(); text != "" {
- emit(AsyncChatResult{Answer: text, Reference: map[string]interface{}{}, CreatedAt: float64(time.Now().Unix())})
+ if !emit(AsyncChatResult{Answer: text, Reference: map[string]interface{}{}, CreatedAt: float64(time.Now().Unix())}) {
+ return false
+ }
}
}
if !result.Final && (result.Answer != "" || result.Reasoning != "") {
result.Answer = answerFilter.write(result.Answer)
result.Reasoning = reasoningFilter.write(result.Reasoning)
if result.Answer == "" && result.Reasoning == "" {
- return
+ return true
}
}
}
- emit(result)
+ return emit(result)
}
// Tool routing: use tool-loop method when tools are bound.
@@ -1167,47 +1185,55 @@ func (s *ChatPipelineService) AsyncChat(
if text == "<think>" {
inThink = true
- send(AsyncChatResult{
+ if !send(AsyncChatResult{
Answer: "",
Reference: map[string]interface{}{},
AudioBinary: nil,
CreatedAt: float64(time.Now().Unix()),
Final: false,
StartToThink: true,
- })
+ }) {
+ return ctx.Err()
+ }
return nil
}
if text == "</think>" {
inThink = false
- send(AsyncChatResult{
+ if !send(AsyncChatResult{
Answer: "",
Reference: map[string]interface{}{},
AudioBinary: nil,
CreatedAt: float64(time.Now().Unix()),
Final: false,
EndToThink: true,
- })
+ }) {
+ return ctx.Err()
+ }
return nil
}
if inThink {
// Reasoning text — route to Reasoning field so
// the SSE handler maps it to
// `delta.reasoning_content`.
- send(AsyncChatResult{
+ if !send(AsyncChatResult{
Reasoning: text,
Reference: map[string]interface{}{},
AudioBinary: nil,
CreatedAt: float64(time.Now().Unix()),
Final: false,
- })
+ }) {
+ return ctx.Err()
+ }
} else {
// Regular answer content
- send(AsyncChatResult{
+ if !send(AsyncChatResult{
Answer: text,
Reference: map[string]interface{}{},
CreatedAt: float64(time.Now().Unix()),
Final: false,
- })
+ }) {
+ return ctx.Err()
+ }
}
return nil
})
@@ -1217,25 +1243,29 @@ func (s *ChatPipelineService) AsyncChat(
func(answer *string, reason *string) error {
if reason != nil && *reason != "" {
if thinkState.EnterReasoning() {
- send(AsyncChatResult{
+ if !send(AsyncChatResult{
Answer: "",
Reference: map[string]interface{}{},
AudioBinary: nil,
CreatedAt: float64(time.Now().Unix()),
Final: false,
StartToThink: true,
- })
+ }) {
+ return ctx.Err()
+ }
}
deltas := NextThinkDelta(thinkState, *reason, 16)
for _, d := range deltas {
if d.Kind == ThinkDeltaText && d.Value != "" {
fullAnswer += d.Value
- send(AsyncChatResult{
+ if !send(AsyncChatResult{
Answer: d.Value,
Reference: map[string]interface{}{},
CreatedAt: float64(time.Now().Unix()),
Final: false,
- })
+ }) {
+ return ctx.Err()
+ }
}
}
}
@@ -1244,33 +1274,39 @@ func (s *ChatPipelineService) AsyncChat(
for _, d := range FlushRemaining(thinkState) {
if d.Kind == ThinkDeltaText && d.Value != "" {
fullAnswer += d.Value
- send(AsyncChatResult{
+ if !send(AsyncChatResult{
Answer: d.Value,
Reference: map[string]interface{}{},
CreatedAt: float64(time.Now().Unix()),
Final: false,
- })
+ }) {
+ return ctx.Err()
+ }
}
}
- send(AsyncChatResult{
+ if !send(AsyncChatResult{
Answer: "",
Reference: map[string]interface{}{},
AudioBinary: nil,
CreatedAt: float64(time.Now().Unix()),
Final: false,
EndToThink: true,
- })
+ }) {
+ return ctx.Err()
+ }
}
fullAnswer += *answer
deltas := BufferAnswerDelta(thinkState, *answer, 16)
for _, d := range deltas {
if d.Kind == ThinkDeltaText && d.Value != "" {
- send(AsyncChatResult{
+ if !send(AsyncChatResult{
Answer: d.Value,
Reference: map[string]interface{}{},
CreatedAt: float64(time.Now().Unix()),
Final: false,
- })
+ }) {
+ return ctx.Err()
+ }
}
}
}
@@ -1279,6 +1315,9 @@ func (s *ChatPipelineService) AsyncChat(
)
}
if driverErr != nil {
+ if ctx.Err() != nil {
+ return
+ }
send(AsyncChatResult{
Answer: fmt.Sprintf("**ERROR**: %s", driverErr.Error()),
Final: true,
@@ -1286,6 +1325,9 @@ func (s *ChatPipelineService) AsyncChat(
return
}
timer.Exit(common.PhaseGenerateAnswer)
+ if ctx.Err() != nil {
+ return
+ }
// Flush remaining state matching Python's final flush order
// (dialog_service.py:1601-1612): think_buffer → marker → answer_buffer → pending_after_close
@@ -1294,35 +1336,41 @@ func (s *ChatPipelineService) AsyncChat(
for _, d := range FlushRemaining(thinkState) {
if d.Kind == ThinkDeltaMarker && d.Value == "</think>" {
hadThinkClose = true
- send(AsyncChatResult{
+ if !send(AsyncChatResult{
Answer: "",
Reference: map[string]interface{}{},
AudioBinary: nil,
CreatedAt: float64(time.Now().Unix()),
Final: false,
EndToThink: true,
- })
+ }) {
+ return
+ }
} else if d.Kind == ThinkDeltaText && d.Value != "" {
- send(AsyncChatResult{
+ if !send(AsyncChatResult{
Answer: d.Value,
Reference: map[string]interface{}{},
CreatedAt: float64(time.Now().Unix()),
Final: false,
- })
+ }) {
+ return
+ }
}
}
// Close reasoning if the stream ended while still in reasoning mode
// (e.g. model returned only reasoning chunks with no content delta).
// Skip when FlushRemaining already emitted a </think> marker.
if !hadThinkClose && thinkState.ExitReasoning() {
- send(AsyncChatResult{
+ if !send(AsyncChatResult{
Answer: "",
Reference: map[string]interface{}{},
AudioBinary: nil,
CreatedAt: float64(time.Now().Unix()),
Final: false,
EndToThink: true,
- })
+ }) {
+ return
+ }
}
// Decorate and yield the final answer.
@@ -1353,10 +1401,10 @@ func (s *ChatPipelineService) AsyncChat(
timer.Exit(common.PhaseGenerateAnswer)
if err != nil {
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: fmt.Sprintf("**ERROR**: %s", err.Error()),
Final: true,
- }
+ })
return
}
@@ -1372,7 +1420,7 @@ func (s *ChatPipelineService) AsyncChat(
// Synthesize TTS for the full answer (non-stream, one-shot).
final := s.decorateAnswer(ctx, answer, kbinfos, prompt, questions, usedTokenCount, timer, embModel, chat.VectorSimilarityWeight, quote, ttsModel, langfuseTraceID, llmModelConfig, chat.TenantID, kbTenantIDStrings(kbs), len(knowledges) > 0)
final.Final = true
- out <- final
+ sendResult(final)
}
common.Info("AsyncChat completed", zap.String("chat_id", chat.ID))
}()
@@ -1443,6 +1491,18 @@ func (s *ChatPipelineService) AsyncChatSolo(
timer := common.NewTimer()
timer.Start()
+ sendResult := func(res AsyncChatResult) bool {
+ if ctx.Err() != nil {
+ return false
+ }
+ select {
+ case out <- res:
+ return true
+ case <-ctx.Done():
+ return false
+ }
+ }
+
// 1. Resolve system prompt.
promptConfig := chat.PromptConfig
systemPrompt := ""
@@ -1520,10 +1580,10 @@ func (s *ChatPipelineService) AsyncChatSolo(
chatModel, err = s.ModelFactory.NewChatModel(ctx, access, chat.LLMID)
}
if err != nil {
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: fmt.Sprintf("**ERROR**: %s", err.Error()),
Final: true,
- }
+ })
return
}
@@ -1578,25 +1638,29 @@ func (s *ChatPipelineService) AsyncChatSolo(
func(answer *string, reason *string) error {
if reason != nil && *reason != "" {
if thinkState.EnterReasoning() {
- out <- AsyncChatResult{
+ if !sendResult(AsyncChatResult{
Answer: "",
Reference: map[string]interface{}{},
AudioBinary: nil,
CreatedAt: float64(time.Now().Unix()),
Final: false,
StartToThink: true,
+ }) {
+ return ctx.Err()
}
}
deltas := NextThinkDelta(thinkState, *reason, 16)
for _, d := range deltas {
if d.Kind == ThinkDeltaText && d.Value != "" {
fullAnswer += d.Value
- out <- AsyncChatResult{
+ if !sendResult(AsyncChatResult{
Answer: d.Value,
Reference: map[string]interface{}{},
AudioBinary: s.synthesizeTTS(ctx, ttsModel, d.Value),
CreatedAt: float64(time.Now().Unix()),
Final: false,
+ }) {
+ return ctx.Err()
}
}
}
@@ -1606,34 +1670,40 @@ func (s *ChatPipelineService) AsyncChatSolo(
for _, d := range FlushRemaining(thinkState) {
if d.Kind == ThinkDeltaText && d.Value != "" {
fullAnswer += d.Value
- out <- AsyncChatResult{
+ if !sendResult(AsyncChatResult{
Answer: d.Value,
Reference: map[string]interface{}{},
AudioBinary: s.synthesizeTTS(ctx, ttsModel, d.Value),
CreatedAt: float64(time.Now().Unix()),
Final: false,
+ }) {
+ return ctx.Err()
}
}
}
- out <- AsyncChatResult{
+ if !sendResult(AsyncChatResult{
Answer: "",
Reference: map[string]interface{}{},
AudioBinary: nil,
CreatedAt: float64(time.Now().Unix()),
Final: false,
EndToThink: true,
+ }) {
+ return ctx.Err()
}
}
fullAnswer += *answer
deltas := BufferAnswerDelta(thinkState, *answer, 16)
for _, d := range deltas {
if d.Kind == ThinkDeltaText && d.Value != "" {
- out <- AsyncChatResult{
+ if !sendResult(AsyncChatResult{
Answer: d.Value,
Reference: map[string]interface{}{},
AudioBinary: s.synthesizeTTS(ctx, ttsModel, d.Value),
CreatedAt: float64(time.Now().Unix()),
Final: false,
+ }) {
+ return ctx.Err()
}
}
}
@@ -1642,10 +1712,16 @@ func (s *ChatPipelineService) AsyncChatSolo(
},
)
if driverErr != nil {
- out <- AsyncChatResult{
+ if ctx.Err() != nil {
+ return
+ }
+ sendResult(AsyncChatResult{
Answer: fmt.Sprintf("**ERROR**: %s", driverErr.Error()),
Final: true,
- }
+ })
+ return
+ }
+ if ctx.Err() != nil {
return
}
timer.Exit(common.PhaseGenerateAnswer)
@@ -1653,21 +1729,25 @@ func (s *ChatPipelineService) AsyncChatSolo(
for _, d := range FlushRemaining(thinkState) {
if d.Kind == ThinkDeltaMarker && d.Value == "</think>" {
hadThinkClose = true
- out <- AsyncChatResult{
+ if !sendResult(AsyncChatResult{
Answer: "",
Reference: map[string]interface{}{},
AudioBinary: nil,
CreatedAt: float64(time.Now().Unix()),
Final: false,
EndToThink: true,
+ }) {
+ return
}
} else if d.Kind == ThinkDeltaText && d.Value != "" {
- out <- AsyncChatResult{
+ if !sendResult(AsyncChatResult{
Answer: d.Value,
Reference: map[string]interface{}{},
AudioBinary: s.synthesizeTTS(ctx, ttsModel, d.Value),
CreatedAt: float64(time.Now().Unix()),
Final: false,
+ }) {
+ return
}
}
}
@@ -1675,26 +1755,28 @@ func (s *ChatPipelineService) AsyncChatSolo(
// (e.g. model returned only reasoning chunks with no content delta).
// Skip when FlushRemaining already emitted a </think> marker.
if !hadThinkClose && thinkState.ExitReasoning() {
- out <- AsyncChatResult{
+ if !sendResult(AsyncChatResult{
Answer: "",
Reference: map[string]interface{}{},
AudioBinary: nil,
CreatedAt: float64(time.Now().Unix()),
Final: false,
EndToThink: true,
+ }) {
+ return
}
}
finalAnswer := ExtractVisibleAnswer(thinkState.fullText)
if finalAnswer == "" {
finalAnswer = fullAnswer
}
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: finalAnswer,
Reference: map[string]interface{}{},
AudioBinary: nil,
CreatedAt: float64(time.Now().Unix()),
Final: true,
- }
+ })
} else {
// Non-streaming: one-shot call.
chatCfg := BuildChatConfig(chat, config)
@@ -1702,10 +1784,10 @@ func (s *ChatPipelineService) AsyncChatSolo(
resp, err := chatModel.ChatWithMessages(ctx, chatMessages, chatCfg, nil)
timer.Exit(common.PhaseGenerateAnswer)
if err != nil {
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: fmt.Sprintf("**ERROR**: %s", err.Error()),
Final: true,
- }
+ })
return
}
answer := ""
@@ -1722,13 +1804,13 @@ func (s *ChatPipelineService) AsyncChatSolo(
common.Debug("User: " + userContent + "|Assistant: " + answer)
// Raw answer with full TTS, no decorate_answer. Caller handles decoration.
- out <- AsyncChatResult{
+ sendResult(AsyncChatResult{
Answer: answer,
Reference: map[string]interface{}{},
AudioBinary: s.synthesizeTTS(ctx, ttsModel, answer),
CreatedAt: float64(time.Now().Unix()),
Final: true,
- }
+ })
}
}()
diff --git a/internal/service/chat_pipeline_test.go b/internal/service/chat_pipeline_test.go
index 0b6c5685de..ea6cfa605c 100644
--- a/internal/service/chat_pipeline_test.go
+++ b/internal/service/chat_pipeline_test.go
@@ -24,6 +24,7 @@ import (
"sort"
"strings"
"testing"
+ "time"
"github.com/glebarez/sqlite"
"gorm.io/gorm"
@@ -2251,3 +2252,33 @@ func TestSynthesizeTTS_CleansTextBeforeCallingDriver(t *testing.T) {
})
}
}
+
+func TestAsyncChat_ContextCancellationTerminatesGoroutine(t *testing.T) {
+ db := setupChatPipelineVisionTestDB(t)
+ seedChatPipelineVisionTenant(t, db, "glm-4-flash@ZHIPU-AI")
+
+ ctx, cancel := context.WithCancel(context.Background())
+ cancel() // pre-cancel context to simulate client disconnect
+
+ chat := dialForTest("glm-4-flash@ZHIPU-AI")
+ results, err := NewChatPipelineService().AsyncChat(ctx, "user-1", chat,
+ []map[string]interface{}{{"role": "user", "content": "Question"}}, true, nil)
+ if err != nil {
+ t.Fatal(err)
+ }
+
+ // Do NOT drain results with a background goroutine.
+ // AsyncChat must detect pre-cancelled context, exit, and close results.
+ timeout := time.After(2 * time.Second)
+ for {
+ select {
+ case _, ok := <-results:
+ if !ok {
+ // success: AsyncChat goroutine exited cleanly without leaking
+ return
+ }
+ case <-timeout:
+ t.Fatal("AsyncChat goroutine leaked: did not terminate when context was cancelled")
+ }
+ }
+}
diff --git a/internal/service/chat_session.go b/internal/service/chat_session.go
index 2215f424cd..31db912ad4 100644
--- a/internal/service/chat_session.go
+++ b/internal/service/chat_session.go
@@ -1115,12 +1115,15 @@ func (s *ChatSessionService) ChatCompletions(
receivedAt := float64(time.Now().UnixNano()) / 1e9
fail := func(err error) (map[string]interface{}, error) {
if stream && streamChan != nil {
- s.sendSSEError(streamChan, err.Error())
+ s.sendSSEError(ctx, streamChan, err.Error())
}
return nil, err
}
sendOrCancel := func(data string) bool {
+ if ctx.Err() != nil {
+ return false
+ }
select {
case streamChan <- data:
return true
@@ -1262,6 +1265,9 @@ func (s *ChatSessionService) ChatCompletions(
var finalLegacyAnswer map[string]interface{}
for result := range resultChan {
+ if ctx.Err() != nil {
+ break
+ }
if result.Reference != nil && len(reference) > 0 {
reference[len(reference)-1] = result.Reference
}
@@ -1274,15 +1280,17 @@ func (s *ChatSessionService) ChatCompletions(
content = result.Answer
}
s.appendAssistantToSession(session, content, messageID)
- if ctx.Err() == nil {
- messages := s.getSessionMessagesAsSlice(session)
+ messages := s.getSessionMessagesAsSlice(session)
+ if len(messages) > 0 {
message := messages[len(messages)-1]
if result.Prompt != "" {
message["prompt"] = result.Prompt
}
attachTurnCost(message, result)
- s.updateSessionMessages(ctx, session, messages, reference)
}
+ saveCtx, saveCancel := context.WithTimeout(context.Background(), 5*time.Second)
+ s.updateSessionMessages(saveCtx, session, messages, reference)
+ saveCancel()
}
if result.AnswerIsAuthoritative {
fullAnswer.Reset()
@@ -1296,7 +1304,9 @@ func (s *ChatSessionService) ChatCompletions(
if chatID != "" {
ans["chat_id"] = chatID
}
- sendOrCancel(fmt.Sprintf("data:%s\n\n", sseMarshalChunk(sanitizeJSONFloats(ans).(map[string]interface{}), chatID)))
+ if !sendOrCancel(fmt.Sprintf("data:%s\n\n", sseMarshalChunk(sanitizeJSONFloats(ans).(map[string]interface{}), chatID))) {
+ break
+ }
}
// Synchronize the in-memory session snapshot with the final
// event before building the response. This does not write
@@ -1337,7 +1347,9 @@ func (s *ChatSessionService) ChatCompletions(
if chatID != "" {
ans["chat_id"] = chatID
}
- sendOrCancel(fmt.Sprintf("data:%s\n\n", sseMarshalChunk(sanitizeJSONFloats(ans).(map[string]interface{}), chatID)))
+ if !sendOrCancel(fmt.Sprintf("data:%s\n\n", sseMarshalChunk(sanitizeJSONFloats(ans).(map[string]interface{}), chatID))) {
+ break
+ }
} else {
if result.Final {
// Synchronize the in-memory session snapshot with the final
@@ -1349,7 +1361,9 @@ func (s *ChatSessionService) ChatCompletions(
if chatID != "" {
ans["chat_id"] = chatID
}
- sendOrCancel(fmt.Sprintf("data:%s\n\n", sseMarshalChunk(sanitizeJSONFloats(ans).(map[string]interface{}), chatID)))
+ if !sendOrCancel(fmt.Sprintf("data:%s\n\n", sseMarshalChunk(sanitizeJSONFloats(ans).(map[string]interface{}), chatID))) {
+ break
+ }
} else {
ans := s.structureAnswer(session, result.Answer, messageID, sessionID, reference)
if result.Reference != nil {
@@ -1365,7 +1379,9 @@ func (s *ChatSessionService) ChatCompletions(
if chatID != "" {
ans["chat_id"] = chatID
}
- sendOrCancel(fmt.Sprintf("data:%s\n\n", sseMarshalChunk(sanitizeJSONFloats(ans).(map[string]interface{}), chatID)))
+ if !sendOrCancel(fmt.Sprintf("data:%s\n\n", sseMarshalChunk(sanitizeJSONFloats(ans).(map[string]interface{}), chatID))) {
+ break
+ }
}
continue
}
@@ -1418,10 +1434,12 @@ func (s *ChatSessionService) ChatCompletions(
if chatID != "" {
ans["chat_id"] = chatID
}
- sendOrCancel(fmt.Sprintf("data:%s\n\n", sseMarshalChunk(sanitizeJSONFloats(ans).(map[string]interface{}), chatID)))
+ if !sendOrCancel(fmt.Sprintf("data:%s\n\n", sseMarshalChunk(sanitizeJSONFloats(ans).(map[string]interface{}), chatID))) {
+ break
+ }
}
}
- if legacy && finalLegacyAnswer != nil {
+ if legacy && finalLegacyAnswer != nil && ctx.Err() == nil {
finalLegacyAnswer["answer"] = fullAnswer.String()
delete(finalLegacyAnswer, "start_to_think")
delete(finalLegacyAnswer, "end_to_think")
@@ -1429,8 +1447,10 @@ func (s *ChatSessionService) ChatCompletions(
sendOrCancel(fmt.Sprintf("data:%s\n\n", marshalJSONWithSpaces(finalChunk)))
}
- wrapper := sseWrapper{Code: 0, Message: "success", Data: true}
- sendOrCancel(fmt.Sprintf("data:%s\n\n", marshalJSONWithSpaces(wrapper)))
+ if ctx.Err() == nil {
+ wrapper := sseWrapper{Code: 0, Message: "success", Data: true}
+ sendOrCancel(fmt.Sprintf("data:%s\n\n", marshalJSONWithSpaces(wrapper)))
+ }
} else {
ans := accumulateNonStreamAnswer(resultChan)
if session != nil {
@@ -1439,7 +1459,9 @@ func (s *ChatSessionService) ChatCompletions(
result["chat_id"] = chatID
}
if ctx.Err() == nil && !strings.Contains(stringValue(ans["answer"]), "**ERROR**") {
- s.updateSessionMessages(ctx, session, s.getSessionMessagesAsSlice(session), reference)
+ saveCtx, saveCancel := context.WithTimeout(context.Background(), 5*time.Second)
+ s.updateSessionMessages(saveCtx, session, s.getSessionMessagesAsSlice(session), reference)
+ saveCancel()
}
return sanitizeJSONFloats(result).(map[string]interface{}), nil
}
@@ -1763,7 +1785,7 @@ func (s *ChatSessionService) getSessionMessagesAsSlice(session *entity.ChatSessi
}
// sendSSEError sends an error in SSE format through the stream channel.
-func (s *ChatSessionService) sendSSEError(streamChan chan<- string, errMsg string) {
+func (s *ChatSessionService) sendSSEError(ctx context.Context, streamChan chan<- string, errMsg string) {
wrapper := sseWrapper{
Code: 500,
Message: errMsg,
@@ -1772,7 +1794,13 @@ func (s *ChatSessionService) sendSSEError(streamChan chan<- string, errMsg strin
"reference": []interface{}{},
},
}
- streamChan <- fmt.Sprintf("data:%s\n\n", marshalJSONWithSpaces(wrapper))
+ if ctx != nil && ctx.Err() != nil {
+ return
+ }
+ select {
+ case streamChan <- fmt.Sprintf("data:%s\n\n", marshalJSONWithSpaces(wrapper)):
+ case <-ctx.Done():
+ }
}
// Helper methods
diff --git a/internal/service/chat_session_test.go b/internal/service/chat_session_test.go
index a863253b22..b46649eceb 100644
--- a/internal/service/chat_session_test.go
+++ b/internal/service/chat_session_test.go
@@ -1967,3 +1967,59 @@ func TestChatCompletions_SharedSessionReadonlyForTeammate(t *testing.T) {
t.Fatalf("update calls=%d, want 0", len(store.updateCalled))
}
}
+
+func TestChatCompletions_CancelledNonStreamDoesNotPersistBlankTurn(t *testing.T) {
+ store := newFakeSessionStore()
+ store.sessions["session-1"] = &entity.ChatSession{
+ ID: "session-1",
+ DialogID: "chat-1",
+ UserID: strPtr("user-1"),
+ Message: json.RawMessage(`[{"role":"user","content":"hello"}]`),
+ }
+ store.dialogs["chat-1"] = &entity.Chat{
+ ID: "chat-1",
+ TenantID: "user-1",
+ LLMID: "chat@factory",
+ LLMSetting: entity.JSONMap{},
+ PromptConfig: entity.JSONMap{"parameters": []interface{}{}},
+ }
+ store.dialogExists["user-1|chat-1"] = true
+
+ ctx, cancel := context.WithCancel(context.Background())
+ cancel()
+
+ // Pipeline returns an empty channel because context was cancelled
+ ch := make(chan AsyncChatResult)
+ close(ch)
+ pipeline := &fakePipeline{resultChan: ch}
+
+ svc := &ChatSessionService{
+ chatSessionDAO: store,
+ permissionChecker: store,
+ pipeline: pipeline,
+ }
+
+ _, _ = svc.ChatCompletions(
+ ctx,
+ "user-1",
+ "chat-1",
+ "session-1",
+ nil,
+ "cancelled question",
+ nil, "", nil, nil,
+ false, false, nil,
+ )
+
+ // The initial user question is saved (1 update), but no assistant turn
+ // should be persisted via updateSessionMessages when context is cancelled.
+ if len(store.updateCalled) != 1 {
+ t.Fatalf("expected 1 updateByID call for user question, got %d", len(store.updateCalled))
+ }
+ for _, call := range store.updateCalled {
+ if hu, ok := call.updates["history_update"].(dao.ConversationHistoryUpdate); ok {
+ if hu.Message["role"] == "assistant" {
+ t.Fatalf("assistant message should not be persisted on cancelled context: %v", hu.Message)
+ }
+ }
+ }
+}
diff --git a/internal/service/openai_chat.go b/internal/service/openai_chat.go
index 54547c8780..3ef0e733f7 100644
--- a/internal/service/openai_chat.go
+++ b/internal/service/openai_chat.go
@@ -237,7 +237,8 @@ func (s *OpenAIChatService) OpenAIChatCompletions(c *gin.Context, userID, chatID
}
}
- ctx := c.Request.Context()
+ ctx, cancel := context.WithCancel(c.Request.Context())
+ defer cancel()
dialogResp, err := s.chatSvc.GetChat(ctx, userID, chatID)
if err != nil {
if permissionresponse.IsPermissionError(err) {
@@ -351,10 +352,23 @@ func (s *OpenAIChatService) OpenAIChatCompletions(c *gin.Context, userID, chatID
events := make(chan OpenAIStreamEvent, 16)
go func() {
defer close(events)
+
+ sendEvent := func(ev OpenAIStreamEvent) bool {
+ if ctx.Err() != nil {
+ return false
+ }
+ select {
+ case events <- ev:
+ return true
+ case <-ctx.Done():
+ return false
+ }
+ }
+
defer func() {
if r := recover(); r != nil {
common.Warn("OpenAI streaming goroutine panic", zap.Any("recover", r))
- events <- OpenAIStreamEvent{Kind: OpenAIEventError, Error: fmt.Sprintf("internal error: %v", r)}
+ _ = sendEvent(OpenAIStreamEvent{Kind: OpenAIEventError, Error: fmt.Sprintf("internal error: %v", r)})
}
}()
@@ -367,6 +381,9 @@ func (s *OpenAIChatService) OpenAIChatCompletions(c *gin.Context, userID, chatID
)
for result := range asyncResults {
+ if ctx.Err() != nil {
+ return
+ }
lastResult = result
// Think markers only toggle routing state — Python never emits
@@ -391,27 +408,31 @@ func (s *OpenAIChatService) OpenAIChatCompletions(c *gin.Context, userID, chatID
}
s.enrichChunksWithDocumentMetadata(ctx, finalReference, dialog.TenantID, openaiReq.IncludeRefMetadata, openaiReq.MetadataFields)
completionTok = tokenizer.NumTokensFromString(finalContent)
- events <- OpenAIStreamEvent{
+ _ = sendEvent(OpenAIStreamEvent{
Kind: OpenAIEventFinal,
FinalAnswer: finalContent,
FinalReference: finalReference,
PromptTokens: promptTokens,
CompletionTokens: completionTok,
TotalTokens: promptTokens + completionTok,
- }
+ })
return
}
if result.Reasoning != "" {
completionTok += tokenizer.NumTokensFromString(result.Reasoning)
- events <- OpenAIStreamEvent{Kind: OpenAIEventReasoning, Delta: result.Reasoning}
+ if !sendEvent(OpenAIStreamEvent{Kind: OpenAIEventReasoning, Delta: result.Reasoning}) {
+ return
+ }
}
if result.Answer != "" {
delta := result.Answer
fullContent += delta
completionTok += tokenizer.NumTokensFromString(delta)
- events <- OpenAIStreamEvent{Kind: OpenAIEventContent, Delta: delta}
+ if !sendEvent(OpenAIStreamEvent{Kind: OpenAIEventContent, Delta: delta}) {
+ return
+ }
if deltaCount < 3 {
common.Debug("OpenAI first content delta",
zap.Int("delta_index", deltaCount),
@@ -422,6 +443,10 @@ func (s *OpenAIChatService) OpenAIChatCompletions(c *gin.Context, userID, chatID
}
}
+ if ctx.Err() != nil {
+ return
+ }
+
if finalReference == nil && openaiReq.NeedReference {
finalReference = []FormattedChunk{}
if ref, ok := lastResult.Reference["chunks"]; ok {
@@ -431,16 +456,17 @@ func (s *OpenAIChatService) OpenAIChatCompletions(c *gin.Context, userID, chatID
}
}
s.enrichChunksWithDocumentMetadata(ctx, finalReference, dialog.TenantID, openaiReq.IncludeRefMetadata, openaiReq.MetadataFields)
- events <- OpenAIStreamEvent{
+ _ = sendEvent(OpenAIStreamEvent{
Kind: OpenAIEventFinal,
FinalAnswer: strings.TrimSpace(fullContent),
FinalReference: finalReference,
PromptTokens: promptTokens,
CompletionTokens: completionTok,
TotalTokens: promptTokens + completionTok,
- }
+ })
}()
if err := streamChatCompletionSSE(c, events, completionID, resolvedModel, openaiReq.NeedReference); err != nil {
+ cancel()
s.writeDataError(c, err.Error())
}
} else {
@@ -760,12 +786,22 @@ func streamChatCompletionSSE(
return fmt.Errorf("streaming unsupported")
}
- writeSSE := func(payload gin.H) {
- body, _ := json.Marshal(payload)
- _, _ = c.Writer.Write([]byte("data:"))
- _, _ = c.Writer.Write(body)
- _, _ = c.Writer.Write([]byte("\n\n"))
+ writeSSE := func(payload gin.H) error {
+ body, err := json.Marshal(payload)
+ if err != nil {
+ return err
+ }
+ if _, err := c.Writer.Write([]byte("data:")); err != nil {
+ return err
+ }
+ if _, err := c.Writer.Write(body); err != nil {
+ return err
+ }
+ if _, err := c.Writer.Write([]byte("\n\n")); err != nil {
+ return err
+ }
flusher.Flush()
+ return nil
}
for ev := range events {
@@ -791,7 +827,9 @@ func streamChatCompletionSSE(
"logprobs": nil,
}},
}
- writeSSE(chunk)
+ if err := writeSSE(chunk); err != nil {
+ return err
+ }
case OpenAIEventReasoning:
chunk := gin.H{
@@ -814,7 +852,9 @@ func streamChatCompletionSSE(
"logprobs": nil,
}},
}
- writeSSE(chunk)
+ if err := writeSSE(chunk); err != nil {
+ return err
+ }
case OpenAIEventError:
chunk := gin.H{
@@ -837,7 +877,9 @@ func streamChatCompletionSSE(
"logprobs": nil,
}},
}
- writeSSE(chunk)
+ if err := writeSSE(chunk); err != nil {
+ return err
+ }
case OpenAIEventFinal:
delta := gin.H{
@@ -869,12 +911,16 @@ func streamChatCompletionSSE(
"logprobs": nil,
}},
}
- writeSSE(chunk)
+ if err := writeSSE(chunk); err != nil {
+ return err
+ }
}
}
// Always terminate with data: [DONE]\n\n.
- _, _ = c.Writer.Write([]byte("data: [DONE]\n\n"))
+ if _, err := c.Writer.Write([]byte("data: [DONE]\n\n")); err != nil {
+ return err
+ }
flusher.Flush()
return nil
}