feat: enhance condition handling with enum value options and metadata in workflow components

internal/ai/workflow/validator/validator.go

@@ -357,8 +357,17 @@ func (v *definitionValidator) validateCondition(field string, sourceNodeID strin
 	if !ok {
 		return
 	}
-	if _, ok := findOutputSpec(sourceSpec.OutputSchema, sourceField); !ok {
+	outputSpec, ok := findOutputSpec(sourceSpec.OutputSchema, sourceField)
+	if !ok {
 		v.addError(field+".left", "condition source field does not exist: "+sourceSelectorNodeID+"."+sourceField)
+		return
+	}
+	if len(outputSpec.Operators) > 0 && !stringInSlice(outputSpec.Operators, operator) {
+		v.addError(field+".operator", "condition operator is not allowed for variable: "+operator)
+		return
+	}
+	if !conditionOperatorWithoutRight(operator) && len(outputSpec.ValueOptions) > 0 && !valueOptionExists(outputSpec.ValueOptions, condition.Right) {
+		v.addError(field+".right", "condition comparison value is not allowed")
 	}
 }
 
@@ -371,6 +380,61 @@ func isSupportedConditionOperator(operator string) bool {
 	}
 }
 
+func conditionOperatorWithoutRight(operator string) bool {
+	switch strings.TrimSpace(operator) {
+	case "exists", "not_exists", "truthy", "is_true", "falsy", "is_false":
+		return true
+	default:
+		return false
+	}
+}
+
+func stringInSlice(items []string, value string) bool {
+	for _, item := range items {
+		if strings.TrimSpace(item) == value {
+			return true
+		}
+	}
+	return false
+}
+
+func valueOptionExists(items []registry.VariableValueOption, value any) bool {
+	for _, item := range items {
+		if conditionValuesEqual(item.Value, value) {
+			return true
+		}
+	}
+	return false
+}
+
+func conditionValuesEqual(left any, right any) bool {
+	switch l := left.(type) {
+	case string:
+		r, ok := right.(string)
+		return ok && l == r
+	case bool:
+		r, ok := right.(bool)
+		return ok && l == r
+	case int:
+		return conditionValuesEqual(float64(l), right)
+	case int64:
+		return conditionValuesEqual(float64(l), right)
+	case float64:
+		switch r := right.(type) {
+		case int:
+			return l == float64(r)
+		case int64:
+			return l == float64(r)
+		case float64:
+			return l == r
+		default:
+			return false
+		}
+	default:
+		return false
+	}
+}
+
 func (v *definitionValidator) hasPath(sourceID string, targetID string, visiting map[string]struct{}) bool {
 	if sourceID == targetID {
 		return false

internal/ai/workflow/validator/validator_test.go

@@ -304,6 +304,19 @@ func TestValidateDefinitionRejectsUnknownConditionVariable(t *testing.T) {
 	}
 }
 
+func TestValidateDefinitionRejectsInvalidConditionEnumValue(t *testing.T) {
+	def := policyConditionDefinition("unknown_action")
+
+	result := validator.ValidateDefinition(def, registry.DefaultRegistry())
+
+	if result.Valid {
+		t.Fatalf("expected invalid enum condition value to be rejected")
+	}
+	if !hasValidationMessage(result, "condition comparison value is not allowed") {
+		t.Fatalf("expected condition enum value error, got %#v", result.Errors)
+	}
+}
+
 func minimalDefinition() dsl.Definition {
 	return dsl.Definition{
 		SchemaVersion: 1,
@@ -322,6 +335,52 @@ func minimalDefinition() dsl.Definition {
 	}
 }
 
+func policyConditionDefinition(action any) dsl.Definition {
+	conditionConfig, _ := json.Marshal(dsl.ConditionConfig{
+		Branches: []dsl.ConditionBranch{
+			{
+				ID:           "direct",
+				Name:         "Direct",
+				TargetNodeID: "end_1",
+				Condition: &dsl.Condition{
+					Left:     &dsl.VariableSelector{NodeID: "policy_1", Field: "action"},
+					Operator: "eq",
+					Right:    action,
+				},
+			},
+			{
+				ID:           "default",
+				Name:         "Default",
+				TargetNodeID: "end_1",
+				Default:      true,
+			},
+		},
+	})
+	return dsl.Definition{
+		SchemaVersion: 1,
+		EntryNodeID:   "start_1",
+		Nodes: []dsl.Node{
+			{ID: "start_1", Type: "start"},
+			{ID: "understanding_1", Type: "conversation_understanding", Inputs: map[string]dsl.VariableSelector{
+				"userMessage": {NodeID: "start_1", Field: "userMessage"},
+			}},
+			{ID: "policy_1", Type: "reply_policy", Inputs: map[string]dsl.VariableSelector{
+				"messageIntent": {NodeID: "understanding_1", Field: "messageIntent"},
+				"answerScope":   {NodeID: "understanding_1", Field: "answerScope"},
+			}},
+			{ID: "condition_1", Type: "condition", Config: conditionConfig},
+			{ID: "end_1", Type: "end"},
+		},
+		Edges: []dsl.Edge{
+			{ID: "e1", Source: "start_1", Target: "understanding_1"},
+			{ID: "e2", Source: "understanding_1", Target: "policy_1"},
+			{ID: "e3", Source: "policy_1", Target: "condition_1"},
+			{ID: "e4", Source: "condition_1", Target: "end_1"},
+			{ID: "e5", Source: "condition_1", Target: "end_1"},
+		},
+	}
+}
+
 func mappedReplyDefinition() dsl.Definition {
 	def := minimalDefinition()
 	def.Nodes[1].Inputs = map[string]dsl.VariableSelector{