Beyond a Single AI Assistant: Creating a Team Chat App Using Spring Boot and LangChain4j

    @Description("""
            When reflecting on a question or statement, you must determine the different aspects of
            the relevance of your answer.
            """)
    record RelevanceMetadata(
            @Description("Rate how relevant this message is to your professional expertise on a scale from 1 (not related) to 10 (highly relevant)")
            int relevanceToProfession,
            @Description("On a scale from 1 to 10, rate how much this message aligns with your personal interests and topics you enjoy discussing.")
            int relevanceToInterests,
            @Description("Classify this message from 1 (purely factual) to 10 (highly opinion-based or subjective).")
            int questionType,
            @Description("On a scale from 1 to 10, rate your confidence in providing an accurate or meaningful response to this message.")
            int confidenceInResponse,
            @Description("Rate how much relevant context is available to understand this message, from 1 (no context) to 10 (fully clear).")
            int contextAvailability,
            @Description("On a scale from 1 (not urgent) to 10 (highly time-sensitive), rate how urgent this message appears to be.")
            int urgencyLevel,
            @Description("On a scale from 1 (completely new topic) to 10 (strongly tied to previous chat messages), rate how related this message is to past interactions.")
            int relationToPreviousChat,
            @Description("On a scale from 1 to 10, rate how much this message fits your defined personality, tone, or conversational style.")
            int alignmentWithPersonality
    ) {
    }

    @Description("The category of the message you received.")
    enum MessageCategory {
        @Description("The message is purely social, small talk, or general pleasantries (e.g., greetings, well-being questions like 'How are you?'). It does not relate to your expertise or interests in any meaningful way.")
        GENERAL_INQUIRY,

        @Description("The message is part of a casual conversation that lightly touches on your interests but does not require an in-depth response. It is more of a social exchange rather than an analytical discussion.")
        INTEREST_CASUAL,

        @Description("The message is about a topic related to your interests and invites a meaningful discussion but does not necessarily require expertise.")
        INTEREST_DISCUSSION,

        @Description("The message is directly related to your expertise, profession, or strong personal interests and requires a knowledgeable or analytical response.")
        EXPERTISE_RELATED,

        @Description("The message asks for your personal opinion, belief, or subjective perspective on a topic, regardless of your expertise.")
        OPINION_REQUEST
    }

public interface Assistant {

    @UserMessage("""
               MESSAGE_NOTIFICATION
               {
               message:'{{message}}',
               messageSender:'{{userName}}',
               conversationThreadLifecycle:'{{conversationThreadState}}',
               directlyAddressedParticipant:'{{directlyAddressedParticipant}}'
               }
            """)
    ResponseMessageWithRelevance send(@V("message") String message,
                                      @V("conversationThreadState") ConversationThreadState conversationThreadState,
                                      @V("directlyAddressedParticipant") String directlyAddressedParticipant,
                                      @V("userName") String userName
    );


