Skip to content

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

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.go
index 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 nil
diff --git a/internal/agent/canvas/parallel_subgraph_test.go b/internal/agent/canvas/parallel_subgraph_test.go
index 3a198162d7..61e6b88191 100644
--- a/internal/agent/canvas/parallel_subgraph_test.go
+++ b/internal/agent/canvas/parallel_subgraph_test.go
@@ -1,9 +1,42 @@
package canvas
import (
+ "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.go
index 48733e87ef..cfff7750f3 100644
--- a/internal/agent/workflowx/parallel.go
+++ b/internal/agent/workflowx/parallel.go
@@ -70,7 +70,7 @@ type parallelOptions struct {
runOpts []compose.Option
checkpointBuilder func(nodeKey string, index int) string
enableSubCheckpoint 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.go
index 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) {