Skip to content

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

fix(agent): retain webhook completion across incremental polls (#20697)

Guofang.Tangd6bfce44733b
diff --git a/internal/handler/agent_webhook_trace.go b/internal/handler/agent_webhook_trace.go
index 28bcf95a00..123c93f474 100644
--- a/internal/handler/agent_webhook_trace.go
+++ b/internal/handler/agent_webhook_trace.go
@@ -125,16 +125,16 @@ func decodeWebhookID(webhookID string, webhooks map[string]webhookTraceRun) (str
}
// collectWebhookTraceEvents returns only events newer than the supplied cursor.
+// Completion depends on the stored terminal event, even when it was already read.
func collectWebhookTraceEvents(run webhookTraceRun, sinceTS float64, webhookID string) webhookTracePoll {
result := newWebhookTracePoll(&webhookID, sinceTS, false)
for _, event := range run.Events {
eventTS := webhookTraceEventTimestamp(event)
- if eventTS <= sinceTS {
- continue
- }
- result.Events = append(result.Events, event)
- if eventTS > result.NextSinceTS {
- result.NextSinceTS = eventTS
+ if eventTS > sinceTS {
+ result.Events = append(result.Events, event)
+ if eventTS > result.NextSinceTS {
+ result.NextSinceTS = eventTS
+ }
}
if eventType, _ := event["event"].(string); eventType == "finished" {
result.Finished = true
diff --git a/internal/handler/agent_webhook_trace_poll_test.go b/internal/handler/agent_webhook_trace_poll_test.go
index de2668f854..1258dcb732 100644
--- a/internal/handler/agent_webhook_trace_poll_test.go
+++ b/internal/handler/agent_webhook_trace_poll_test.go
@@ -14,7 +14,62 @@
package handler
-import "testing"
+import (
+ "encoding/json"
+ "testing"
+)
+
+// TestPollWebhookTraceKeepsTerminalState verifies completion survives advancing the event cursor.
+func TestPollWebhookTraceKeepsTerminalState(t *testing.T) {
+ for _, outcome := range []struct {
+ name string
+ success bool
+ }{
+ {"successful run", true},
+ {"failed run", false},
+ } {
+ t.Run(outcome.name, func(t *testing.T) {
+ store := webhookTraceStore{Webhooks: map[string]webhookTraceRun{
+ "50": {StartTS: 50, Events: []map[string]any{
+ {"ts": 51, "event": "message"},
+ {"ts": 52, "event": "finished", "data": map[string]any{"success": outcome.success}},
+ {"ts": 53, "event": "message", "data": map[string]any{"content": "late"}},
+ }},
+ }}
+ raw, err := json.Marshal(store)
+ if err != nil {
+ t.Fatal(err)
+ }
+ id := encodeWebhookID("50")
+ first, err := pollWebhookTrace(string(raw), 50, id)
+ if err != nil || !first.Finished || len(first.Events) != 2 || first.NextSinceTS != 52 {
+ t.Fatalf("first poll = %+v, error = %v", first, err)
+ }
+ data := first.Events[1]["data"].(map[string]any)
+ if data["success"] != outcome.success {
+ t.Fatalf("terminal outcome = %#v, want success=%t", data, outcome.success)
+ }
+ for _, cursor := range []float64{first.NextSinceTS, 60} {
+ repeated, err := pollWebhookTrace(string(raw), cursor, id)
+ if err != nil || !repeated.Finished || repeated.NextSinceTS != cursor {
+ t.Fatalf("repeat at %v = %+v, error = %v", cursor, repeated, err)
+ }
+ if repeated.WebhookID == nil || *repeated.WebhookID != id || repeated.Events == nil || len(repeated.Events) != 0 {
+ t.Fatalf("repeat at %v = %+v, want same run and no replayed or trailing events", cursor, repeated)
+ }
+ }
+ })
+ }
+}
+
+// TestPollWebhookTraceExhaustedActiveRun does not infer completion merely from an empty event delta.
+func TestPollWebhookTraceExhaustedActiveRun(t *testing.T) {
+ raw := `{"webhooks":{"50":{"start_ts":50,"events":[{"ts":51,"event":"message"}]}}}`
+ result, err := pollWebhookTrace(raw, 51, encodeWebhookID("50"))
+ if err != nil || result.Finished || result.NextSinceTS != 51 || result.Events == nil || len(result.Events) != 0 {
+ t.Fatalf("active run = %+v, error = %v, want unfinished with no new events", result, err)
+ }
+}
// TestPollWebhookTraceMissingRun distinguishes waiting for a trigger from losing an already selected trace.
func TestPollWebhookTraceMissingRun(t *testing.T) {
diff --git a/internal/handler/agent_webhook_trace_test.go b/internal/handler/agent_webhook_trace_test.go
index 6033415672..5517bed7db 100644
--- a/internal/handler/agent_webhook_trace_test.go
+++ b/internal/handler/agent_webhook_trace_test.go
@@ -371,6 +371,21 @@ func TestGetAgentWebhookLogsPollsTraceIncrementally(t *testing.T) {
if !incremental.Data.Finished || incremental.Data.NextSinceTS != finishedTS {
t.Fatalf("incremental completion = %+v", incremental.Data)
}
+ for _, cursor := range []float64{incremental.Data.NextSinceTS, trailingTS} {
+ repeated := requestWebhookTrace(t, h, "c1", "u1", url.Values{
+ "since_ts": {strconv.FormatFloat(cursor, 'f', -1, 64)},
+ "webhook_id": {*discovery.Data.WebhookID},
+ })
+ if repeated.Code != int(common.CodeSuccess) || repeated.Data == nil || !repeated.Data.Finished {
+ t.Fatalf("repeat at %f = %+v, want completed trace", cursor, repeated)
+ }
+ if repeated.Data.WebhookID == nil || *repeated.Data.WebhookID != *discovery.Data.WebhookID || repeated.Data.NextSinceTS != cursor {
+ t.Fatalf("repeat data = %+v, want unchanged run and cursor", repeated.Data)
+ }
+ if repeated.Data.Events == nil || len(repeated.Data.Events) != 0 {
+ t.Fatalf("repeat events = %#v, want no replayed or trailing events", repeated.Data.Events)
+ }
+ }
}
// TestGetAgentWebhookLogsHandlesMissingAndInvalidState covers empty and stale cursors.