final Locale locale = getUserLocale();
        final String language = locale.getLanguage();
        if ("en".equals(language)) {
            return StringUtil.EMPTY;
        }
        return "IMPORTANT: You MUST respond in " + locale.getDisplayLanguage(Locale.ENGLISH) + ".";
    }

    /**
     * Resolves the {{languageInstruction}} placeholder in a prompt.
     *
     * @param prompt the prompt template

        return taskNames.contains("promotionBuild") ||
            taskNames.any { it.contains("updateReleasedVersions") }
    }


/**
 * Override the version of Groovy bundled by Gradle. Must be greater than or equal to the major version of Groovy used by Gradle.
 */
val Project.bundleGroovyMajor: Int
    get() = systemProperty(BUNDLE_GROOVY_MAJOR).orNull?.toInt() ?: 4

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<ScheduledJobCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<ScheduledJobCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<AccessTokenCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<AccessTokenCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<SearchLogCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<SearchLogCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {

    }

    private boolean isValidVirtualHostPath(final String path) {
        // Empty path is valid (default host)
        if (StringUtil.isBlank(path)) {
            return true;
        }
        // Path must match one of the configured virtual host paths
        for (final String validPath : ComponentUtil.getVirtualHostHelper().getVirtualHostPaths()) {
            if (path.equals(validPath)) {
                return true;

            }
        }
    }

    /**
     * Builds role-based query filters using the provided role set.
     * This method adds should clauses for allowed roles and must-not clauses for denied roles.
     *
     * @param roleSet the set of roles to use for filtering
     * @param boolQuery the boolean query builder to add role filters to
     */

            logger.debug("Start element: name={}", qName);
        }
        if (tagQueue.isEmpty() && !"eef".equalsIgnoreCase(qName)) {
            throw new GsaConfigException("Invalid GSA configuration format. Root element must be 'eef', but found: " + qName);
        }
        if (COLLECTION.equalsIgnoreCase(qName) && COLLECTIONS.equalsIgnoreCase(tagQueue.peekLast())) {
            final long now = ComponentUtil.getSystemHelper().getCurrentTimeAsLong();

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<WebConfigCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<WebConfigCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {

            if (configIdValue == null) {
                continue;
            }

            final QueryBuilder queryBuilder = QueryBuilders.boolQuery()
                    .must(QueryBuilders.termQuery(fessConfig.getIndexFieldUrl(), inputDoc.get(fessConfig.getIndexFieldUrl())))
                    .filter(QueryBuilders.termQuery(fessConfig.getIndexFieldConfigId(), configIdValue));