    record ResponseMessageWithRelevance(@Description("Your name") String name,
                                        @Description("Your answer to the received message") String answer,
                                        @Description("The name of the conversion participant, who sent you the message.") String responseTo,
                                        @Description("Is your response message intended to close the conversation thread?") boolean closingConversationThread,
                                        @Description("The value of the directlyAddressedParticipant field in the message notification") String directlyAddressedParticipant,
                                        MessageCategory messageCategory,
                                        @Description("Describe here why did you choose that messageCategory.") String messageCategoryDescription,
                                        RelevanceMetadata relevance
    ) {
    }
}

  user:
    description:
      name: "Tom"
  assistant:
    first:
      model-name: "gpt-4o-mini"
      description:
        name: "Bill"
        persona: "
        Age: 72. 
        Occupation: Retired Cinematographer (50 years in the industry). 
        Personality: Cynical, nostalgic, grumpy, but deeply knowledgeable about classic cinema. 
        Interests: -Golden Age Hollywood films (1940s–1970s), 
                   -film lighting techniques and practical effects, 
                   -black-and-white cinematography, 
                   -classic directors (Hitchcock, Kubrick, Fellini, Tarkovsky), 
                   -complaining about modern CGI and 'soulless' blockbusters, 
                   -drinking whiskey while watching old film reels, 
        Dislikes: -Superhero movies ('They all look the same!'), 
                  -overuse of CGI ('Back in my day, we built real sets!'), 
                  -streaming services ('Films should be seen on the big screen!'), 
                  -'TikTok filmmakers' and YouTube critics"
      system-message: "
        Your name is ${multi-assistant.assistant.first.description.name}.
        Your persona: ${multi-assistant.assistant.first.description.persona}
        
        ${multi-assistant.communication-config.base-system-message}
      "
    second:
      model-name: "gpt-4o-mini"
      description:
        name: "Joe"
        persona: "
        Age: 24. 
        Occupation: Aspiring Thrash Metal Guitarist. 
        Personality: Energetic, sarcastic, rebellious, always looking for a joke in every situation. 
        Interests: -Thrash metal (Slayer, Metallica, Megadeth, Anthrax), 
                   -shredding guitar solos, 
                   -mosh pits, 
                   -collecting vintage band T-shirts, 
                   -making fun of everything (especially serious people), 
                   -turning normal conversations into jokes, 
                   -fast food, 
                   -late-night gaming sessions, 
                   -loud concerts, 
                   -headbanging until his neck hurts. 
        Dislikes: -Classical music snobs, 
                  -pop music, 
                  -people who take themselves too seriously, 
                  -mornings, 
                  -silence, 
                  -slow ballads, 
                  -and anyone who says 'metal is just noise."
      system-message: "
        Your name is ${multi-assistant.assistant.second.description.name}.
        Your persona: ${multi-assistant.assistant.second.description.persona}
        
        ${multi-assistant.communication-config.base-system-message}
      "

    base-system-message: "
      There are three of you in a team chat. All the participants has a name.
      The participants of the conversation are:
        -name: ${multi-assistant.user.description.name}, 
        -name: ${multi-assistant.assistant.first.description.name}, 
        -name: ${multi-assistant.assistant.second.description.name}
        
       If a new message appears in the chat, then you will be notified about that. 
       This notification will contain 
         -the message itself(message field), 
         -the name of the message sender(messageSender field),
         -and the state of the current conversation thread(conversationThreadLifecycle field)
         -and the name of the chat participant who was directly addressed with the message in the directlyAddressedParticipant field(if there is no one directly addressed, the field is empty).
         
       The length of a conversation thread is limited. Until you reach this limit, 
       the conversationThreadLifecycle is set to ACTIVE and you can continue the conversation. 
       Once you near to reach the limit, the status changes from ACTIVE to FINALIZE. 
       The FINALIZE status tells you when you should try to close the conversation on the topic.
       
       An example for a  message notification where you can continue the conversation:
        '
          MESSAGE_NOTIFICATION
          message:'How are you today?'
          messageSender:'Tom'
          conversationThreadLifecycle:'ACTIVE'
          directlyAddressedParticipant:''
        '
        
        An example for a  message notification where you should try to close the conversation:
        '
          MESSAGE_NOTIFICATION
          message:'How are you today?'
          messageSender:'Tom'
          conversationThreadLifecycle:'FINALIZE'
          directlyAddressedParticipant:'Tom'
        '
        
        If you want to reply to the message, you can, but you should always determine 
        the relevance of your reply to the original message you are replying to.
        The relevance value you set determines whether your answer will appear in the team chat.
      "

 /**
 * This interface represents a consumer of messages in a chat system.
 * Implementations of this interface are responsible for handling and processing messages
 * received from a message publisher. The consumer operates in a separate thread of execution.
 * Implementing classes should define the logic for consuming messages and specify the
 * participant name to identify the chat participant associated with this consumer.
 */
public interface MessageConsumer extends Consumer<Message>, Runnable {

    /**
     * The name of the chat participant, who consumes the messages with the particular MessageConsumer instance.
     *
     * @return participant name
     */
    String participantName();
}

public class DefaultMessageConsumer implements MessageConsumer {
    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultMessageConsumer.class);
    private final LinkedBlockingDeque<Message> messageQueue = new LinkedBlockingDeque<>();
    private final String participantName;
    private final ConsumedMessageProcessor consumedMessageProcessor;

    public DefaultMessageConsumer(String participantName, ConsumedMessageProcessor consumedMessageProcessor) {
        this.participantName = participantName;
        this.consumedMessageProcessor = consumedMessageProcessor;
    }

    @Override
    public String participantName() {
        return participantName;
    }

    @Override
    public void accept(Message message) {
        if (!participantName().equals(message.getName())) {
            try {
                if (message instanceof PoisonPillMessage) {
                    messageQueue.putFirst(message);
                } else {
                    messageQueue.put(message);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                LOGGER.warn("Message accepting thread {} was interrupted!", Thread.currentThread().getName());
            }
        }
    }

    @Override
    public void run() {
        try {
            while (true) {
                var message = messageQueue.take();
                if (message instanceof PoisonPillMessage) {
                    LOGGER.info("Poison pill message received at thread {}", Thread.currentThread().getName());
                    break;
                }
                consumedMessageProcessor.process(message);
            }
            LOGGER.info("Thread {} has finished message processing.", Thread.currentThread().getName());
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOGGER.warn("Message processing thread {} was interrupted!", Thread.currentThread().getName());
        }
    }
}

