Skip to content

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

fix(agent): keep deferred Agent model failures in the chat stream instead of toast popups (#19829)

euvre51f473ecced4
diff --git a/internal/agent/component/message.go b/internal/agent/component/message.go
index 39435e110d..c9c7328e58 100644
--- a/internal/agent/component/message.go
+++ b/internal/agent/component/message.go
@@ -443,10 +443,10 @@ func (m *MessageComponent) resolveDeferredTemplate(ctx context.Context, text str
runtime.EmitCanvasMessageEvent(ctx, "", false, true)
}
if err != nil {
- return "", true, fmt.Errorf("Message: consume deferred Agent stream: %w", err)
+ return "", true, &runtime.DeferredStreamError{Err: err}
}
if resultErr, _ := result["_ERROR"].(string); strings.TrimSpace(resultErr) != "" {
- return "", true, fmt.Errorf("Message: consume deferred Agent stream: %s", resultErr)
+ return "", true, &runtime.DeferredStreamError{Text: resultErr}
}
finalText := visible.String()
if result != nil {
diff --git a/internal/agent/runtime/component.go b/internal/agent/runtime/component.go
index 35dfa40b58..91b137d400 100644
--- a/internal/agent/runtime/component.go
+++ b/internal/agent/runtime/component.go
@@ -75,6 +75,30 @@ func NewUserFacingError(message string) error {
return &UserFacingError{Err: fmt.Errorf("%s", message)}
}
+// DeferredStreamError marks a failure recorded while a Message component
+// consumed an Agent's deferred stream. Text holds the user-facing failure
+// (the Agent's `_ERROR` output); Err holds the underlying cause when the
+// stream itself failed to open, so cancellation keeps propagating. The run
+// handler surfaces FailureText in the chat message flow instead of an
+// error frame; match with errors.As.
+type DeferredStreamError struct {
+ Text string
+ Err error
+}
+
+func (e *DeferredStreamError) Error() string {
+ return "Message: consume deferred Agent stream: " + e.FailureText()
+}
+
+func (e *DeferredStreamError) Unwrap() error { return e.Err }
+
+func (e *DeferredStreamError) FailureText() string {
+ if e.Err != nil {
+ return e.Err.Error()
+ }
+ return e.Text
+}
+
// ParamError wraps a parameter validation failure with the field name
// for clearer error messages to the user.
type ParamError struct {
diff --git a/internal/service/agent.go b/internal/service/agent.go
index f62bd24caf..b6e56b2602 100644
--- a/internal/service/agent.go
+++ b/internal/service/agent.go
@@ -2333,6 +2333,28 @@ func (s *AgentService) buildRunFunc(canvasID string, versionRow *entity.UserCanv
s.markRunSucceeded(ctx2, runID)
return state, nil
}
+ if failureText := deferredAgentStreamFailureText(err); failureText != "" {
+ visibleAnswer := answer
+ if visibleAnswer == "" && !messageEventsEmitted && shouldEmitMessage {
+ emitAgentMessageEvents(emit, failureText, thinking, referencePayload)
+ visibleAnswer = failureText
+ }
+ if persistErr := s.persistAgentRunSession(ctx, canvasID, userID, sessionID, messageID, userInput, visibleAnswer, thinking, referencePayload, dsl, state, visibleAnswer != ""); persistErr != nil {
+ s.markRunFailed(ctx2, runID, "persist session: "+persistErr.Error())
+ return nil, canvas.NewInternalRunError(
+ fmt.Errorf("persist agent session: %w: %w", persistErr, ErrAgentStorageError),
+ )
+ }
+ if shouldEmitMessage {
+ meData, _ := json.Marshal(canvas.MessageEndEvent{
+ Attachment: attachment,
+ Reference: referencePayload,
+ })
+ emit("message_end", string(meData))
+ }
+ s.markRunFailed(ctx2, runID, "invoke: "+err.Error())
+ return state, nil
+ }
s.markRunFailed(ctx2, runID, "invoke: "+err.Error())
return nil, fmt.Errorf("canvas invoke: %w", err)
}
@@ -2838,6 +2860,23 @@ func tenantIDFromRoot(root map[string]any) string {
return ""
}
+// deferredAgentStreamFailureText returns the user-facing failure text the
+// Message component recorded when its deferred consumption of an Agent
+// stream failed. Python surfaces that same text through the failing node's
+// outputs into the chat stream instead of aborting the SSE conversation
+// with an error frame, so the run handler keeps it in the message flow.
+// Cancellation and timeouts stay run-level errors.
+func deferredAgentStreamFailureText(err error) string {
+ if err == nil || errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
+ return ""
+ }
+ var deferred *runtime.DeferredStreamError
+ if !errors.As(err, &deferred) {
+ return ""
+ }
+ return strings.TrimSpace(deferred.FailureText())
+}
+
func shouldTreatAsCompletedLoopRun(err error, answer string) bool {
if err == nil || answer == "" {
return false
diff --git a/internal/service/agent_deferred_failure_test.go b/internal/service/agent_deferred_failure_test.go
new file mode 100644
index 0000000000..289b07d352
--- /dev/null
+++ b/internal/service/agent_deferred_failure_test.go
@@ -0,0 +1,168 @@
+package service
+
+import (
+ "context"
+ "encoding/json"
+ "errors"
+ "fmt"
+ "strings"
+ "testing"
+
+ "ragflow/internal/agent/canvas"
+ _ "ragflow/internal/agent/component" // blank import: registers factories via component.init()
+ "ragflow/internal/agent/runtime"
+ "ragflow/internal/dao"
+ "ragflow/internal/entity"
+)
+
+func TestDeferredAgentStreamFailureText(t *testing.T) {
+ deferred := &runtime.DeferredStreamError{Text: "**ERROR**: [GraphRunError] model unavailable"}
+ if got := deferredAgentStreamFailureText(fmt.Errorf("canvas invoke: component %q invoke: %w", "Message:x", deferred)); got != deferred.Text {
+ t.Errorf("deferredAgentStreamFailureText = %q, want the Agent _ERROR text", got)
+ }
+ embedded := &runtime.DeferredStreamError{Text: "**ERROR**: [GraphRunError] consume deferred Agent stream: model unavailable"}
+ if got := deferredAgentStreamFailureText(fmt.Errorf("canvas invoke: %w", embedded)); got != embedded.Text {
+ t.Errorf("marker text embedded in the _ERROR value truncated the failure text to %q", got)
+ }
+ if got := deferredAgentStreamFailureText(errors.New("canvas invoke: Message: consume deferred Agent stream: unrelated")); got != "" {
+ t.Errorf("plain error containing the marker text returned %q, want empty", got)
+ }
+ if got := deferredAgentStreamFailureText(fmt.Errorf("invoke: %w", &runtime.DeferredStreamError{Err: errors.New("stream dropped")})); got != "stream dropped" {
+ t.Errorf("underlying stream error returned %q, want its message", got)
+ }
+ if got := deferredAgentStreamFailureText(fmt.Errorf("invoke: %w", &runtime.DeferredStreamError{Err: context.Canceled})); got != "" {
+ t.Errorf("cancellation inside the deferred stream returned %q, want empty", got)
+ }
+ if got := deferredAgentStreamFailureText(errors.New("canvas invoke: compile error")); got != "" {
+ t.Errorf("non-deferred error returned %q, want empty", got)
+ }
+ if got := deferredAgentStreamFailureText(context.DeadlineExceeded); got != "" {
+ t.Errorf("timeout returned %q, want empty", got)
+ }
+}
+
+// An Agent whose chat model is unavailable fails through its `_ERROR`
+// output; the downstream Message records the failure while consuming the
+// deferred stream. The run must keep that failure text in the chat message
+// flow (like the Python canvas, whose node outputs surface it in the chat
+// bubble) instead of terminating the SSE conversation with an error frame
+// that the front-end renders as toast popups.
+func TestRunAgent_DeferredAgentModelFailureStaysInChatStream(t *testing.T) {
+ testDB := setupServiceTestDB(t)
+ if err := testDB.AutoMigrate(
+ &entity.UserCanvas{},
+ &entity.UserCanvasVersion{},
+ &entity.APIToken{},
+ &entity.API4Conversation{},
+ &entity.TenantModelProvider{},
+ &entity.TenantModelInstance{},
+ &entity.TenantModel{},
+ ); err != nil {
+ t.Fatalf("migrate: %v", err)
+ }
+ orig := dao.DB
+ dao.DB = testDB
+ t.Cleanup(func() { dao.DB = orig })
+
+ dsl := map[string]any{
+ "components": map[string]any{
+ "begin_0": map[string]any{
+ "obj": map[string]any{"component_name": "Begin", "params": map[string]any{}},
+ "downstream": []any{"Agent:fail_0"},
+ },
+ "Agent:fail_0": map[string]any{
+ "obj": map[string]any{
+ "component_name": "Agent",
+ "params": map[string]any{
+ "llm_id": "unavailable-model",
+ "driver": "OpenAI",
+ "api_key": "test-key",
+ "base_url": "http://127.0.0.1:59999/v1",
+ "prompts": []any{map[string]any{"content": "{sys.query}", "role": "user"}},
+ },
+ },
+ "upstream": []any{"begin_0"},
+ "downstream": []any{"Message:fail_0"},
+ },
+ "Message:fail_0": map[string]any{
+ "obj": map[string]any{
+ "component_name": "Message",
+ "params": map[string]any{"content": []any{"{Agent:fail_0@content}"}},
+ },
+ "upstream": []any{"Agent:fail_0"},
+ },
+ },
+ "path": []any{"begin_0", "Agent:fail_0", "Message:fail_0"},
+ }
+ dao.DB.Create(&entity.TenantModelProvider{ID: "prov-deferred-fail", ProviderName: "OpenAI-API-Compatible", TenantID: "tenant-1"})
+ dao.DB.Create(&entity.TenantModelInstance{ID: "inst-deferred-fail", InstanceName: "unreachable", ProviderID: "prov-deferred-fail", APIKey: "test-key", Extra: `{"base_url": "http://127.0.0.1:59999/v1"}`})
+ dao.DB.Create(&entity.TenantModel{ID: "unavailable-model", ModelName: "unavailable-model", ProviderID: "prov-deferred-fail", InstanceID: "inst-deferred-fail", ModelType: int(entity.ModelTypeChat), Status: "active", Extra: "{}"})
+ makeCanvasWithDSL(t, "canvas-deferred-fail", "user-1", "tenant-1", "v-deferred-fail", dsl)
+
+ tracker, _ := newAgentCancelTracker(t)
+ svc := NewAgentServiceWithOptions(nil, nil, tracker)
+ events, err := svc.RunAgent(
+ t.Context(),
+ "user-1",
+ "canvas-deferred-fail",
+ "session-deferred-fail",
+ "",
+ "hello", nil)
+ if err != nil {
+ t.Fatalf("RunAgent returned sync error: %v", err)
+ }
+ messages, _, errs, messageEnds, done := drainAgentEvents(t, events)
+ if len(errs) != 0 {
+ t.Fatalf("model failure produced error frames %+v, want the failure kept in the message stream", errs)
+ }
+ if !done {
+ t.Fatal("stream did not terminate with done")
+ }
+ if messageEnds == 0 {
+ t.Fatal("deferred failure stream ended without message_end")
+ }
+ var failureText string
+ for _, m := range messages {
+ if strings.Contains(m.Content, "**ERROR**") {
+ failureText = m.Content
+ break
+ }
+ }
+ if failureText == "" {
+ t.Fatalf("no message event carries the Agent _ERROR text; messages: %+v", messages)
+ }
+ assertPersistedAssistantFailure(t, "session-deferred-fail", "canvas-deferred-fail", failureText)
+ assertRunMarkedFailed(t, tracker, "canvas-deferred-fail", "session-deferred-fail")
+}
+
+func assertPersistedAssistantFailure(t *testing.T, sessionID, agentID, wantText string) {
+ t.Helper()
+ conv, err := dao.NewAPI4ConversationDAO().GetBySessionID(t.Context(), dao.DB, sessionID, agentID)
+ if err != nil {
+ t.Fatalf("reload conversation: %v", err)
+ }
+ var history []map[string]any
+ if err := json.Unmarshal(conv.Message, &history); err != nil {
+ t.Fatalf("parse persisted message history: %v", err)
+ }
+ for _, turn := range history {
+ if turn["role"] != "assistant" {
+ continue
+ }
+ if content, _ := turn["content"].(string); strings.Contains(content, wantText) {
+ return
+ }
+ }
+ t.Fatalf("persisted assistant answer does not carry the failure text %q; history: %+v", wantText, history)
+}
+
+func assertRunMarkedFailed(t *testing.T, tracker *canvas.RunTracker, canvasID, sessionID string) {
+ t.Helper()
+ fields, err := tracker.Get(t.Context(), runIDFor(canvasID, map[string]any{"session_id": sessionID}))
+ if err != nil {
+ t.Fatalf("read run status: %v", err)
+ }
+ if fields["status"] != "2" {
+ t.Fatalf("run status = %q, want 2 (failed); fields: %+v", fields["status"], fields)
+ }
+}
diff --git a/internal/service/agent_run_e2e_test.go b/internal/service/agent_run_e2e_test.go
index b8b0deb125..49eb47364c 100644
--- a/internal/service/agent_run_e2e_test.go
+++ b/internal/service/agent_run_e2e_test.go
@@ -86,10 +86,10 @@ func makeCanvasWithDSL(t *testing.T, canvasID, userID, tenantID, versionID strin
}
// drainAgentEvents drains the channel returned by RunAgent and
-// collects the typed events into the three buckets. The 5-second
-// deadline protects against driver deadlocks — a successful run
-// always closes the channel within milliseconds.
-func drainAgentEvents(t *testing.T, events <-chan canvas.RunEvent) (messages []canvas.MessageEvent, waiting []canvas.WaitingForUserEvent, errors_ []canvas.ErrorEvent, done bool) {
+// collects the typed events into buckets, counting message_end
+// events. The 5-second deadline protects against driver deadlocks —
+// a successful run always closes the channel within milliseconds.
+func drainAgentEvents(t *testing.T, events <-chan canvas.RunEvent) (messages []canvas.MessageEvent, waiting []canvas.WaitingForUserEvent, errors_ []canvas.ErrorEvent, messageEnds int, done bool) {
t.Helper()
deadline := time.After(5 * time.Second)
for {
@@ -118,6 +118,8 @@ func drainAgentEvents(t *testing.T, events <-chan canvas.RunEvent) (messages []c
t.Fatalf("drain: bad error payload: %v", err)
}
errors_ = append(errors_, e)
+ case "message_end":
+ messageEnds++
case "done":
done = true
}
@@ -209,7 +211,7 @@ func TestRunAgent_RealCanvas_BeginMessage(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent: %v", err)
}
- messages, waiting, errs, done := drainAgentEvents(t, events)
+ messages, waiting, errs, _, done := drainAgentEvents(t, events)
if len(errs) > 0 {
t.Fatalf("unexpected error events: %+v", errs)
}
@@ -297,7 +299,7 @@ func TestRunAgent_SessionHistoryFeedsSysHistoryAndPersists(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent(%q): %v", input, err)
}
- messages, waiting, errs, done := drainAgentEvents(t, events)
+ messages, waiting, errs, _, done := drainAgentEvents(t, events)
if len(errs) != 0 || len(waiting) != 0 || !done {
t.Fatalf("RunAgent(%q): messages=%+v waiting=%+v errors=%+v done=%v", input, messages, waiting, errs, done)
}
@@ -393,7 +395,7 @@ func TestRunAgent_NewSessionPersistsHistoryForNextTurn(t *testing.T) {
if err != nil {
t.Fatalf("first RunAgent: %v", err)
}
- firstMessages, waiting, errs, done := drainAgentEvents(t, events)
+ firstMessages, waiting, errs, _, done := drainAgentEvents(t, events)
if len(errs) != 0 || len(waiting) != 0 || !done || len(firstMessages) != 1 {
t.Fatalf("first run: messages=%+v waiting=%+v errors=%+v done=%v", firstMessages, waiting, errs, done)
}
@@ -424,7 +426,7 @@ func TestRunAgent_NewSessionPersistsHistoryForNextTurn(t *testing.T) {
if err != nil {
t.Fatalf("second RunAgent: %v", err)
}
- secondMessages, waiting, errs, done := drainAgentEvents(t, events)
+ secondMessages, waiting, errs, _, done := drainAgentEvents(t, events)
if len(errs) != 0 || len(waiting) != 0 || !done || len(secondMessages) != 1 {
t.Fatalf("second run: messages=%+v waiting=%+v errors=%+v done=%v", secondMessages, waiting, errs, done)
}
@@ -609,7 +611,7 @@ func TestRunAgent_RealCanvas_WaitForUserResume(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent run 1: %v", err)
}
- _, waiting1, errs1, _ := drainAgentEvents(t, events1)
+ _, waiting1, errs1, _, _ := drainAgentEvents(t, events1)
if len(errs1) > 0 {
t.Fatalf("run 1: unexpected error events: %+v", errs1)
}
@@ -643,7 +645,7 @@ func TestRunAgent_RealCanvas_WaitForUserResume(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent run 2: %v", err)
}
- messages2, waiting2, errs2, done2 := drainAgentEvents(t, events2)
+ messages2, waiting2, errs2, _, done2 := drainAgentEvents(t, events2)
if len(errs2) > 0 {
t.Fatalf("run 2: unexpected error events: %+v", errs2)
}
@@ -723,7 +725,7 @@ func TestRunAgent_InterruptPersistsPartialAssistantHistory(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent: %v", err)
}
- messages, waiting, errs, done := drainAgentEvents(t, events)
+ messages, waiting, errs, _, done := drainAgentEvents(t, events)
if len(errs) != 0 || len(waiting) != 1 || !done {
t.Fatalf("messages=%+v waiting=%+v errors=%+v done=%v", messages, waiting, errs, done)
}
@@ -948,7 +950,7 @@ func TestRunAgent_RealCanvas_GroupedParallelOuterFollower(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent: %v", err)
}
- messages, waiting, errs, done := drainAgentEvents(t, events)
+ messages, waiting, errs, _, done := drainAgentEvents(t, events)
if len(errs) > 0 {
t.Fatalf("unexpected error events: %+v", errs)
}
@@ -1018,7 +1020,7 @@ func TestRunAgent_AllFixture_LoopInterruptResume(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent run 1: %v", err)
}
- messages1, waiting1, errs1, done1 := drainAgentEvents(t, events1)
+ messages1, waiting1, errs1, _, done1 := drainAgentEvents(t, events1)
if len(errs1) > 0 {
t.Fatalf("run 1: unexpected error events: %+v", errs1)
}
@@ -1058,7 +1060,7 @@ func TestRunAgent_AllFixture_LoopInterruptResume(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent run 2: %v", err)
}
- messages2, waiting2, errs2, done2 := drainAgentEvents(t, events2)
+ messages2, waiting2, errs2, _, done2 := drainAgentEvents(t, events2)
if len(errs2) > 0 {
t.Fatalf("run 2: unexpected error events: %+v", errs2)
}
@@ -1081,7 +1083,7 @@ func TestRunAgent_AllFixture_LoopInterruptResume(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent run 3: %v", err)
}
- messages2, waiting3, errs3, done3 := drainAgentEvents(t, events3)
+ messages2, waiting3, errs3, _, done3 := drainAgentEvents(t, events3)
if len(errs3) > 0 || len(waiting3) > 0 || !done3 {
t.Fatalf("run 3: errs=%+v waiting=%+v done=%v", errs3, waiting3, done3)
}
@@ -1144,7 +1146,7 @@ func TestRunAgent_AllFixture_LoopInterruptResume_MultiTurn(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent run %d (%q): %v", i+1, input, err)
}
- messages, waiting, errs, done := drainAgentEvents(t, events)
+ messages, waiting, errs, _, done := drainAgentEvents(t, events)
if len(errs) > 0 {
t.Fatalf("run %d (%q): unexpected error events: %+v", i+1, input, errs)
}
@@ -1237,7 +1239,7 @@ func TestRunAgent_AllFixture_IterationFormatsItems(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent run 1: %v", err)
}
- messages1, waiting1, errs1, done1 := drainAgentEvents(t, events1)
+ messages1, waiting1, errs1, _, done1 := drainAgentEvents(t, events1)
if len(errs1) > 0 {
t.Fatalf("run 1: unexpected error events: %+v", errs1)
}
@@ -1266,7 +1268,7 @@ func TestRunAgent_AllFixture_IterationFormatsItems(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent run 2: %v", err)
}
- messages2, waiting2, errs2, done2 := drainAgentEvents(t, events2)
+ messages2, waiting2, errs2, _, done2 := drainAgentEvents(t, events2)
if len(errs2) > 0 {
t.Fatalf("run 2: unexpected error events: %+v", errs2)
}
@@ -1289,7 +1291,7 @@ func TestRunAgent_AllFixture_IterationFormatsItems(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent run 3: %v", err)
}
- messages2, waiting3, errs3, done3 := drainAgentEvents(t, events3)
+ messages2, waiting3, errs3, _, done3 := drainAgentEvents(t, events3)
if len(errs3) > 0 {
t.Fatalf("run 3: unexpected error events: %+v", errs3)
}
@@ -1347,7 +1349,7 @@ func TestRunAgent_AllFixture_VarAssigner(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent: %v", err)
}
- messages, waiting, errs, done := drainAgentEvents(t, events)
+ messages, waiting, errs, _, done := drainAgentEvents(t, events)
if len(errs) > 0 {
t.Fatalf("unexpected error events: %+v", errs)
}
@@ -1372,7 +1374,7 @@ func TestRunAgent_AllFixture_VarAssigner(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent resume: %v", err)
}
- messages, waiting, errs, done = drainAgentEvents(t, events)
+ messages, waiting, errs, _, done = drainAgentEvents(t, events)
if len(errs) > 0 || len(waiting) > 0 || !done {
t.Fatalf("resume: messages=%+v waiting=%+v errs=%+v done=%v", messages, waiting, errs, done)
}
@@ -1431,7 +1433,7 @@ func TestRunAgent_AllFixture_DataOps(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent: %v", err)
}
- messages, waiting, errs, done := drainAgentEvents(t, events)
+ messages, waiting, errs, _, done := drainAgentEvents(t, events)
if len(errs) > 0 {
t.Fatalf("unexpected error events: %+v", errs)
}
@@ -1456,7 +1458,7 @@ func TestRunAgent_AllFixture_DataOps(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent resume: %v", err)
}
- messages, waiting, errs, done = drainAgentEvents(t, events)
+ messages, waiting, errs, _, done = drainAgentEvents(t, events)
if len(errs) > 0 || len(waiting) > 0 || !done {
t.Fatalf("resume: messages=%+v waiting=%+v errs=%+v done=%v", messages, waiting, errs, done)
}
@@ -1533,7 +1535,7 @@ func TestRunAgent_RealCanvas_CompileFails(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent returned sync error: %v", err)
}
- _, _, errs, _ := drainAgentEvents(t, events)
+ _, _, errs, _, _ := drainAgentEvents(t, events)
if len(errs) == 0 {
t.Fatal("expected error event from Compile of DSL with unknown component name")
}
@@ -1605,7 +1607,7 @@ func TestRunAgent_AllFixture_CategorizeResume(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent run 1: %v", err)
}
- messages1, waiting1, errs1, done1 := drainAgentEvents(t, events1)
+ messages1, waiting1, errs1, _, done1 := drainAgentEvents(t, events1)
t.Logf("run1: messages=%d waiting=%d errs=%d done=%v", len(messages1), len(waiting1), len(errs1), done1)
for i, e := range errs1 {
t.Logf(" run1 err[%d]: %s", i, e.Message)
@@ -1633,7 +1635,7 @@ func TestRunAgent_AllFixture_CategorizeResume(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent run 2: %v", err)
}
- messages2, waiting2, errs2, done2 := drainAgentEvents(t, events2)
+ messages2, waiting2, errs2, _, done2 := drainAgentEvents(t, events2)
t.Logf("run2: messages=%d waiting=%d errs=%d done=%v", len(messages2), len(waiting2), len(errs2), done2)
for i, e := range errs2 {
t.Logf(" run2 err[%d]: %s", i, e.Message)
@@ -1669,7 +1671,7 @@ func TestRunAgent_AllFixture_CategorizeResume(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent run 3: %v", err)
}
- messages2, waiting3, errs3, done3 := drainAgentEvents(t, events3)
+ messages2, waiting3, errs3, _, done3 := drainAgentEvents(t, events3)
if len(errs3) != 0 || len(waiting3) != 0 || !done3 {
t.Fatalf("run 3: messages=%+v waiting=%+v errs=%+v done=%v", messages2, waiting3, errs3, done3)
}
@@ -1763,7 +1765,7 @@ func TestRunAgent_RealCanvas_InvokeFails(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent returned sync error: %v", err)
}
- _, _, errs, _ := drainAgentEvents(t, events)
+ _, _, errs, _, _ := drainAgentEvents(t, events)
if len(errs) == 0 {
t.Fatal("expected error event from Invoke of DSL with bad component query ref")
}
@@ -1870,7 +1872,7 @@ func TestRunAgent_RunTracker_AttachCheckpoint_CallSequence(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent: %v", err)
}
- messages, _, errs, done := drainAgentEvents(t, events)
+ messages, _, errs, _, done := drainAgentEvents(t, events)
if len(errs) > 0 {
t.Fatalf("unexpected error events: %+v", errs)
}
@@ -2045,7 +2047,7 @@ func TestRunAgent_FilesPopulateIteration(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent with files: %v", err)
}
- messages, waiting, errs, done := drainAgentEvents(t, events)
+ messages, waiting, errs, _, done := drainAgentEvents(t, events)
if len(errs) > 0 {
t.Fatalf("unexpected error events with files: %+v", errs)
}
@@ -2119,7 +2121,7 @@ func TestRunAgent_MissingUploadEmitsError(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent: %v", err)
}
- messages, _, errs, done := drainAgentEvents(t, events)
+ messages, _, errs, _, done := drainAgentEvents(t, events)
if len(messages) != 0 {
t.Fatalf("messages = %+v, want none", messages)
}
@@ -2190,7 +2192,7 @@ func TestRunAgent_NoFilesRunsNormally(t *testing.T) {
if err != nil {
t.Fatalf("RunAgent without files: %v", err)
}
- messages, waiting, errs, done := drainAgentEvents(t, events)
+ messages, waiting, errs, _, done := drainAgentEvents(t, events)
if len(errs) > 0 {
t.Fatalf("unexpected error events without files: %+v", errs)
}