Skip to content

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

fix(agent): save incomplete Message drafts and gate Run (#21355)

Sbaaoui Idrissdc0fdb185e42
diff --git a/internal/agent/canvas/compile_test.go b/internal/agent/canvas/compile_test.go
index 7adc4ba385..c4f08611d6 100644
--- a/internal/agent/canvas/compile_test.go
+++ b/internal/agent/canvas/compile_test.go
@@ -63,7 +63,7 @@ func TestCompile_LogsWhenLegacyNodesPresent(t *testing.T) {
Downstream: []string{"Body:1"},
},
"Body:1": {
- Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{}},
+ Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "body"}},
},
},
}
@@ -201,7 +201,7 @@ func TestCompile_PropagatesCheckPointID(t *testing.T) {
Components: map[string]CanvasComponent{
"begin": {Obj: CanvasComponentObj{ComponentName: "Begin", Params: map[string]any{}}},
"llm:0": {Obj: CanvasComponentObj{ComponentName: "LLM", Params: map[string]any{}}, Downstream: []string{"answer:0"}},
- "answer:0": {Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{}}},
+ "answer:0": {Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "answer"}}},
},
}
ctx := t.Context()
diff --git a/internal/agent/canvas/loop_subgraph_test.go b/internal/agent/canvas/loop_subgraph_test.go
index 069b016c9a..823f7ff9a3 100644
--- a/internal/agent/canvas/loop_subgraph_test.go
+++ b/internal/agent/canvas/loop_subgraph_test.go
@@ -583,7 +583,7 @@ func TestBuildWorkflow_LoopInstallsOneNode(t *testing.T) {
"loop_variables": []any{},
}},
Upstream: []string{"begin"}, Downstream: []string{"msg"}},
- "msg": {Obj: CanvasComponentObj{ComponentName: "Message"},
+ "msg": {Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "done"}},
Upstream: []string{"loop"}},
},
}
@@ -854,7 +854,7 @@ func TestBuildWorkflow_LoopWithBody(t *testing.T) {
"maximum_loop_count": 10,
}},
Upstream: []string{"begin"}, Downstream: []string{"a"}},
- "a": {Obj: CanvasComponentObj{ComponentName: "Message"},
+ "a": {Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "loop body"}},
Upstream: []string{"loop"}, Downstream: []string{"b"}},
"b": {Obj: CanvasComponentObj{ComponentName: "LLM"},
Upstream: []string{"a"}},
@@ -903,11 +903,11 @@ func TestBuildWorkflow_LoopBodyWithMultiTerminalCompiles(t *testing.T) {
Downstream: []string{"left", "right"},
},
"left": {
- Obj: CanvasComponentObj{ComponentName: "Message"},
+ Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "left"}},
Upstream: []string{"branch"},
},
"right": {
- Obj: CanvasComponentObj{ComponentName: "Message"},
+ Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "right"}},
Upstream: []string{"branch"},
},
},
diff --git a/internal/agent/canvas/multibranch_test.go b/internal/agent/canvas/multibranch_test.go
index d2492ace57..b8b43c544c 100644
--- a/internal/agent/canvas/multibranch_test.go
+++ b/internal/agent/canvas/multibranch_test.go
@@ -331,11 +331,11 @@ func TestMultiBranch_CompileSucceeds(t *testing.T) {
Upstream: []string{"begin"},
},
"a": {
- Obj: CanvasComponentObj{ComponentName: "Message"},
+ Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "a"}},
Upstream: []string{"switch_0"},
},
"b": {
- Obj: CanvasComponentObj{ComponentName: "Message"},
+ Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "b"}},
Upstream: []string{"switch_0"},
},
},
diff --git a/internal/agent/canvas/parallel_batch_test.go b/internal/agent/canvas/parallel_batch_test.go
index 1685c0ea05..e735a2de2d 100644
--- a/internal/agent/canvas/parallel_batch_test.go
+++ b/internal/agent/canvas/parallel_batch_test.go
@@ -43,9 +43,9 @@ func TestBuildWorkflow_ParallelBatchStructure(t *testing.T) {
c := &Canvas{
Components: map[string]CanvasComponent{
"begin": {Obj: CanvasComponentObj{ComponentName: "Begin"}, Downstream: []string{"a", "b"}},
- "a": {Obj: CanvasComponentObj{ComponentName: "Message"}, Downstream: []string{"final"}},
- "b": {Obj: CanvasComponentObj{ComponentName: "Message"}, Downstream: []string{"final"}},
- "final": {Obj: CanvasComponentObj{ComponentName: "Message"}},
+ "a": {Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "a"}}, Downstream: []string{"final"}},
+ "b": {Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "b"}}, Downstream: []string{"final"}},
+ "final": {Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "final"}}},
},
Path: []string{"begin", "a", "b", "final"},
}
diff --git a/internal/agent/canvas/parallel_timing_test.go b/internal/agent/canvas/parallel_timing_test.go
index ed8d833db2..e2c9a6600d 100644
--- a/internal/agent/canvas/parallel_timing_test.go
+++ b/internal/agent/canvas/parallel_timing_test.go
@@ -64,10 +64,10 @@ func TestCanvas_ParallelExecution_StaticAnalysis(t *testing.T) {
c := &Canvas{
Components: map[string]CanvasComponent{
"begin": {Obj: CanvasComponentObj{ComponentName: "Begin"}, Downstream: []string{"a", "b", "c"}},
- "a": {Obj: CanvasComponentObj{ComponentName: "Message"}, Downstream: []string{"final"}},
- "b": {Obj: CanvasComponentObj{ComponentName: "Message"}, Downstream: []string{"final"}},
- "c": {Obj: CanvasComponentObj{ComponentName: "Message"}, Downstream: []string{"final"}},
- "final": {Obj: CanvasComponentObj{ComponentName: "Message"}},
+ "a": {Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "a"}}, Downstream: []string{"final"}},
+ "b": {Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "b"}}, Downstream: []string{"final"}},
+ "c": {Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "c"}}, Downstream: []string{"final"}},
+ "final": {Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "final"}}},
},
Path: []string{"begin", "a", "b", "c", "final"},
}
diff --git a/internal/agent/canvas/scheduler_test.go b/internal/agent/canvas/scheduler_test.go
index 35c94bc005..171c8d1129 100644
--- a/internal/agent/canvas/scheduler_test.go
+++ b/internal/agent/canvas/scheduler_test.go
@@ -23,7 +23,7 @@ func TestBuildWorkflow_3NodeLinear(t *testing.T) {
Upstream: []string{"begin_0"},
},
"message_0": {
- Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{}},
+ Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "answer"}},
Downstream: []string{},
Upstream: []string{"llm_0"},
},
@@ -110,7 +110,7 @@ func TestBuildWorkflow_5NodeDiamond(t *testing.T) {
Upstream: []string{"a_0"},
},
"d_0": {
- Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{}},
+ Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "answer"}},
Downstream: []string{},
Upstream: []string{"b_0", "c_0"},
},
@@ -144,7 +144,7 @@ func TestBuildWorkflow_DuplicateUpstreamSucceeds(t *testing.T) {
Upstream: []string{"begin_0"},
},
"message_0": {
- Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{}},
+ Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "answer"}},
Upstream: []string{"categorize_0", "categorize_0"},
},
},
@@ -177,12 +177,12 @@ func TestBuildWorkflow_MultiTerminalSucceeds(t *testing.T) {
Upstream: []string{"begin_0"},
},
"b_0": {
- Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{}},
+ Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "answer a"}},
Downstream: []string{},
Upstream: []string{"a_0"},
},
"c_0": {
- Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{}},
+ Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "answer b"}},
Downstream: []string{},
Upstream: []string{"a_0"},
},
@@ -278,7 +278,7 @@ func TestBuildWorkflow_ErrorsOnUnknownUpstream(t *testing.T) {
Upstream: []string{},
},
"message_0": {
- Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{}},
+ Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"text": "answer"}},
Downstream: []string{},
Upstream: []string{"unknown_0"}, // <-- bad
},
diff --git a/internal/agent/component/dynamic_params.go b/internal/agent/component/dynamic_params.go
index d549267402..33dddc5cd0 100644
--- a/internal/agent/component/dynamic_params.go
+++ b/internal/agent/component/dynamic_params.go
@@ -12,27 +12,33 @@ var ErrCompilationTemplateRequired = errors.New("Compilation Template Group does
// ValidateDynamicEntries rejects blank values in repeatable Agent parameters.
func ValidateDynamicEntries(dsl map[string]any) error {
- return validateDynamicEntries(dsl)
+ return validateDynamicEntries(dsl, false)
}
-func validateDynamicEntries(value any) error {
+// ValidateDraftDynamicEntries allows unfinished Message content in saved drafts.
+// All other component checks remain the same as ValidateDynamicEntries.
+func ValidateDraftDynamicEntries(dsl map[string]any) error {
+ return validateDynamicEntries(dsl, true)
+}
+
+func validateDynamicEntries(value any, draft bool) error {
switch node := value.(type) {
case map[string]any:
if name, ok := node["component_name"].(string); ok {
if params, ok := node["params"].(map[string]any); ok {
- if err := validateDynamicParams(name, params); err != nil {
+ if err := validateDynamicParams(name, params, draft); err != nil {
return err
}
}
}
for _, child := range node {
- if err := validateDynamicEntries(child); err != nil {
+ if err := validateDynamicEntries(child, draft); err != nil {
return err
}
}
case []any:
for _, child := range node {
- if err := validateDynamicEntries(child); err != nil {
+ if err := validateDynamicEntries(child, draft); err != nil {
return err
}
}
@@ -40,7 +46,7 @@ func validateDynamicEntries(value any) error {
return nil
}
-func validateDynamicParams(component string, params map[string]any) error {
+func validateDynamicParams(component string, params map[string]any, draft bool) error {
for _, field := range []string{
"include_domains", "exclude_domains", "site_include", "site_exclude",
"country_include", "language_include",
@@ -59,6 +65,9 @@ func validateDynamicParams(component string, params map[string]any) error {
}
switch strings.ToLower(component) {
case "message":
+ if draft {
+ return nil
+ }
if err := validateMessageContent(params); err != nil {
return fmt.Errorf("[%s] %w", component, err)
}
@@ -126,6 +135,9 @@ func validateMessageContent(params map[string]any) error {
return fmt.Errorf("content does not support empty value")
}
case []string:
+ if len(values) == 0 {
+ return fmt.Errorf("content does not support empty value")
+ }
for _, value := range values {
if strings.TrimSpace(value) == "" {
return fmt.Errorf("content does not support empty entries")
diff --git a/internal/agent/component/dynamic_params_test.go b/internal/agent/component/dynamic_params_test.go
index 05a0994a2d..081193902b 100644
--- a/internal/agent/component/dynamic_params_test.go
+++ b/internal/agent/component/dynamic_params_test.go
@@ -95,6 +95,14 @@ func TestValidateDynamicEntries(t *testing.T) {
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
+ draftErr := ValidateDraftDynamicEntries(dslWithComponents(test.component))
+ if test.component["component_name"] == "Message" {
+ if draftErr != nil {
+ t.Fatalf("draft rejected Message: %v", draftErr)
+ }
+ } else if draftErr == nil || !strings.Contains(draftErr.Error(), test.want) {
+ t.Fatalf("draft validation changed: %v, want %q", draftErr, test.want)
+ }
err := ValidateDynamicEntries(dslWithComponents(test.component))
if err == nil || !strings.Contains(err.Error(), test.want) {
t.Fatalf("ValidateDynamicEntries() error = %v, want %q", err, test.want)
@@ -114,3 +122,13 @@ func dslWithComponents(components ...map[string]any) map[string]any {
func componentDSL(name string, params map[string]any) map[string]any {
return map[string]any{"component_name": name, "params": params}
}
+
+func TestMessageDSLFactoryRejectsIncompleteContent(t *testing.T) {
+ for _, params := range []map[string]any{
+ nil, {}, {"text": ""}, {"content": []string{}}, {"content": []string{"hello", ""}},
+ } {
+ if _, err := New("Message", params); err == nil || !strings.Contains(err.Error(), "content does not support empty") {
+ t.Fatalf("factory accepted %#v: %v", params, err)
+ }
+ }
+}
diff --git a/internal/agent/component/message.go b/internal/agent/component/message.go
index 951d6f0396..1573434347 100644
--- a/internal/agent/component/message.go
+++ b/internal/agent/component/message.go
@@ -638,5 +638,11 @@ func (m *MessageComponent) Outputs() map[string]string {
}
func init() {
- Register(componentNameMessage, NewMessageComponent)
+ Register(componentNameMessage, func(params map[string]any) (Component, error) {
+ // DSL factories run before execution; direct callers may supply text at Invoke.
+ if err := validateMessageContent(params); err != nil {
+ return nil, runtime.NewUserFacingError(fmt.Sprintf("[Message] %s", err))
+ }
+ return NewMessageComponent(params)
+ })
}
diff --git a/internal/agent/component/verify_p1_test.go b/internal/agent/component/verify_p1_test.go
index 83e4758c17..f8bf3e971e 100644
--- a/internal/agent/component/verify_p1_test.go
+++ b/internal/agent/component/verify_p1_test.go
@@ -60,7 +60,7 @@ func TestVerifyRegistration_P1(t *testing.T) {
// Case-insensitive lookup on a real component to prove the
// registry's name normalization works at lookup time.
- if c, err := New("Message", nil); err != nil || c == nil {
+ if c, err := New("Message", map[string]any{"text": "registered"}); err != nil || c == nil {
t.Errorf("New(Message) failed: c=%v err=%v", c, err)
}
diff --git a/internal/handler/agent_component_test.go b/internal/handler/agent_component_test.go
index c48f6b8363..58ffb220f0 100644
--- a/internal/handler/agent_component_test.go
+++ b/internal/handler/agent_component_test.go
@@ -269,6 +269,7 @@ func TestGetComponentInputForm_NoInputForm(t *testing.T) {
"obj": map[string]any{
"component_name": "Message",
// no params.inputs
+ "params": map[string]any{"text": "hello"},
},
},
},
diff --git a/internal/service/agent.go b/internal/service/agent.go
index 81f72ecad7..1d67c98785 100644
--- a/internal/service/agent.go
+++ b/internal/service/agent.go
@@ -971,7 +971,7 @@ func (s *AgentService) CreateAgent(ctx context.Context, userID string, req *Crea
if err := component.ValidateIntegerParameters(req.DSL); err != nil {
return nil, common.CodeArgumentError, fmt.Errorf("create agent: %w", err)
}
- if err := component.ValidateDynamicEntries(req.DSL); err != nil {
+ if err := component.ValidateDraftDynamicEntries(req.DSL); err != nil {
return nil, common.CodeArgumentError, fmt.Errorf("create agent: %w", err)
}
// Normalize legacy v1 / Go-v2 payloads to a React-Flow-shaped graph so
@@ -1194,7 +1194,11 @@ func (s *AgentService) UpdateAgent(ctx context.Context, userID, canvasID string,
if err := component.ValidateIntegerParameters(dslMap); err != nil {
return fmt.Errorf("update agent %s: %w", canvasID, err)
}
- if err := component.ValidateDynamicEntries(dslMap); err != nil {
+ validateEntries := component.ValidateDraftDynamicEntries
+ if release {
+ validateEntries = component.ValidateDynamicEntries
+ }
+ if err := validateEntries(dslMap); err != nil {
return fmt.Errorf("update agent %s: %w", canvasID, err)
}
if err := validateAgentChatModels(ctx, userID, canvasInstance.EffectiveTenantID(), dslMap); err != nil {
@@ -2252,6 +2256,9 @@ func (s *AgentService) buildRunFunc(canvasID string, versionRow *entity.UserCanv
zap.Error(err))
s.markAgentSessionFailed(ctx2, canvasID, userID, sessionID, "compile: "+err.Error())
s.markRunFailed(ctx2, runID, "compile: "+err.Error())
+ if _, ok := errors.AsType[*runtime.UserFacingError](err); ok {
+ return nil, err
+ }
if errors.Is(err, agenttool.ErrExeSQLNoCredentials) {
return nil, runtime.NewUserFacingError("ExeSQL configuration is incomplete. Set the database connection details before running the agent.")
}
diff --git a/internal/service/agent_message_draft_test.go b/internal/service/agent_message_draft_test.go
new file mode 100644
index 0000000000..b5370d4586
--- /dev/null
+++ b/internal/service/agent_message_draft_test.go
@@ -0,0 +1,107 @@
+package service
+
+import (
+ "errors"
+ "reflect"
+ "strings"
+ "testing"
+
+ "ragflow/internal/agent/canvas"
+ "ragflow/internal/agent/runtime"
+ "ragflow/internal/common"
+ "ragflow/internal/dao"
+ "ragflow/internal/entity"
+)
+
+func messageDraftDSL(params map[string]any) entity.JSONMap {
+ return entity.JSONMap{"graph": map[string]any{"nodes": []any{map[string]any{"id": "begin"}, map[string]any{"id": "message"}}, "edges": []any{}}, "components": map[string]any{
+ "begin": map[string]any{"obj": map[string]any{"component_name": "Begin", "params": map[string]any{}}, "downstream": []any{"message"}},
+ "message": map[string]any{"obj": map[string]any{"component_name": "Message", "params": params}, "upstream": []any{"begin"}},
+ }, "path": []any{}}
+}
+
+func TestMessageDraftRoundTripAndExecution(t *testing.T) {
+ setupAgentSessionServiceTest(t)
+ tests := []struct {
+ name string
+ params map[string]any
+ valid bool
+ }{
+ {"missing", map[string]any{}, false},
+ {"empty text", map[string]any{"text": ""}, false},
+ {"blank text", map[string]any{"text": " \t"}, false},
+ {"empty string", map[string]any{"content": ""}, false},
+ {"null", map[string]any{"content": nil}, false},
+ {"empty array", map[string]any{"content": []any{}}, false},
+ {"empty rows", map[string]any{"content": []any{"", " "}}, false},
+ {"partial", map[string]any{"content": []any{"hello", ""}}, false},
+ {"valid", map[string]any{"content": []any{"hello", "world"}}, true},
+ {"valid text", map[string]any{"text": "hello"}, true},
+ }
+ svc := NewAgentService()
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ title := "Message " + tt.name
+ row, code, err := svc.CreateAgent(t.Context(), "user-1", &CreateAgentRequest{Title: &title, DSL: messageDraftDSL(tt.params)})
+ if err != nil || code != common.CodeSuccess {
+ t.Fatalf("create: code=%v err=%v", code, err)
+ }
+ for range 2 {
+ if err := svc.UpdateAgent(t.Context(), "user-1", row.ID, map[string]any{"dsl": messageDraftDSL(tt.params)}); err != nil {
+ t.Fatalf("save: %v", err)
+ }
+ saved, err := svc.GetAgent(t.Context(), "user-1", row.ID)
+ if err != nil {
+ t.Fatal(err)
+ }
+ got := saved.DSL["components"].(map[string]any)["message"].(map[string]any)["obj"].(map[string]any)["params"]
+ if !reflect.DeepEqual(got, tt.params) {
+ t.Fatalf("params=%#v want %#v", got, tt.params)
+ }
+ versions, err := dao.NewUserCanvasVersionDAO().ListByCanvasID(t.Context(), dao.DB, row.ID)
+ if err != nil || len(versions) != 1 {
+ t.Fatalf("versions=%v err=%v", len(versions), err)
+ }
+ if !reflect.DeepEqual(versions[0].DSL["components"].(map[string]any)["message"].(map[string]any)["obj"].(map[string]any)["params"], tt.params) {
+ t.Fatal("draft version changed params")
+ }
+ }
+ c, err := canvas.DecodeFromDSL(messageDraftDSL(tt.params))
+ if err != nil {
+ t.Fatal(err)
+ }
+ compiled, err := canvas.Compile(t.Context(), c)
+ if !tt.valid {
+ _, runErr := svc.buildRunFunc(row.ID, nil, messageDraftDSL(tt.params))(t.Context(), map[string]any{"user_id": "user-1"})
+ _, userFacing := errors.AsType[*runtime.UserFacingError](runErr)
+ if !userFacing || !strings.Contains(runErr.Error(), "content does not support empty") {
+ t.Fatalf("run must return clear validation error: %v", runErr)
+ }
+ if err == nil || !strings.Contains(err.Error(), "content does not support empty") {
+ t.Fatalf("compile error=%v", err)
+ }
+ if err := svc.UpdateAgent(t.Context(), "user-1", row.ID, map[string]any{"dsl": messageDraftDSL(tt.params), "release": true}); err == nil {
+ t.Fatal("release accepted incomplete Message")
+ }
+ if _, err := svc.PublishAgent(t.Context(), "user-1", row.ID, &PublishAgentRequest{DSL: messageDraftDSL(tt.params)}); err == nil {
+ t.Fatal("publish accepted incomplete Message")
+ }
+ return
+ }
+ if err != nil {
+ t.Fatal(err)
+ }
+ state := canvas.NewCanvasState("message-test", "message-test")
+ if _, err := compiled.Workflow.Invoke(canvas.WithState(t.Context(), state), map[string]any{}); err != nil {
+ t.Fatalf("invoke: %v", err)
+ }
+ want := "hello"
+ if tt.name == "valid" {
+ want = "helloworld"
+ }
+ if got, err := state.GetVar("message@content"); err != nil || got != want {
+ t.Fatalf("content = %#v err=%v, want %q", got, err, want)
+ }
+ })
+ }
+}
diff --git a/web/src/pages/agent/hooks/use-canvas-checklist.ts b/web/src/pages/agent/hooks/use-canvas-checklist.ts
index 03675dc005..c28af33d32 100644
--- a/web/src/pages/agent/hooks/use-canvas-checklist.ts
+++ b/web/src/pages/agent/hooks/use-canvas-checklist.ts
@@ -60,7 +60,7 @@ function collectAllDatasetIds(nodes: RAGFlowNodeType[]): string[] {
/**
* Real-time canvas issues for the checklist panel, debounced so dragging a
* node does not recompute every frame. The checklist only reports issues to
- * the user; it does not gate any entry points.
+ * the user. Run checks blocking rules synchronously, without this debounce.
*/
export function useCanvasChecklist({
ownerTenantId,
diff --git a/web/src/pages/agent/hooks/use-run-preflight.test.ts b/web/src/pages/agent/hooks/use-run-preflight.test.ts
new file mode 100644
index 0000000000..a0f5633412
--- /dev/null
+++ b/web/src/pages/agent/hooks/use-run-preflight.test.ts
@@ -0,0 +1,153 @@
+import message from '@/components/ui/message';
+import { act, renderHook } from '@testing-library/react';
+import useGraphStore from '../store';
+import * as checklist from '../utils/canvas-checklist';
+import {
+ useSaveGraph,
+ useSaveGraphBeforeOpeningDebugDrawer,
+} from './use-save-graph';
+
+const mockSetAgent = jest.fn();
+const mockResetAgent = jest.fn();
+const mockBuildDslData = jest.fn();
+
+jest.mock('@/hooks/use-agent-request', () => ({
+ useFetchAgent: () => ({ data: { title: 'Draft' } }),
+ useSetAgent: () => ({ setAgent: mockSetAgent, loading: false }),
+ useResetAgent: () => ({ resetAgent: mockResetAgent }),
+}));
+jest.mock('./use-build-dsl', () => ({
+ useBuildDslData: () => ({ buildDslData: mockBuildDslData }),
+}));
+jest.mock('react-router', () => ({ useParams: () => ({ id: 'agent-1' }) }));
+jest.mock('@/components/ui/message', () => ({
+ __esModule: true,
+ default: { error: jest.fn() },
+}));
+jest.mock('@/locales/config', () => ({
+ __esModule: true,
+ default: { t: (key: string) => key },
+}));
+
+jest.mock('../utils/canvas-checklist', () => {
+ const actual = jest.requireActual('../utils/canvas-checklist');
+ return {
+ ...actual,
+ collectCanvasIssues: jest.fn(actual.collectCanvasIssues),
+ };
+});
+
+const node = (label: string, form: Record<string, unknown>) =>
+ ({ id: `${label}:1`, data: { label, name: label, form } }) as any;
+
+describe('Run preflight', () => {
+ beforeEach(() => {
+ jest.clearAllMocks();
+ mockSetAgent.mockResolvedValue({ code: 0 });
+ mockResetAgent.mockResolvedValue({ code: 0 });
+ useGraphStore.setState({ nodes: [], edges: [], editedNodeFormIds: [] });
+ });
+
+ it('blocks any run-blocking issue before saving, resetting or opening chat', async () => {
+ jest.mocked(checklist.collectCanvasIssues).mockReturnValueOnce([
+ {
+ nodeId: 'future-node',
+ nodeName: 'Future block',
+ operatorLabel: 'Future',
+ type: checklist.CanvasIssueType.MissingRequired,
+ messageKey: 'future.emptyEntry',
+ blocksRun: true,
+ },
+ ]);
+ const show = jest.fn();
+ const { result } = renderHook(() =>
+ useSaveGraphBeforeOpeningDebugDrawer(show),
+ );
+ await act(async () => {
+ await result.current.handleRun();
+ });
+ expect(message.error).toHaveBeenCalledWith(
+ 'Future block: future.emptyEntry',
+ );
+ expect(mockSetAgent).not.toHaveBeenCalled();
+ expect(mockResetAgent).not.toHaveBeenCalled();
+ expect(show).not.toHaveBeenCalled();
+ });
+
+ it.each([{}, { content: [] }, { content: ['hello', ''] }, { text: '' }])(
+ 'rejects incomplete Message %j without opening chat',
+ async (form) => {
+ useGraphStore.setState({ nodes: [node('Message', form)] });
+ const show = jest.fn();
+ const { result } = renderHook(() =>
+ useSaveGraphBeforeOpeningDebugDrawer(show),
+ );
+ await act(async () => {
+ await result.current.handleRun();
+ });
+ expect(message.error).toHaveBeenCalledWith('Message: flow.messageMsg');
+ expect(mockResetAgent).not.toHaveBeenCalled();
+ expect(show).not.toHaveBeenCalled();
+ },
+ );
+
+ it('reads current nodes at click time and accepts valid text without gating advisory issues', async () => {
+ useGraphStore.setState({ nodes: [node('Message', {})] });
+ const show = jest.fn();
+ const { result } = renderHook(() =>
+ useSaveGraphBeforeOpeningDebugDrawer(show),
+ );
+ useGraphStore.setState({
+ nodes: [node('Message', { text: 'hello' }), node('Compiler', {})],
+ });
+ await act(async () => {
+ await result.current.handleRun();
+ });
+ expect(message.error).not.toHaveBeenCalled();
+ expect(mockSetAgent).toHaveBeenCalled();
+ expect(mockResetAgent).toHaveBeenCalled();
+ expect(show).toHaveBeenCalledTimes(1);
+ });
+
+ it.each([
+ { content: ['hello'] },
+ { content: 'hello' },
+ { text: 'hello', content: [] },
+ ])('opens chat for valid Message %j', async (form) => {
+ useGraphStore.setState({ nodes: [node('Message', form)] });
+ const show = jest.fn();
+ const { result } = renderHook(() =>
+ useSaveGraphBeforeOpeningDebugDrawer(show),
+ );
+ await act(async () => {
+ await result.current.handleRun();
+ });
+ expect(message.error).not.toHaveBeenCalled();
+ expect(show).toHaveBeenCalledTimes(1);
+ });
+
+ it('still saves drafts with incomplete Message content', async () => {
+ useGraphStore.setState({ nodes: [node('Message', { content: [''] })] });
+ const { result } = renderHook(() => useSaveGraph());
+ await act(async () => {
+ await result.current.saveGraph();
+ });
+ expect(mockSetAgent).toHaveBeenCalled();
+ expect(message.error).not.toHaveBeenCalled();
+ });
+
+ it('validates explicit nextNodes before opening chat', async () => {
+ useGraphStore.setState({
+ nodes: [node('Message', { content: ['hello'] })],
+ });
+ const show = jest.fn();
+ const { result } = renderHook(() =>
+ useSaveGraphBeforeOpeningDebugDrawer(show),
+ );
+ await act(async () => {
+ await result.current.handleRun([node('Message', { content: [''] })]);
+ });
+ expect(show).not.toHaveBeenCalled();
+ expect(mockResetAgent).not.toHaveBeenCalled();
+ });
+});
diff --git a/web/src/pages/agent/hooks/use-save-graph.ts b/web/src/pages/agent/hooks/use-save-graph.ts
index 6932b73f56..5678f9c6eb 100644
--- a/web/src/pages/agent/hooks/use-save-graph.ts
+++ b/web/src/pages/agent/hooks/use-save-graph.ts
@@ -1,3 +1,4 @@
+import message from '@/components/ui/message';
import {
useFetchAgent,
useResetAgent,
@@ -8,10 +9,12 @@ import {
RAGFlowNodeType,
} from '@/interfaces/database/agent';
import { formatDate } from '@/utils/date';
+import i18n from '@/locales/config';
import { useDebounceEffect } from 'ahooks';
import { useCallback, useEffect, useState } from 'react';
import { useParams } from 'react-router';
import useGraphStore from '../store';
+import { collectCanvasIssues } from '../utils/canvas-checklist';
import { useBuildDslData } from './use-build-dsl';
export const useSaveGraph = (
@@ -23,8 +26,7 @@ export const useSaveGraph = (
const { id } = useParams();
const { buildDslData } = useBuildDslData();
- // Saving is always allowed, even with unresolved canvas issues — those are
- // only surfaced to the user by the canvas checklist (useCanvasChecklist).
+ // Draft saving is independent of run-readiness checks.
const saveGraph = useCallback(
async (
currentNodes?: RAGFlowNodeType[],
@@ -61,6 +63,18 @@ export const useSaveGraphBeforeOpeningDebugDrawer = (show: () => void) => {
const handleRun = useCallback(
async (nextNodes?: RAGFlowNodeType[]) => {
+ const { nodes, edges, editedNodeFormIds } = useGraphStore.getState();
+ const issue = collectCanvasIssues({
+ nodes: nextNodes ?? nodes,
+ edges,
+ editedNodeFormIds,
+ }).find((issue) => issue.blocksRun);
+ if (issue) {
+ message.error(
+ `${issue.nodeName}: ${i18n.t(issue.messageKey, issue.messageParams)}`,
+ );
+ return;
+ }
const saveRet = await saveGraph(nextNodes);
if (saveRet?.code === 0) {
// Call the reset api before opening the run drawer each time
diff --git a/web/src/pages/agent/index.tsx b/web/src/pages/agent/index.tsx
index c62d65872b..bd487b2a71 100644
--- a/web/src/pages/agent/index.tsx
+++ b/web/src/pages/agent/index.tsx
@@ -119,8 +119,7 @@ export default function Agent() {
saveGraph();
}, [saveGraph]);
const { flowDetail: agentDetail } = useFetchDataOnMount();
- // The canvas checklist only surfaces issues to the user; it never gates
- // the save/run/explore/publish/embed entry points.
+ // The checklist displays all issues; Run separately checks blocking rules.
const { issues } = useCanvasChecklist({
ownerTenantId: agentDetail?.tenant_id,
canvasID: id,
diff --git a/web/src/pages/agent/utils.test.ts b/web/src/pages/agent/utils.test.ts
index 96cfbbbf66..5247444360 100644
--- a/web/src/pages/agent/utils.test.ts
+++ b/web/src/pages/agent/utils.test.ts
@@ -447,17 +447,19 @@ describe('receiveMessageError', () => {
describe('Message component content validation', () => {
describe('isEmptyMessageContent', () => {
- it('treats missing, non-array and blank-only content as empty', () => {
+ it('rejects missing, malformed and blank content', () => {
expect(isEmptyMessageContent()).toBe(true);
expect(isEmptyMessageContent(null)).toBe(true);
- expect(isEmptyMessageContent('hello')).toBe(true);
+ expect(isEmptyMessageContent('')).toBe(true);
+ expect(isEmptyMessageContent(' \t ')).toBe(true);
expect(isEmptyMessageContent([])).toBe(true);
expect(isEmptyMessageContent(['', ' \t '])).toBe(true);
// Non-string entries never satisfy the backend either.
expect(isEmptyMessageContent([123])).toBe(true);
});
- it('accepts content with at least one non-blank string entry', () => {
+ it('accepts strings and arrays without blank entries', () => {
+ expect(isEmptyMessageContent('hello')).toBe(false);
expect(isEmptyMessageContent(['hi'])).toBe(false);
expect(isEmptyMessageContent(['', '{begin@query}'])).toBe(true);
expect(isEmptyMessageContent([' text '])).toBe(false);
diff --git a/web/src/pages/agent/utils.ts b/web/src/pages/agent/utils.ts
index 3dfa5a9035..c47a91feec 100644
--- a/web/src/pages/agent/utils.ts
+++ b/web/src/pages/agent/utils.ts
@@ -1058,12 +1058,13 @@ export function convertToObjectArray<T extends string | number | boolean>(
}
/**
- * Message (回复消息) components keep their texts in form.content (string[]).
- * The backend rejects the component at canvas run time unless at least one
- * entry is a non-blank string, so missing/non-array/blank-only content all
- * count as empty here as well.
+ * Message accepts text/content strings or content arrays; every entry must
+ * be a non-blank string to match backend execution validation.
*/
export function isEmptyMessageContent(content?: unknown): boolean {
+ if (typeof content === 'string') {
+ return content.trim() === '';
+ }
return (
!Array.isArray(content) ||
content.length === 0 ||
diff --git a/web/src/pages/agent/utils/canvas-checklist.ts b/web/src/pages/agent/utils/canvas-checklist.ts
index 1994f14f4e..e743950b69 100644
--- a/web/src/pages/agent/utils/canvas-checklist.ts
+++ b/web/src/pages/agent/utils/canvas-checklist.ts
@@ -52,6 +52,7 @@ export type CanvasIssue = {
type: CanvasIssueType;
messageKey: string;
messageParams?: Record<string, string>;
+ blocksRun?: boolean;
};
export type CanvasChecklistInputs = {
@@ -503,11 +504,15 @@ export function collectCanvasIssues({
});
}
- if (label === Operator.Message && isEmptyMessageContent(form?.content)) {
+ if (
+ label === Operator.Message &&
+ isEmptyMessageContent(form && 'text' in form ? form.text : form?.content)
+ ) {
issues.push({
...target,
type: CanvasIssueType.MissingRequired,
messageKey: 'flow.messageMsg',
+ blocksRun: true,
});
}