public class MessageStreamConsumedMessageProcessor implements ConsumedMessageProcessor {
    private static final Logger LOGGER = LoggerFactory.getLogger(MessageStreamConsumedMessageProcessor.class);
    private final MessageStreamService messageStreamService;

    public MessageStreamConsumedMessageProcessor(MessageStreamService messageStreamService) {
        this.messageStreamService = messageStreamService;
    }

    @Override
    public void process(Message message) {
        try {
            messageStreamService.getStream()
                    .orElseThrow(()->new RuntimeException("Stream not initialized!"))
                    .send(MessageHtmlUtil.messageToAiHtmlChatItem(message));
        } catch (Exception e) {
            LOGGER.error("Failed to send message to stream", e);
        }
    }
}

public class AssistantConsumedMessageProcessor implements ConsumedMessageProcessor {
    private static final Logger LOGGER = LoggerFactory.getLogger(AssistantConsumedMessageProcessor.class);
    private String assistantName;
    private Assistant assistant;
    private MessagePublisher messagePublisher;
    private RelevanceCalculator relevanceCalculator;
    private ConversationThreadHandler conversationThreadHandler;
    private ModeratorAssistant moderatorAssistant;

    public void setAssistantName(String assistantName) {
        this.assistantName = assistantName;
    }

    public void setAssistant(Assistant assistant) {
        this.assistant = assistant;
    }

    public void setMessagePublisher(MessagePublisher messagePublisher) {
        this.messagePublisher = messagePublisher;
    }

    public void setRelevanceCalculator(RelevanceCalculator relevanceCalculator) {
        this.relevanceCalculator = relevanceCalculator;
    }

    public void setConversationThreadHandler(ConversationThreadHandler conversationThreadHandler) {
        this.conversationThreadHandler = conversationThreadHandler;
    }

    public void setModeratorAssistant(ModeratorAssistant moderatorAssistant) {
        this.moderatorAssistant = moderatorAssistant;
    }

    @Override
    public void process(Message message) {
        try {
            if (conversationThreadHandler.isConversationThreadActive(message.getConversationThreadId()) &&
                    conversationThreadHandler.isConversationThreadOpenForAssistant(message.getConversationThreadId(), assistantName)) {

                var conversationThreadLimitReached = conversationThreadHandler.isConversationThreadLimitReached(message.getConversationThreadId(), assistantName);
                var directlyAddressedParticipant = determineDirectlyAddressedParticipant(message);
                var result = assistant.send(
                        message.getMessage(),
                        conversationThreadLimitReached ? Assistant.ConversationThreadState.FINALIZE : Assistant.ConversationThreadState.ACTIVE,
                        directlyAddressedParticipant,
                        message.getName());

                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug("Response message was {} to request message {} ", result, message);
                }

                if (conversationThreadLimitReached) {
                    conversationThreadHandler.closeConversationThreadForAssistant(message.getConversationThreadId(), assistantName);
                }

                if (relevanceCalculator.isResponseRelevant(result)) {
                    messagePublisher.publish(new Message()
                            .setConversationThreadId(message.getConversationThreadId())
                            .setName(result.name())
                            .setMessage(result.answer())
                    );
                }

            }

        } catch (Exception e) {
            LOGGER.error("Message processing failed:", e);
        }
    }

    private String determineDirectlyAddressedParticipant(Message message) {
        var directlyAddressedParticipant = moderatorAssistant.analyze(message.getMessage(), message.getName()).directlyAddressedTo();
        return directlyAddressedParticipant == null ? "" : directlyAddressedParticipant;
    }
}

@Component
public class DefaultMessagePublisher implements MessagePublisher {
    private List<MessageConsumer> messageConsumers;
    private ConversationThreadHandler conversationThreadHandler;

    @Autowired
    public void setMessageConsumers(List<MessageConsumer> messageConsumers) {
        this.messageConsumers = messageConsumers;
    }

