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
refactor(canvas): reject failed parallel state clones (#20443)
Sbaaoui Idrissd62b4ed2717e
diff --git a/internal/agent/canvas/parallel_subgraph.go b/internal/agent/canvas/parallel_subgraph.goindex 7b6a14757c..f018d45da8 100644--- a/internal/agent/canvas/parallel_subgraph.go+++ b/internal/agent/canvas/parallel_subgraph.go@@ -222,26 +222,19 @@ func buildParallelOuterWorkflow(}parOpts = append(parOpts, workflowx.WithParallelContextBuilder(func(ctx context.Context, item any, index int,- ) context.Context {+ ) (context.Context, error) {parentState, err := runtime.GetStateFromContext(ctx)if err != nil || parentState == nil {- return ctx+ return ctx, nil}itemMap, _ := item.(map[string]any)- // cloneCanvasState can fail (e.g. unsupported value in a Sys/Env- // field that the JSON round-trip rejects). When it does, fall- // back to a fresh per-item state so concurrent workers never- // share the same CanvasState — sharing would corrupt Globals- // and Outputs across items.localState, cloneErr := cloneCanvasState(parentState)- if cloneErr != nil || localState == nil {- localState = runtime.NewCanvasState(parentState.RunID, parentState.SessionID)- localState.Sys = shallowCopyAnyMap(parentState.Sys)- localState.Globals = shallowCopyAnyMap(parentState.Globals)+ if cloneErr != nil {+ return nil, fmt.Errorf("agent: parallel %q item %d: clone state: %w", key, index, cloneErr)}localState.Globals["__item__"] = itemMap["item"]localState.Globals["__index__"] = index- return runtime.WithState(ctx, localState)+ return runtime.WithState(ctx, localState), nil}))parNode, err := workflowx.AddParallelNode[map[string]any, map[string]any](@@ -316,20 +309,6 @@ func cloneCanvasState(src *CanvasState) (*CanvasState, error) {return dst, nil}-// shallowCopyAnyMap returns a new map with the same keys/values as src.-// A nil src yields an empty (non-nil) map so callers can assign into the-// result without nil checks. Values are shared, not deep-copied.-func shallowCopyAnyMap(src map[string]any) map[string]any {- if src == nil {- return map[string]any{}- }- dst := make(map[string]any, len(src))- for k, v := range src {- dst[k] = v- }- return dst-}-func resolveParallelItemRef(itemOut map[string]any, ref string) any {if ref == "" || itemOut == nil {return nildiff --git a/internal/agent/canvas/parallel_subgraph_test.go b/internal/agent/canvas/parallel_subgraph_test.goindex 3a198162d7..61e6b88191 100644--- a/internal/agent/canvas/parallel_subgraph_test.go+++ b/internal/agent/canvas/parallel_subgraph_test.go@@ -1,9 +1,42 @@package canvasimport (+ "errors"+ "strings""testing")+type failingParallelCloneValue struct{}++func (failingParallelCloneValue) MarshalJSON() ([]byte, error) {+ return nil, errors.New("clone failure")+}++func TestParallelCloneFailureStopsItemBeforeInvocation(t *testing.T) {+ c := &Canvas{Components: map[string]CanvasComponent{+ "Message:body": {Obj: CanvasComponentObj{ComponentName: "Message", Params: map[string]any{"content": []any{"done"}}}},+ }}+ sub, err := buildParallelItemWorkflow(t.Context(), c, "parallel", map[string]bool{"Message:body": true})+ if err != nil {+ t.Fatal(err)+ }+ outer, err := buildParallelOuterWorkflow(t.Context(), "parallel", "sys.items", 1, nil, sub)+ if err != nil {+ t.Fatal(err)+ }+ runnable, err := outer.Compile(t.Context())+ if err != nil {+ t.Fatal(err)+ }+ state := NewCanvasState("run", "session")+ state.Sys["items"] = []any{"one"}+ state.Sys["broken"] = failingParallelCloneValue{}+ _, err = runnable.Invoke(withState(t.Context(), state), map[string]any{})+ if err == nil || !strings.Contains(err.Error(), "clone failure") {+ t.Fatalf("Invoke error = %v; want clone failure", err)+ }+}+func TestCollectGroupedMembers_UsesParentMetadata(t *testing.T) {c := &Canvas{Components: map[string]CanvasComponent{diff --git a/internal/agent/workflowx/parallel.go b/internal/agent/workflowx/parallel.goindex 48733e87ef..cfff7750f3 100644--- a/internal/agent/workflowx/parallel.go+++ b/internal/agent/workflowx/parallel.go@@ -70,7 +70,7 @@ type parallelOptions struct {runOpts []compose.OptioncheckpointBuilder func(nodeKey string, index int) stringenableSubCheckpoint bool- contextBuilder func(ctx context.Context, item any, index int) context.Context+ contextBuilder func(ctx context.Context, item any, index int) (context.Context, error)}// WithParallelMaxConcurrency caps the number of per-item sub-workflow@@ -146,10 +146,9 @@ func WithParallelEnableSubCheckpoint(enable bool) ParallelOption {}// WithParallelContextBuilder decorates the per-item sub-workflow-// context before Invoke. This lets callers attach item-scoped runtime-// state without changing the outer []I -> []O parallel API.+// context before Invoke. A builder error skips invoking that item.func WithParallelContextBuilder(- b func(ctx context.Context, item any, index int) context.Context,+ b func(ctx context.Context, item any, index int) (context.Context, error),) ParallelOption {return func(o *parallelOptions) {if b != nil {@@ -666,7 +665,12 @@ func runParallelFanout[I, O any](// Bridge store wiring for this item.subCtx = withParallelBridgeState(subCtx, bridgeState)if options.contextBuilder != nil {- subCtx = options.contextBuilder(subCtx, items[idx], idx)+ var err error+ subCtx, err = options.contextBuilder(subCtx, items[idx], idx)+ if err != nil {+ resultCh <- parallelTaskResult{index: idx, err: err}+ return+ }}invokeOpts := make([]compose.Option, 0, len(options.runOpts)+1)diff --git a/internal/agent/workflowx/parallel_test.go b/internal/agent/workflowx/parallel_test.goindex b75178ca48..2e0185554e 100644--- a/internal/agent/workflowx/parallel_test.go+++ b/internal/agent/workflowx/parallel_test.go@@ -638,6 +638,36 @@ func TestParallel_InvokeRejectsInputCountMismatch(t *testing.T) {}}+func TestParallel_ResumeBuilderFailureSkipsItemInvocation(t *testing.T) {+ cloneErr := errors.New("state clone failed")+ payload, err := encodeParallelState(ParallelInterruptState{+ OriginalInputsJSON: []byte(`[1,2]`),+ CompletedResults: map[int]any{0: 10},+ InterruptedIndices: []int{1},+ TotalCount: 2,+ })+ if err != nil {+ t.Fatal(err)+ }+ var calls atomic.Int32+ sub := testCountingRunnable{fn: func(_ context.Context, in int, _ ...compose.Option) (int, error) {+ calls.Add(1)+ return in, nil+ }}+ opts := getParallelOptions([]ParallelOption{+ WithParallelContextBuilder(func(ctx context.Context, _ any, _ int) (context.Context, error) {+ return ctx, cloneErr+ }),+ })+ _, err = runParallelInvoke(injectResumeState(t.Context(), payload), "par", sub, nil, opts, newParallelBridgeState(nil))+ if !errors.Is(err, cloneErr) {+ t.Fatalf("resume error = %v, want state clone failure", err)+ }+ if calls.Load() != 0 {+ t.Fatalf("sub invoked %d times after state clone failure", calls.Load())+ }+}+// TestParallel_EmptyInput_NoSubInvoke asserts that an empty input// slice returns []O{}, nil without invoking the inner sub-workflow.func TestParallel_EmptyInput_NoSubInvoke(t *testing.T) {