Input.Relations[%d] kind %s has invalid param count %d

Error message

Input.Relations[%d] kind %s has invalid param count %d

What it means

compileRelations enforces param-count rules per relation kind: exactly_one/at_least_one/co_occur/conflicts require at least 2 params, and requires requires exactly 2. A relation with too few (or, for requires, not exactly 2) params fails compilation with this error. It exists so runtime relation enforcement never sees under-specified rules.

Source

Thrown at shortcuts/common/typed_compile_contract.go:27

	"fmt"
	"strings"
)

func compileRelations(definitions []typedRelation, fieldByName map[string]int) ([]compiledRelation, error) {
	result := make([]compiledRelation, 0, len(definitions))
	seen := make(map[string]struct{})
	for i, definition := range definitions {
		minimum := 2
		exact := 0
		switch definition.Kind {
		case typedRelationExactlyOne, typedRelationAtLeastOne, typedRelationCoOccur, typedRelationConflicts:
		case typedRelationRequires:
			exact = 2
		default:
			return nil, fmt.Errorf("Input.Relations[%d].Kind %q is invalid", i, definition.Kind)
		}
		if exact > 0 && len(definition.Params) != exact || exact == 0 && len(definition.Params) < minimum {
			return nil, fmt.Errorf("Input.Relations[%d] kind %s has invalid param count %d", i, definition.Kind, len(definition.Params))
		}
		if definition.Presence != typedPresenceExplicit && definition.Presence != typedPresenceNonZero {
			return nil, fmt.Errorf("Input.Relations[%d].Presence %q is invalid", i, definition.Presence)
		}
		if definition.Stage != typedStageSourcePreRun && definition.Stage != typedStageAfterPrepare {
			return nil, fmt.Errorf("Input.Relations[%d].Stage %q is invalid", i, definition.Stage)
		}
		compiled := compiledRelation{kind: definition.Kind, presence: definition.Presence, stage: definition.Stage}
		local := make(map[string]struct{})
		for _, name := range definition.Params {
			field, ok := fieldByName[name]
			if !ok {
				return nil, fmt.Errorf("Input.Relations[%d] references unknown param --%s", i, name)
			}
			if _, duplicate := local[name]; duplicate {
				return nil, fmt.Errorf("Input.Relations[%d] repeats param --%s", i, name)
			}
			local[name] = struct{}{}

View on GitHub (pinned to 7fd6ef3c07)

Solutions

Ensure each relation lists at least 2 distinct params (exactly 2 for requires)
Split or remove degenerate single-param relations; a one-param rule is meaningless, delete it
If params are computed at build time, assert the list length before appending the relation

Example fix

// before
{Kind: typedRelationRequires, Params: []string{"token"}}
// after
{Kind: typedRelationRequires, Params: []string{"token", "user_id"}}

Defensive patterns

Strategy: validation

Validate before calling

func relationParamCountOK(k typedRelationKind, n int) bool {
	if k == typedRelationRequires { return n == 2 }
	return n >= 2
}

Prevention

Remember requires is strictly a 2-param relation
Guard programmatic relation builders against <2 params
Delete degenerate single-param relations instead of encoding them

When it happens

Trigger: Declaring Relations with a single-param relation, e.g. {Kind: typedRelationRequires, Params: []string{"a"}} or a conflicts with one param.

Common situations: Building relation lists programmatically with filtered params that dropped entries; misunderstanding that 'requires' is a pair relation.

Related errors

AI-assisted analysis of larksuite/cli@7fd6ef3c07 (2026-09-04). Data as JSON: /api/errors/7bc77a09a24fa1ae. Report an issue: GitHub.