    @Autowired
    public void setConversationThreadHandler(ConversationThreadHandler conversationThreadHandler) {
        this.conversationThreadHandler = conversationThreadHandler;
    }

    @Override
    public void publish(Message message) {
        conversationThreadHandler.incrementConversationThreadCounter(message);
        messageConsumers.forEach(messageConsumer -> messageConsumer.accept(message));
    }
}

    @Bean
    MessageConsumer userMessageConsumer(@Qualifier("messageConsumptionTaskExecutor") TaskExecutor taskExecutor,
                                        UserConfigurationProperties userConfig,
                                        @Qualifier("userConsumedMessageProcessor") ConsumedMessageProcessor consumedMessageProcessor) {
        var messageConsumer = new DefaultMessageConsumer(userConfig.description().name(), consumedMessageProcessor);
        taskExecutor.execute(messageConsumer);
        return messageConsumer;
    }
	
    @Bean
    MessageConsumer firstAssistantMessageConsumer(@Qualifier("messageConsumptionTaskExecutor") ThreadPoolTaskExecutor taskExecutor,
                                                  FirstAssistantConfigurationProperties assistantConfig,
                                                  @Qualifier("firstAssistantMessageProcessor") ConsumedMessageProcessor consumedMessageProcessor) {
        var messageConsumer = new DefaultMessageConsumer(assistantConfig.description().name(), consumedMessageProcessor);
        taskExecutor.execute(messageConsumer);
        return messageConsumer;
    }
	
    @Bean
    MessageConsumer secondAssistantMessageConsumer(@Qualifier("messageConsumptionTaskExecutor") ThreadPoolTaskExecutor taskExecutor,
                                                   SecondAssistantConfigurationProperties assistantConfig,
                                                   @Qualifier("secondAssistantMessageProcessor") ConsumedMessageProcessor consumedMessageProcessor) {
        var messageConsumer = new DefaultMessageConsumer(assistantConfig.description().name(), consumedMessageProcessor);
        taskExecutor.execute(messageConsumer);
        return messageConsumer;
    }
	
    @Bean("messageConsumptionTaskExecutor")
    ThreadPoolTaskExecutor messageConsumptionTaskExecutor() {

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(3);
        executor.setMaxPoolSize(3);
        executor.setThreadNamePrefix("message_consumer_");
        executor.setVirtualThreads(true);
        executor.initialize();

        return executor;
    }

    @Bean("firstAssistantChatMemory")
    ChatMemory firstAssistantChatMemory(FirstAssistantConfigurationProperties firstAssistantConfiguration,
                                        ObjectMapper objectMapper,
                                        RelevanceCalculator relevanceCalculator) {
        return new RelevanceFilterChatMemoryProxy(TokenWindowChatMemory.builder()
                .chatMemoryStore(new InMemoryChatMemoryStore())
                .maxTokens(3000, new OpenAiTokenizer(firstAssistantConfiguration.modelName()))
                .build(),
                relevanceCalculator,
                objectMapper
        );
    }

    @Bean("firstAssistantChatLanguageModel")
    ChatLanguageModel firstAssistantChatLanguageModel(AiConfigurationProperties aiConfigurationProperties,
                                                      FirstAssistantConfigurationProperties firstAssistantConfiguration) {
        return OpenAiChatModel.builder()
                .apiKey(aiConfigurationProperties.apiKey())
                .modelName(firstAssistantConfiguration.modelName())
                .temperature(0.5)
                .logRequests(true)
                .logResponses(true)
                .build();
    }

    @Bean("firstAssistant")
    Assistant firstAssistant(@Qualifier("firstAssistantChatLanguageModel") ChatLanguageModel chatLanguageModel,
                             @Qualifier("firstAssistantChatMemory") ChatMemory chatMemory,
                             FirstAssistantConfigurationProperties firstAssistantConfiguration) {
        return AiServices
                .builder(Assistant.class)
                .chatLanguageModel(chatLanguageModel)
                .systemMessageProvider(memoryId -> firstAssistantConfiguration.systemMessage())
                .chatMemory(chatMemory)

                .build();
    }

    @Bean("secondAssistantChatMemory")
    ChatMemory secondAssistantChatMemory(SecondAssistantConfigurationProperties secondAssistantConfiguration,
                                         ObjectMapper objectMapper,
                                         RelevanceCalculator relevanceCalculator) {
        return new RelevanceFilterChatMemoryProxy(TokenWindowChatMemory.builder()
                .chatMemoryStore(new InMemoryChatMemoryStore())
                .maxTokens(3000, new OpenAiTokenizer(secondAssistantConfiguration.modelName()))
                .build(),
                relevanceCalculator,
                objectMapper
        );
    }

    @Bean("secondAssistantChatLanguageModel")
    ChatLanguageModel secondAssistantChatLanguageModel(AiConfigurationProperties aiConfigurationProperties,
                                                       SecondAssistantConfigurationProperties secondAssistantConfiguration) {
        return OpenAiChatModel.builder()
                .apiKey(aiConfigurationProperties.apiKey())
                .modelName(secondAssistantConfiguration.modelName())
                .temperature(0.5)
                .logRequests(true)
                .logResponses(true)
                .build();
    }

    @Bean("secondAssistant")
    Assistant secondAssistant(@Qualifier("secondAssistantChatLanguageModel") ChatLanguageModel chatLanguageModel,
                              @Qualifier("secondAssistantChatMemory") ChatMemory chatMemory,
                              SecondAssistantConfigurationProperties secondAssistantConfiguration) {
        return AiServices
                .builder(Assistant.class)
                .chatLanguageModel(chatLanguageModel)
                .systemMessageProvider(memoryId -> secondAssistantConfiguration.systemMessage())
                .chatMemory(chatMemory)
                .build();
    }

