Skip to content

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

fix(agent): return the StringTransform split result as a generic list (#20920)

Eugene Kalininc2457770a903
diff --git a/internal/agent/component/string_transform.go b/internal/agent/component/string_transform.go
index 88dc181464..8973db95c3 100644
--- a/internal/agent/component/string_transform.go
+++ b/internal/agent/component/string_transform.go
@@ -290,8 +290,10 @@ func (s *StringTransformComponent) doSplit(_ context.Context, state *runtime.Can
// matches. This mirrors Python's re.split with a capture group
// (which interleaves content and delimiter tokens) followed by
// dropping the odd-indexed (delimiter) tokens. When there are no
- // matches, the whole input is a single content token.
- kept := make([]string, 0, len(matches)+1)
+ // matches, the whole input is a single content token. The result is
+ // []any, like other canvas lists, so ListOperations and the
+ // VariableAssigner list operators accept it.
+ kept := make([]any, 0, len(matches)+1)
prevEnd := 0
for _, m := range matches {
kept = append(kept, varValue[prevEnd:m[0]])
diff --git a/internal/agent/component/string_transform_test.go b/internal/agent/component/string_transform_test.go
index 0540085261..a639b4a695 100644
--- a/internal/agent/component/string_transform_test.go
+++ b/internal/agent/component/string_transform_test.go
@@ -40,8 +40,8 @@ func TestStringTransform_SplitBasic(t *testing.T) {
if err != nil {
t.Fatalf("Invoke: %v", err)
}
- got, _ := out["result"].([]string)
- want := []string{"a", "b", "c"}
+ got, _ := out["result"].([]any)
+ want := []any{"a", "b", "c"}
if !reflect.DeepEqual(got, want) {
t.Errorf("split: got %v, want %v", got, want)
}
@@ -60,8 +60,8 @@ func TestStringTransform_SplitNoDelim(t *testing.T) {
if err != nil {
t.Fatalf("Invoke: %v", err)
}
- got, _ := out["result"].([]string)
- want := []string{"abc"}
+ got, _ := out["result"].([]any)
+ want := []any{"abc"}
if !reflect.DeepEqual(got, want) {
t.Errorf("split: got %v, want %v", got, want)
}
@@ -122,8 +122,8 @@ func TestStringTransform_SplitFromStateRef(t *testing.T) {
if err != nil {
t.Fatalf("Invoke: %v", err)
}
- got, _ := out["result"].([]string)
- want := []string{"alpha", "beta", "gamma"}
+ got, _ := out["result"].([]any)
+ want := []any{"alpha", "beta", "gamma"}
if !reflect.DeepEqual(got, want) {
t.Errorf("split from state: got %v, want %v", got, want)
}
@@ -216,13 +216,78 @@ func TestStringTransform_SplitStringDelimiter(t *testing.T) {
if err != nil {
t.Fatalf("Invoke: %v", err)
}
- got, _ := out["result"].([]string)
- want := []string{"a", "b"}
+ got, _ := out["result"].([]any)
+ want := []any{"a", "b"}
if !reflect.DeepEqual(got, want) {
t.Errorf("split: got %v, want %v", got, want)
}
}
+// splitIntoState runs a split of line on "," and stores the outputs under
+// cpnID, the way the canvas records a node's outputs for later nodes.
+func splitIntoState(t *testing.T, state *canvas.CanvasState, cpnID, line string) {
+ t.Helper()
+ c, err := NewStringTransformComponent(map[string]any{
+ "method": "split",
+ "delimiters": []string{","},
+ })
+ if err != nil {
+ t.Fatalf("NewStringTransformComponent: %v", err)
+ }
+ out, err := c.Invoke(canvas.WithState(t.Context(), state), nil, map[string]any{"line": line})
+ if err != nil {
+ t.Fatalf("split Invoke: %v", err)
+ }
+ state.Outputs[cpnID] = out
+}
+
+// TestStringTransform_SplitFeedsListOperations: a split result is a list
+// that ListOperations accepts in the same run.
+func TestStringTransform_SplitFeedsListOperations(t *testing.T) {
+ state := canvas.NewCanvasState("run-8", "task-8")
+ splitIntoState(t, state, "st_0", "a,b,c")
+
+ c, err := NewListOperationsComponent(map[string]any{
+ "query": "st_0@result",
+ "operations": "head",
+ "n": 2,
+ })
+ if err != nil {
+ t.Fatalf("NewListOperationsComponent: %v", err)
+ }
+ out, err := c.Invoke(canvas.WithState(t.Context(), state), nil, nil)
+ if err != nil {
+ t.Fatalf("ListOperations Invoke: %v", err)
+ }
+ got, _ := out["result"].([]any)
+ want := []any{"a", "b"}
+ if !reflect.DeepEqual(got, want) {
+ t.Errorf("head: got %v, want %v", got, want)
+ }
+}
+
+// TestStringTransform_SplitFeedsVariableAssignerAppend: a split result is a
+// list that the VariableAssigner append operator accepts in the same run.
+func TestStringTransform_SplitFeedsVariableAssignerAppend(t *testing.T) {
+ state := canvas.NewCanvasState("run-9", "task-9")
+ splitIntoState(t, state, "st_0", "a,b,c")
+
+ c, err := NewVariableAssignerComponent(map[string]any{"variables": []map[string]any{
+ {"variable": "st_0@result", "operator": "append", "parameter": "d"},
+ }})
+ if err != nil {
+ t.Fatalf("NewVariableAssignerComponent: %v", err)
+ }
+ if _, err := c.Invoke(canvas.WithState(t.Context(), state), nil, nil); err != nil {
+ t.Fatalf("VariableAssigner Invoke: %v", err)
+ }
+ got := state.Outputs["st_0"]["result"]
+ want := []any{"a", "b", "c", "d"}
+ if !reflect.DeepEqual(got, want) {
+ t.Errorf("st_0@result: got %v, want %v", got, want)
+ }
+}
+
// TestStringTransform_EmptyStringDelimiter: delimiters="" is rejected.
func TestStringTransform_EmptyStringDelimiter(t *testing.T) {
_, err := NewStringTransformComponent(map[string]any{