@Override public void executeTask(IConversationMemory memory) throws LifecycleException { IConversationMemory.IWritableConversationStep currentStep = memory.getCurrentStep(); IData<List<String>> latestData = currentStep.getLatestData(ACTION_KEY); if (latestData == null) { return; currentStep.storeData(httpResponseData); currentStep.addConversationOutputMap(KEY_HTTP_CALLS, Map.of(responseObjectName, responseObject));
currentStep.addConversationOutputList(KEY_OUTPUT, Collections.singletonList(output.getResult()));
@Override public ExecutionState execute(IConversationMemory memory, List<BehaviorRule> trace) { List<IData<Context>> contextData = memory.getCurrentStep().getAllData(CONTEXT);
@Override public void executeTask(IConversationMemory memory) throws LifecycleException { IConversationMemory.IWritableConversationStep currentStep = memory.getCurrentStep(); IData<String> expressionsData = currentStep.getLatestData(EXPRESSIONS_PARSED_IDENTIFIER); List<IData<Context>> contextDataList = currentStep.getAllData(CONTEXT_IDENTIFIER); IData<List<String>> actionsData = currentStep.getLatestData(ACTIONS_IDENTIFIER); List<String> actions = actionsData.getResult(); if (actions != null && actions.contains(CATCH_ANY_INPUT_AS_PROPERTY_ACTION)) { IData<String> initialInputData = currentStep.getLatestData(INPUT_INITIAL_IDENTIFIER); String initialInput = initialInputData.getResult(); if (!initialInput.isEmpty()) { currentStep.storeData(dataFactory.createData(PROPERTIES_EXTRACTED_IDENTIFIER, properties, true));
memory.getCurrentStep().storeData(contextData);
initialData.setPublic(true); lifecycleData.add(initialData); currentStep.addConversationOutputString(KEY_INPUT, message); IData<List<String>> actionData = currentStep.getLatestData(KEY_ACTIONS); if (actionData != null) { List<String> result = actionData.getResult();
IData data = memory.getCurrentStep().getLatestData("result_size"); List result; if (data != null) {
@Override public ExecutionState execute(IConversationMemory memory, List<BehaviorRule> trace) { IData<String> data; switch (occurrence) { case currentStep: data = memory.getCurrentStep().getLatestData(KEY_EXPRESSIONS); state = evaluateInputExpressions(data); break; case lastStep: IConversationStepStack previousSteps = memory.getPreviousSteps(); if (previousSteps.size() > 0) { data = previousSteps.get(0).getLatestData(KEY_EXPRESSIONS); state = evaluateInputExpressions(data); } else { state = FAIL; } break; case anyStep: state = occurredInAnyStep(memory, KEY_EXPRESSIONS, this::evaluateInputExpressions) ? SUCCESS : FAIL; break; case never: state = occurredInAnyStep(memory, KEY_EXPRESSIONS, this::evaluateInputExpressions) ? FAIL : SUCCESS; break; } return state; }
@Override public ExecutionState execute(IConversationMemory memory, List<BehaviorRule> trace) { IData<List<String>> data; switch (occurrence) { case currentStep: data = memory.getCurrentStep().getLatestData(KEY_ACTIONS); state = evaluateActions(data); break; case lastStep: IConversationMemory.IConversationStepStack previousSteps = memory.getPreviousSteps(); if (previousSteps.size() > 0) { data = previousSteps.get(0).getLatestData(KEY_ACTIONS); state = evaluateActions(data); } else { state = FAIL; } break; case anyStep: state = occurredInAnyStep(memory, KEY_ACTIONS, this::evaluateActions) ? SUCCESS : FAIL; break; case never: state = occurredInAnyStep(memory, KEY_ACTIONS, this::evaluateActions) ? FAIL : SUCCESS; break; } return state; }
public static IConversationMemory convertConversationMemorySnapshot(ConversationMemorySnapshot snapshot) { ConversationMemory conversationMemory = new ConversationMemory(snapshot.getConversationId(), snapshot.getBotId(), snapshot.getBotVersion(), snapshot.getUserId()); conversationMemory.setConversationState(snapshot.getConversationState()); conversationMemory.getConversationProperties().putAll(snapshot.getConversationProperties()); List<IConversationMemory.IConversationStep> redoSteps = iterateRedoCache(snapshot.getRedoCache()); for (IConversationMemory.IConversationStep redoStep : redoSteps) { conversationMemory.getRedoCache().add(redoStep); } List<ConversationMemorySnapshot.ConversationStepSnapshot> conversationSteps = snapshot.getConversationSteps(); for (int i = 0; i < conversationSteps.size(); i++) { ConversationOutput conversationOutput = snapshot.getConversationOutputs().get(i); ConversationMemorySnapshot.ConversationStepSnapshot conversationStepSnapshot = conversationSteps.get(i); if (i > 0) { conversationMemory.startNextStep(conversationOutput); } for (ConversationMemorySnapshot.PackageRunSnapshot packageRunSnapshot : conversationStepSnapshot.getPackages()) { for (ConversationMemorySnapshot.ResultSnapshot resultSnapshot : packageRunSnapshot.getLifecycleTasks()) { Data data = new Data(resultSnapshot.getKey(), resultSnapshot.getResult(), resultSnapshot.getPossibleResults(), resultSnapshot.getTimestamp(), resultSnapshot.isPublic()); conversationMemory.getCurrentStep().storeData(data); } } } return conversationMemory; }
private void selectAndStoreOutput(IWritableConversationStep currentStep, String action, List<OutputValue> outputValues) { List<QuickReply> quickReplies = new LinkedList<>(); IntStream.range(0, outputValues.size()).forEach(index -> { OutputValue outputValue = outputValues.get(index); List<Object> possibleValueAlternatives = outputValue.getValueAlternatives(); Object randomValue = chooseRandomly(possibleValueAlternatives); if (randomValue instanceof Map) { Map<String, String> randomValueMap = new LinkedHashMap<>((Map) randomValue); randomValueMap.put("type", outputValue.getType()); if (OUTPUT_TYPE_QUICK_REPLY.equals(outputValue.getType())) { quickReplies.add(new QuickReply(randomValueMap.get(KEY_VALUE), randomValueMap.get(KEY_EXPRESSIONS), Boolean.parseBoolean(randomValueMap.getOrDefault(KEY_IS_DEFAULT, "false")))); } randomValue = randomValueMap; } String outputKey = createOutputKey(action, outputValues, outputValue, index); IData<Object> outputData = dataFactory.createData(outputKey, randomValue, possibleValueAlternatives); outputData.setPublic(true); currentStep.storeData(outputData); currentStep.addConversationOutputList(MEMORY_OUTPUT_IDENTIFIER, Collections.singletonList(randomValue)); }); if (!quickReplies.isEmpty()) { storeQuickReplies(currentStep, quickReplies, action); } }
private void templatingQuickReplies(IConversationMemory memory, List<IData<List<QuickReply>>> quickReplyDataList, Map<String, Object> contextMap) { quickReplyDataList.forEach(quickReplyData -> { List<QuickReply> quickReplies = quickReplyData.getResult(); List<QuickReply> preTemplatedQuickReplies = copyQuickReplies(quickReplies); quickReplies.forEach(quickReply -> { try { String preTemplatedValue = quickReply.getValue(); String postTemplatedValue = templatingEngine.processTemplate(preTemplatedValue, contextMap); quickReply.setValue(postTemplatedValue); String preTemplatedExpressions = quickReply.getExpressions(); String postTemplatedExpressions = templatingEngine.processTemplate(preTemplatedExpressions, contextMap); quickReply.setExpressions(postTemplatedExpressions); } catch (ITemplatingEngine.TemplateEngineException e) { log.error(e.getLocalizedMessage(), e); } }); templateData(memory, quickReplyData, quickReplyData.getKey(), preTemplatedQuickReplies, quickReplies); memory.getCurrentStep().addConversationOutputList(KEY_QUICK_REPLIES, quickReplies); }); }
@Override public void executeTask(IConversationMemory memory) { //parse user input to meanings final IData<String> inputData = memory.getCurrentStep().getLatestData(KEY_INPUT); if (inputData == null) { return; } List<IDictionary> temporaryDictionaries = prepareTemporaryDictionaries(memory); List<RawSolution> parsedSolutions; try { String userInput = inputData.getResult(); String normalizedUserInput = sentenceParser.normalize(userInput); storeNormalizedResultInMemory(memory.getCurrentStep(), normalizedUserInput); parsedSolutions = sentenceParser.parse(normalizedUserInput, temporaryDictionaries); } catch (InterruptedException e) { log.warn(e.getLocalizedMessage(), e); return; } storeResultInMemory(memory.getCurrentStep(), parsedSolutions); }
private void storeResultInMemory(IConversationMemory.IWritableConversationStep currentStep, List<RawSolution> parsedSolutions) { if (!parsedSolutions.isEmpty()) { Solution solution = extractExpressions(parsedSolutions, includeUnused, includeUnknown).get(0); String expressions = solution.getExpressions(); if (appendExpressions && !expressions.isEmpty()) { IData<String> latestExpressions = currentStep.getLatestData(KEY_EXPRESSIONS_PARSED); if (latestExpressions != null) { expressions = StringUtilities.joinStrings(", ", latestExpressions.getResult(), expressions); } IData<String> expressionsData = new Data<>(KEY_EXPRESSIONS_PARSED, expressions); currentStep.storeData(expressionsData); currentStep.addConversationOutputString(KEY_EXPRESSIONS, expressions); List<String> intents = expressionProvider.parseExpressions(expressions).stream(). map(Expression::getExpressionName). collect(Collectors.toList()); Data<List<String>> intentData = new Data<>(KEY_INTENT, intents); currentStep.storeData(intentData); currentStep.addConversationOutputList(KEY_INTENT, intents); } } }
private void addActionsToConversationMemory(IConversationMemory memory, List<BehaviorRule> successRules) { List<String> allCurrentActions = new LinkedList<>(); successRules.forEach(successRule -> successRule.getActions().stream(). filter(action -> !allCurrentActions.contains(action)).forEach(allCurrentActions::add)); var currentStep = memory.getCurrentStep(); List<String> actions = new LinkedList<>(); if (appendActions || allCurrentActions.isEmpty()) { IData<List<String>> latestActions = currentStep.getLatestData(KEY_ACTIONS); if (latestActions != null && latestActions.getResult() != null) { actions.addAll(latestActions.getResult()); } } actions.addAll(allCurrentActions.stream(). filter(action -> !actions.contains(action)).collect(Collectors.toList())); Data actionsData = new Data<>(KEY_ACTIONS, actions); actionsData.setPublic(true); currentStep.storeData(actionsData); currentStep.resetConversationOutput(KEY_ACTIONS); currentStep.addConversationOutputList(KEY_ACTIONS, actions); }
@Override public Map<String, Object> convert(IConversationMemory memory) { Map<String, Object> ret = new LinkedHashMap<>(); List<IData<Context>> contextDataList = memory.getCurrentStep().getAllData(KEY_CONTEXT); var contextMap = prepareContext(contextDataList); var memoryMap = convertMemoryItems(memory); var conversationProperties = memory.getConversationProperties(); if (!contextMap.isEmpty()) { ret.put(KEY_CONTEXT, contextMap); ret.putAll(contextMap); } if (!conversationProperties.isEmpty()) { ret.put(KEY_PROPERTIES, conversationProperties.toMap()); } if (!memoryMap.isEmpty()) { ret.put(KEY_MEMORY, convertMemoryItems(memory)); } return ret; }
@Override public void executeTask(IConversationMemory memory) { IWritableConversationStep currentStep = memory.getCurrentStep(); List<IData<Context>> contextDataList = currentStep.getAllData("context"); storeContextQuickReplies(currentStep, contextDataList); IData<List<String>> latestData = currentStep.getLatestData(KEY_ACTIONS); if (latestData == null) { return; } List<String> actions = latestData.getResult(); List<IOutputFilter> outputFilters = createOutputFilters(memory, actions); Map<String, List<OutputEntry>> outputs = outputGeneration.getOutputs(outputFilters); outputs.forEach((action, outputEntries) -> outputEntries.forEach(outputEntry -> { List<OutputValue> outputValues = outputEntry.getOutputs(); selectAndStoreOutput(currentStep, action, outputValues); storeQuickReplies(currentStep, outputEntry.getQuickReplies(), outputEntry.getAction()); })); }
@Override public void executeTask(IConversationMemory memory) { IData<List<String>> actionData = memory.getCurrentStep().getLatestData(KEY_ACTIONS); if (!executeCallback(actionData)) { return; } var request = new ConversationDataRequest(); request.setConversationMemorySnapshot(convertConversationMemory(memory)); var response = conversationCallback.doExternalCall(callback, request, timeoutInMillis); if (String.valueOf(response.getHttpCode()).startsWith("2")) { //check for success, http code 2xx mergeConversationMemory(memory, response.getConversationMemorySnapshot()); } else { String msg = "ConversationCallback was (%s) but should have been 2xx. Return value as been ignored"; msg = String.format(msg, response.getHttpCode()); log.warn(msg); } }
private static List<IConversationMemory.IConversationStep> iterateRedoCache(List<ConversationMemorySnapshot.ConversationStepSnapshot> redoSteps) { List<IConversationMemory.IConversationStep> conversationSteps = new LinkedList<>(); for (ConversationMemorySnapshot.ConversationStepSnapshot redoStep : redoSteps) { IConversationMemory.IWritableConversationStep conversationStep = new ConversationStep(new ConversationOutput()); conversationSteps.add(conversationStep); for (ConversationMemorySnapshot.PackageRunSnapshot packageRunSnapshot : redoStep.getPackages()) { for (ConversationMemorySnapshot.ResultSnapshot resultSnapshot : packageRunSnapshot.getLifecycleTasks()) { Data data = new Data(resultSnapshot.getKey(), resultSnapshot.getResult(), resultSnapshot.getPossibleResults(), resultSnapshot.getTimestamp(), resultSnapshot.isPublic()); conversationStep.storeData(data); } } } return conversationSteps; }
@Override public void executeTask(IConversationMemory memory) { IWritableConversationStep currentStep = memory.getCurrentStep(); List<IData<Object>> outputDataList = currentStep.getAllData(KEY_OUTPUT); List<IData<List<QuickReply>>> quickReplyDataList = currentStep.getAllData(KEY_QUICK_REPLIES); final Map<String, Object> contextMap = memoryItemConverter.convert(memory); if (!outputDataList.isEmpty()) { currentStep.resetConversationOutput(KEY_OUTPUT); } templateOutputTexts(memory, outputDataList, contextMap); if (!quickReplyDataList.isEmpty()) { currentStep.resetConversationOutput(KEY_QUICK_REPLIES); } templatingQuickReplies(memory, quickReplyDataList, contextMap); }