Skip to content

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

refactor(agent): remove unused canvas stream abstraction (#20169)

Sbaaoui Idrissfe1b1d10b26f
diff --git a/internal/agent/canvas/stream.go b/internal/agent/canvas/stream.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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()")
- }
-}