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
refactor(agent): remove unused canvas stream abstraction (#20169)
Sbaaoui Idrissfe1b1d10b26f
diff --git a/internal/agent/canvas/stream.go b/internal/agent/canvas/stream.godeleted file mode 100644index 8ad7c86447..0000000000--- a/internal/agent/canvas/stream.go+++ /dev/null@@ -1,111 +0,0 @@-//-// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.-//-// Licensed under the Apache License, Version 2.0 (the "License");-// you may not use this file except in compliance with the License.-// You may obtain a copy of the License at-//-// http://www.apache.org/licenses/LICENSE-2.0-//-// Unless required by applicable law or agreed to in writing, software-// distributed under the License is distributed on an "AS IS" BASIS,-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.-// See the License for the specific language governing permissions and-// limitations under the License.-//--// stream.go defines the SSE event channel and the helper that-// formats events in the Python agent_api.py wire format.-package canvas--import (- "encoding/json"-- "go.uber.org/zap"-- "ragflow/internal/common"-)--// StreamEvent is the unit emitted by canvas components to the SSE writer.-// Field names match the Python "data" payload shape so a single-// frontend SSE parser can consume both runtimes.-type StreamEvent struct {- // Event is the event name: "node_start" | "node_finish" | "message" | "error" | "cancelled" | ...- Event string `json:"event"`- // SessionID identifies the canvas session; required for client correlation.- SessionID string `json:"session_id"`- // Component identifies the canvas component that produced the event.- Component string `json:"component,omitempty"`- // Data is the free-form event body. SSE wire format is "data: " + json(ev.Data).- Data map[string]any `json:"data,omitempty"`-}--// StreamEmitter pushes events toward an SSE writer. Emit must be-// non-blocking — a slow consumer must not stall canvas execution. The-// Phase-1 implementation drops events when the buffer is full and-// logs a warning; a Phase-5 SSE handler can swap in a back-pressured-// implementation if needed.-type StreamEmitter interface {- Emit(ev StreamEvent) error- Close() error-}--// channelEmitter is the default StreamEmitter: a buffered Go channel-// drained by an HTTP handler running in a separate goroutine.-type channelEmitter struct {- ch chan StreamEvent-}--// NewChannelEmitter returns a StreamEmitter backed by a buffered channel-// of the given size. Size 0 is valid (unbuffered) but will block Emit-// until a reader is ready — typically not what canvas runs want.-func NewChannelEmitter(buffer int) StreamEmitter {- return &channelEmitter{ch: make(chan StreamEvent, buffer)}-}--// Emit pushes ev onto the channel. Non-blocking: if the buffer is full-// the event is dropped and a warning is logged. Returning a nil error-// on drop is intentional — the canvas run must keep going even if the-// SSE consumer is slow or absent.-func (e *channelEmitter) Emit(ev StreamEvent) error {- select {- case e.ch <- ev:- return nil- default:- common.Warn("canvas stream: dropping event (buffer full)",- zap.String("event", ev.Event),- zap.String("session", ev.SessionID))- return nil- }-}--// Close closes the underlying channel. Safe to call once; further Emits-// will panic (caught by the run goroutine's defer) which is the desired-// signal that the emitter is no longer usable.-func (e *channelEmitter) Close() error {- close(e.ch)- return nil-}--// Channel returns the underlying receive-only channel. It is exported-// (lowercase access from same package) only for tests; production code-// should consume via the StreamEmitter interface.-func (e *channelEmitter) Channel() <-chan StreamEvent {- return e.ch-}--// FormatSSE renders ev into the Python agent_api.py wire format:-// `data: <json>\n\n`. JSON is emitted without HTML escaping so unicode-// stays readable. Errors marshaling Data fall back to a minimal-// `{"error": "..."}` payload so the SSE stream never gets a malformed-// frame.-func FormatSSE(ev StreamEvent) string {- body, err := json.Marshal(ev.Data)- if err != nil {- body, _ = json.Marshal(map[string]string{- "error": "stream marshal failed",- "detail": err.Error(),- })- }- return "data: " + string(body) + "\n\n"-}diff --git a/internal/agent/canvas/stream_test.go b/internal/agent/canvas/stream_test.godeleted file mode 100644index be9ba55449..0000000000--- a/internal/agent/canvas/stream_test.go+++ /dev/null@@ -1,142 +0,0 @@-//-// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.-//-// Licensed under the Apache License, Version 2.0 (the "License");-// you may not use this file except in compliance with the License.-// You may obtain a copy of the License at-//-// http://www.apache.org/licenses/LICENSE-2.0-//-// Unless required by applicable law or agreed to in writing, software-// distributed under the License is distributed on an "AS IS" BASIS,-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.-// See the License for the specific language governing permissions and-// limitations under the License.-//--package canvas--import (- "encoding/json"- "strings"- "testing"- "time"-)--func TestChannelEmitter_EmitAndClose(t *testing.T) {- em := NewChannelEmitter(4)- ch := em.(*channelEmitter).Channel()-- evs := []StreamEvent{- {Event: "node_start", SessionID: "s1", Component: "begin_0"},- {Event: "message", SessionID: "s1", Component: "llm_0",- Data: map[string]any{"delta": "hello"}},- {Event: "node_finish", SessionID: "s1", Component: "begin_0",- Data: map[string]any{"ok": true}},- }- for _, ev := range evs {- if err := em.Emit(ev); err != nil {- t.Fatalf("Emit %q: %v", ev.Event, err)- }- }- if err := em.Close(); err != nil {- t.Fatalf("Close: %v", err)- }-- var got []StreamEvent- for ev := range ch {- got = append(got, ev)- }- if len(got) != len(evs) {- t.Fatalf("got %d events, want %d", len(got), len(evs))- }- for i, ev := range got {- if ev.Event != evs[i].Event || ev.SessionID != evs[i].SessionID ||- ev.Component != evs[i].Component {- t.Fatalf("event %d: got %+v, want %+v", i, ev, evs[i])- }- }-}--func TestChannelEmitter_NonBlockingDrop(t *testing.T) {- // Buffer of 1 with no reader; the second Emit must return nil- // immediately (drop on full) rather than block.- em := NewChannelEmitter(1)- if err := em.Emit(StreamEvent{Event: "e1", SessionID: "s"}); err != nil {- t.Fatalf("Emit 1: %v", err)- }- done := make(chan struct{})- go func() {- if err := em.Emit(StreamEvent{Event: "e2", SessionID: "s"}); err != nil {- t.Errorf("Emit 2: %v", err)- }- close(done)- }()- select {- case <-done:- case <-time.After(200 * time.Millisecond):- t.Fatal("Emit blocked despite non-blocking contract")- }- // The first event is still buffered; the second was dropped.- ch := em.(*channelEmitter).Channel()- first := <-ch- if first.Event != "e1" {- t.Fatalf("first buffered event = %q, want e1", first.Event)- }-}--func TestFormatSSE(t *testing.T) {- ev := StreamEvent{- Event: "message",- SessionID: "session_42",- Component: "llm_0",- Data: map[string]any{- "delta": "héllo, 世界",- "index": 7,- },- }- got := FormatSSE(ev)-- if !strings.HasPrefix(got, "data: ") {- t.Fatalf("SSE frame must start with 'data: '; got %q", got)- }- if !strings.HasSuffix(got, "\n\n") {- t.Fatalf("SSE frame must end with '\\n\\n'; got %q", got)- }- body := strings.TrimPrefix(got, "data: ")- body = strings.TrimSuffix(body, "\n\n")-- // Body must be valid JSON and round-trip the Data field.- var decoded map[string]any- if err := json.Unmarshal([]byte(body), &decoded); err != nil {- t.Fatalf("SSE body is not JSON: %v\nbody: %q", err, body)- }- if decoded["delta"] != "héllo, 世界" {- t.Fatalf("delta round-trip: got %q, want %q", decoded["delta"], "héllo, 世界")- }- if v, _ := decoded["index"].(float64); v != 7 {- t.Fatalf("index round-trip: got %v, want 7", decoded["index"])- }-}--func TestFormatSSE_EmptyData(t *testing.T) {- // Empty Data must still produce a valid frame, not panic.- got := FormatSSE(StreamEvent{Event: "node_start", SessionID: "s"})- if !strings.HasPrefix(got, "data: ") || !strings.HasSuffix(got, "\n\n") {- t.Fatalf("empty Data frame malformed: %q", got)- }-}--func TestChannelEmitter_CloseIdempotentCheck(t *testing.T) {- // Emitting after Close must panic — callers should not emit on a- // closed emitter. This is the desired Go-idiomatic signal.- em := NewChannelEmitter(1)- ch := em.(*channelEmitter).Channel()- if err := em.Close(); err != nil {- t.Fatalf("Close: %v", err)- }- // Drain to confirm the channel is closed.- if _, ok := <-ch; ok {- t.Fatal("channel not closed after Close()")- }-}