public class RelevanceFilterChatMemoryProxy implements ChatMemory {
    private static final Logger LOGGER = LoggerFactory.getLogger(RelevanceFilterChatMemoryProxy.class);
    private static final Pattern JSON_BLOCK_PATTERN = Pattern.compile("(?s)\\{.*\\}|\\[.*\\]");
    private final ChatMemory wrappedChatMemory;
    private final RelevanceCalculator relevanceCalculator;
    private final ObjectMapper objectMapper;

    public RelevanceFilterChatMemoryProxy(ChatMemory wrappedChatMemory, RelevanceCalculator relevanceCalculator, ObjectMapper objectMapper) {
        this.wrappedChatMemory = wrappedChatMemory;
        this.relevanceCalculator = relevanceCalculator;
        this.objectMapper = objectMapper;
    }

    @Override
    public Object id() {
        return wrappedChatMemory.id();
    }

    @Override
    public void add(ChatMessage message) {
        if (isMessageRelevant(message)) {
            wrappedChatMemory.add(message);
        }
    }

    @Override
    public List<ChatMessage> messages() {
        return wrappedChatMemory.messages();
    }

    @Override
    public void clear() {
        wrappedChatMemory.clear();
    }

    /**
     * If the given message is an AiMessage and the contained text is a ResponseMessageWithRelevance,
     * then it compares the received relevance value with the configured relevance threshold.
     * If the relevance falls below the threshold, the message is not relevant. Otherwise, it is relevant.
     *
     * @param chatMessage the received message
     * @return true if the message is relevant. Otherwise, returns false
     */
    private boolean isMessageRelevant(ChatMessage chatMessage) {
        if (chatMessage instanceof AiMessage aiMessage) {
            var aiMessageText = extractJsonBlock(aiMessage.text());
            try {
                var messageWithRelevance = objectMapper.readValue(aiMessageText, Assistant.ResponseMessageWithRelevance.class);
                if (!relevanceCalculator.isResponseRelevant(messageWithRelevance)) {
                    return false;
                }
            } catch (JsonProcessingException e) {
                LOGGER.warn("AiMessage was not a valid ResponseMessageWithRelevance:{}", aiMessageText);
            }
        }

        return true;
    }

    /**
     * Extracts the JSON block from the given text.
     *
     * @param text the text
     * @return the JSON block from the text
     */
    private String extractJsonBlock(String text) {
        Matcher matcher = JSON_BLOCK_PATTERN.matcher(text);
        if (matcher.find()) {
            return matcher.group();
        }
        return text;
    }
}

@Component
public class RelevanceCalculator {
    private static final Logger LOGGER = LoggerFactory.getLogger(RelevanceCalculator.class);
    private final CommunicationConfigurationProperties.AnswerRelevanceThresholdConfig answerRelevanceThresholdConfig;
    private final WeakHashMap<Assistant.ResponseMessageWithRelevance, Boolean> relevanceCache = new WeakHashMap<>();

    public RelevanceCalculator(CommunicationConfigurationProperties communicationConfiguration) {
        this.answerRelevanceThresholdConfig = communicationConfiguration.answerRelevanceThreshold();
    }

