RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
fix(service): prevent goroutine leaks on SSE stream channel writes (#21179)
Sanderhoff-alt581f1a2cca67
diff --git a/internal/handler/agent.go b/internal/handler/agent.goindex 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.goindex 3a542b5f3a..aad880cbae 100644--- a/internal/handler/agent_openai.go+++ b/internal/handler/agent_openai.go@@ -17,6 +17,7 @@package handlerimport (+ "context""encoding/json""errors""net/http"@@ -110,7 +111,8 @@ func (h *AgentHandler) handleOpenAICompat(c *gin.Context, user *entity.User, reqc.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.goindex 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) {returndiff --git a/internal/handler/chat_session.go b/internal/handler/chat_session.goindex 7dad6110b2..66a49150e9 100644--- a/internal/handler/chat_session.go+++ b/internal/handler/chat_session.go@@ -17,6 +17,7 @@package handlerimport (+ "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 firstdiff --git a/internal/handler/search.go b/internal/handler/search.goindex 7a1bba35dd..1a7057aaa0 100644--- a/internal/handler/search.go+++ b/internal/handler/search.go@@ -17,6 +17,7 @@package handlerimport (+ "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 boolswitch 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.goindex df2d73d944..ae20d85891 100644--- a/internal/handler/searchbot.go+++ b/internal/handler/searchbot.go@@ -17,6 +17,7 @@package handlerimport (+ "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 := falseadapter := &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 boolswitch 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.goindex 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.goindex 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 stringvar 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 := rawAnswerif 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.goindex e141b4ade9..5890a270d8 100644--- a/internal/service/bot_completion_history_test.go+++ b/internal/service/bot_completion_history_test.go@@ -26,6 +26,7 @@ package serviceimport ("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.goindex 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 stringthinkState := &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 += *answerdeltas := 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.PromptConfigsystemPrompt := ""@@ -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 += *answerdeltas := 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.goindex 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.goindex 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()) / 1e9fail := 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 methodsdiff --git a/internal/service/chat_session_test.go b/internal/service/chat_session_test.goindex 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.goindex 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, chatIDevents := 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.AnswerfullContent += deltacompletionTok += 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}