Function validateNode

packages/agentflow/src/core/validation/flowValidation.ts:175–269

(node: FlowNode, availableNodes?: NodeDataSchema[])

 *   nested config schemas via `availableNodes.find(n => n.name === componentName)`.
 */
export function validateNode(node: FlowNode, availableNodes?: NodeDataSchema[]): ValidationError[] {
    const errors: ValidationError[] = []

    // Check required fields
    if (!node.data.name) {
        errors.push({
            nodeId: node.id,
            message: 'Node is missing a name',
            type: 'error'
        })
    }

    const schemaFromAvailable = availableNodes?.find((n) => n.name === node.data.name)
    const inputParams = schemaFromAvailable?.inputs || node.data.inputParams || []
    const inputValues = node.data.inputs || {}

    for (const param of inputParams) {
        // Credential validation (skip general check to avoid duplicate errors)
        if (param.name === 'credential') {
            if (!param.optional && !inputValues[param.name]) {
                errors.push({
                    nodeId: node.id,
                    message: 'Credential is required',
                    type: 'warning'
                })
            }
            continue
        }

        // Check required inputs, skipping hidden params.
        // asyncOptions and asyncMultiOptions values are stored in inputValues just like options;
        // evaluateParamVisibility correctly uses those values to resolve show/hide conditions on
        // dependent fields, so async-driven visibility is handled automatically here.
        if (!param.optional && evaluateParamVisibility(param, inputValues) && isEmptyValue(inputValues[param.name] ?? param.default)) {
            errors.push({
                nodeId: node.id,
                message: `${param.label || param.name} is required`,
                type: 'warning'
            })
        }

        // Array item sub-field validation
        if (param.type === 'array' && Array.isArray(inputValues[param.name]) && param.array) {
            const arrayItems = inputValues[param.name] as Record<string, unknown>[]

            if (arrayItems.length > 0) {
                arrayItems.forEach((item, index) => {
                    for (const arrayParam of param.array!) {
                        // Evaluate visibility with array index for $index-based conditions
                        const shouldValidate = evaluateParamVisibility(arrayParam, item as Record<string, unknown>, index)

                        if (shouldValidate && !arrayParam.optional) {
                            const value = item[arrayParam.name]
                            if (isEmptyValue(value)) {
                                errors.push({
                                    nodeId: node.id,
                                    message: `${param.label} item #${index + 1}: ${arrayParam.label} is required`,
                                    type: 'warning'