    /**
     * Checks if the given response message is relevant enough to be sent to the other participants of the conversation,
     * based on its relevance metadata.
     *
     * @param responseMessageWithRelevance The response message
     * @return true if the response message is relevant, false otherwise
     */
    public boolean isResponseRelevant(Assistant.ResponseMessageWithRelevance responseMessageWithRelevance) {

        var cachedRelevance = relevanceCache.get(responseMessageWithRelevance);
        if (cachedRelevance != null) {
            return cachedRelevance;
        }

        if (responseMessageWithRelevance.closingConversationThread()) {
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("The message is a conversation thread closing message, so it is relevant: {}", responseMessageWithRelevance);
            }
            relevanceCache.put(responseMessageWithRelevance, true);
            return true;
        }

        if (StringUtils.hasLength(responseMessageWithRelevance.directlyAddressedParticipant()) && !responseMessageWithRelevance.name().equals(responseMessageWithRelevance.directlyAddressedParticipant())) {
            if (LOGGER.isDebugEnabled()) {
                LOGGER.debug("The message was directly addressed to another participant, so it is not relevant: {}", responseMessageWithRelevance);
            }
            relevanceCache.put(responseMessageWithRelevance, false);
            return false;
        }

        var relevanceMetadata = responseMessageWithRelevance.relevance();
        var relevancePercentage = new PercentageCalculator()
                .addFieldValue(relevanceMetadata.relevanceToProfession())
                .addFieldValue(relevanceMetadata.relevanceToInterests())
                .addFieldValue(relevanceMetadata.questionType())
                .addFieldValue(relevanceMetadata.confidenceInResponse())
                .addFieldValue(relevanceMetadata.contextAvailability())
                .addFieldValue(relevanceMetadata.urgencyLevel())
                .addFieldValue(relevanceMetadata.relationToPreviousChat())
                .addFieldValue(relevanceMetadata.alignmentWithPersonality())
                .calculate();

        var relevant = isRelevant(responseMessageWithRelevance.messageCategory(), relevancePercentage);
        relevanceCache.put(responseMessageWithRelevance, relevant);
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("The relevance value was {} for the following response, so its relevance is {}: {}", relevancePercentage, relevant, responseMessageWithRelevance);
        }

        return relevant;
    }

    /**
     * Checks if the given message category is relevant based on the given relevance percentage.
     *
     * @param messageCategory     The message category to check
     * @param relevancePercentage The relevance percentage
     * @return true if the message category is relevant based on the given relevance percentage, false otherwise
     */
    private boolean isRelevant(Assistant.MessageCategory messageCategory, int relevancePercentage) {
        var answerRelevanceThreshold = answerRelevanceThresholdConfig.thresholds().get(messageCategory);
        if (answerRelevanceThreshold == null) {
            return false;
        }
        return relevancePercentage >= answerRelevanceThreshold;
    }

    /**
     * Calculates the relevance percentage based on the given field values.
     */
    private static class PercentageCalculator {
        private static final int MAX_VALUE_PER_FIELD = 10;
        private int maxValue = 0;
        private int sum = 0;

        PercentageCalculator addFieldValue(int value) {
            maxValue += MAX_VALUE_PER_FIELD;
            sum += Math.min(value, MAX_VALUE_PER_FIELD);
            return this;
        }

        int calculate() {
            if (maxValue == 0) {
                return 0;

            }
            return (int) Math.round((sum * 100.0) / maxValue);
        }
    }
}

  communication-config:
    answer-relevance-threshold:
      thresholds:
        -GENERAL_INQUIRY: 39
        -INTEREST_CASUAL: 52
        -EXPERTISE_RELATED: 61
        -OPINION_REQUEST: 66
        -INTEREST_DISCUSSION: 64
    conversation-thread-limit: 3

MESSAGE_NOTIFICATION
{
  message:'{{message}}',
  messageSender:'{{userName}}',
  conversationThreadLifecycle:'{{conversationThreadState}}',
  directlyAddressedParticipant:'{{directlyAddressedParticipant}}'
}

enum ConversationThreadState {
    ACTIVE, FINALIZE
}

@Description("Is your response message intended to close the conversation thread?") boolean closingConversationThread

The length of a conversation thread is limited. Until you reach this limit, 
the conversationThreadLifecycle is set to ACTIVE and you can continue the conversation. 
Once you near to reach the limit, the status changes from ACTIVE to FINALIZE. 
The FINALIZE status tells you when you should try to close the conversation on the topic.