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(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.goindex 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 strruntime.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.goindex 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.goindex 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.UserCanvs.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 falsediff --git a/internal/service/agent_deferred_failure_test.go b/internal/service/agent_deferred_failure_test.gonew file mode 100644index 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.goindex 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 []ct.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)}