We Keep Coding

Luis choosing between two intent

If the luis highest intent score for a conversation is 0.15, and the second is 0.14, would it be possible for the bot to ask the user if they meant the first intent or the second intent? If yes how to do so? I've been searching in the documentation samples and there doesn't seem to be any solution except just making more and more utterances so this does not happen; is that correct?

If the luis highest intent score for a conversation is 0.15, and the second is 0.14, would it be possible for the bot to ask the user if they meant the first intent or the second intent? If yes how to do so?
Yes, we can achieve this requirement. The following sample code work for me, you can refer to it.
[Serializable]
public class MyLuisDialog : LuisDialog<object>
{
public MyLuisDialog() : base(new LuisService(new LuisModelAttribute("xxxxxxx",
"xxxxxxx",
domain: "westus.api.cognitive.microsoft.com")))
{
}
//modify Luis request to make it return all intents instead of just the topscoring intent
protected override LuisRequest ModifyLuisRequest(LuisRequest request)
{
request.Verbose = true;
return request;
}
protected override async Task DispatchToIntentHandler(IDialogContext context, IAwaitable<IMessageActivity> item, IntentRecommendation bestIntent, LuisResult result)
{
if (bestIntent.Intent == "FindFood" || bestIntent.Intent == "BuyFood")
{
if (result.Intents[0].Score - result.Intents[1].Score < 0.1)
{
bestIntent.Intent = "FindOrBuyFood";
bestIntent.Score = 1;
}
}
await base.DispatchToIntentHandler(context, item, bestIntent, result);
}
[LuisIntent("Greeting")]
public async Task GreetingIntent(IDialogContext context, LuisResult result)
{
await this.ShowLuisResult(context, result);
}
//...
//other intent handlers
//...
[LuisIntent("FindFood")]
[LuisIntent("BuyFood")]
public async Task FoodIntent(IDialogContext context, LuisResult result)
{
await this.ShowLuisResult(context, result);
}
[LuisIntent("FindOrBuyFood")]
public async Task FindOrBuyFoodIntent(IDialogContext context, LuisResult result)
{
var food = "food";
if (result.Entities.Count() > 0)
{
food = result.Entities[0].Entity;
}
List<string> options = new List<string>() { $"Find {food}", $"Buy {food}" };
PromptDialog.Choice(
context: context,
resume: ChoiceReceivedAsync,
options: options,
prompt: "Hi. Please Select one option :",
retry: "Please try again.",
promptStyle: PromptStyle.Auto
);
}
private async Task ChoiceReceivedAsync(IDialogContext context, IAwaitable<object> result)
{
var option = await result;
//your code logic here
await context.PostAsync($"You selected the '{option}'");
context.Wait(MessageReceived);
}
private async Task ShowLuisResult(IDialogContext context, LuisResult result)
{
await context.PostAsync($"You have reached {result.Intents[0].Intent} intent.");
context.Wait(MessageReceived);
}
}
Test Result:

Bot Framework's context.Wait() not waiting for user input

I am starting to develop a simple Bot, evolving from the Echo bot in the documentation. And I've hit an issue quickly.
I have these three methods on my RootDialog:
public async Task StartAsync(IDialogContext context)
{
await context.PostAsync("Olá! Eu sou um bot!");
await context.PostAsync("Qual é o teu nome?");
context.Wait(NameReceivedAsync);
}
private async Task NameReceivedAsync(IDialogContext context, IAwaitable<object> result)
{
var activity = await result as Activity;
userName = activity.Text;
await context.PostAsync($"Olá {userName}. Podes dizer alguma coisa e eu vou repetir.");
context.Wait(MessageReceivedAsync);
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable<object> result)
{
var activity = await result as Activity;
// calculate something for us to return
int length = (activity.Text ?? string.Empty).Length;
// return our reply to the user
await context.PostAsync($"Tu disseste { activity.Text}, que tem {length} caracteres");
context.Wait(MessageReceivedAsync);
}
And my MessageController Post method is like this:
public async Task<HttpResponseMessage> Post([FromBody]Activity activity)
{
await Conversation.SendAsync(activity, () => new Dialogs.RootDialog());
return new HttpResponseMessage(System.Net.HttpStatusCode.Accepted);
}
The idea is for the bot to send two messages right away, wait for input with userName from the user, send another message, and then go to MessageReceivedAsync where he'll start his echo loop. The problem is the bot is not waiting for the inputs, only stopping at the end of the MessageReceivedAsync, where he'll start the echo.
I can't seem to understand why this happens, since from what I've seen the context.Wait(...) should make the Bot wait for input, which is not happening. I'm testing it with the Bot Framework Channel Emulator on Chrome, if that makes any difference.

context.Wait(method) is a little confusing because it actually sets up a “continuation delegate to specify the method that should be called when a new message is received” from: https://learn.microsoft.com/en-us/bot-framework/dotnet/bot-builder-dotnet-dialogs#implementation-details However, the context.Wait(method) in .StartAsync will execute the "method" immediately, since the dialog is being run for the first time.
If you change your code to something like the following, it should work as you expect:
[Serializable]
public class RootDialogTest : IDialog<object>
{
public async Task StartAsync(IDialogContext context)
{
context.Wait(NameReceivedAsync);
}
private async Task NameReceivedAsync(IDialogContext context, IAwaitable<object> result)
{
var activity = await result as Activity;
if (!context.UserData.ContainsKey("askedname"))
{
await context.PostAsync("Olá! Eu sou um bot!");
await context.PostAsync("Qual é o teu nome?");
context.UserData.SetValue("askedname", true);
context.Wait(NameReceivedAsync);
}
else
{
var userName = activity.Text;
await context.PostAsync($"Olá {userName}. Podes dizer alguma coisa e eu vou repetir.");
context.Wait(MessageReceivedAsync);
}
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable<object> result)
{
var activity = await result as Activity;
// calculate something for us to return
int length = (activity.Text ?? string.Empty).Length;
// return our reply to the user
await context.PostAsync($"Tu disseste { activity.Text}, que tem {length} caracteres");
context.Wait(MessageReceivedAsync);
}
}
Edit: another option, that involves fewer changes to your current dialog:
[Serializable]
public class RootDialogTest : IDialog<object>
{
public async Task StartAsync(IDialogContext context)
{
await context.PostAsync("Olá! Eu sou um bot!");
await context.PostAsync("Qual é o teu nome?");
context.Wait(SetupMethodWait);
}
private async Task SetupMethodWait(IDialogContext context, IAwaitable<object> result)
{
context.Wait(NameReceivedAsync);
}
private async Task NameReceivedAsync(IDialogContext context, IAwaitable<object> result)
{
var activity = await result as Activity;
var userName = activity.Text;
await context.PostAsync($"Olá {userName}. Podes dizer alguma coisa e eu vou repetir.");
context.Wait(MessageReceivedAsync);
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable<object> result)
{
var activity = await result as Activity;
// calculate something for us to return
int length = (activity.Text ?? string.Empty).Length;
// return our reply to the user
await context.PostAsync($"Tu disseste { activity.Text}, que tem {length} caracteres");
context.Wait(MessageReceivedAsync);
}
}

From what I can tell from developing with the Bot Framework, the Conversation.SendAsync() works like a context.Forward() forwarding the message onto the RootDialog().
I suggest directing the user to a separate dialog using such as AskNameDialog() using context.Call() and process your code there.
Have a look at the samples the BotBuilder provides
https://github.com/Microsoft/BotBuilder-Samples they should help you in understanding.

Stack is empty error when calling context.Done in child dialog

I have a LuisDialog which makes a forward to another LuisDialog in the "None" intent as some kind of fallback:
[LuisIntent("None")]
public async Task None(IDialogContext context, IAwaitable<IMessageActivity> message, LuisResult result)
{
var luisService = new LuisService(new LuisModelAttribute("XXX", "XXX"));
await context.Forward(new MyChildDialog(luisService), null, await message);
context.Wait(MessageReceived);
}
The method executed in MyChildDialog is like this:
[LuisIntent("myLuisIntent")]
public async Task MyLuisIntent(IDialogContext context, LuisResult result)
{
await context.PostAsync("Hi!");
context.Done(0);
}
When the context.Done() is executed, emulator shows an error: "Stack is empty". But, how can it be empty if forward adds the dialog to the stack?

Make sure you have a handler for what to do when the MyChildDialog is fininshed
[LuisIntent("None")]
public async Task None(IDialogContext context, IAwaitable<IMessageActivity> message, LuisResult result)
{
var luisService = new LuisService(new LuisModelAttribute("XXX", "XXX"));
await context.Forward(new MyChildDialog(luisService), WaitForMessageResume, await message);
context.Wait(MessageReceived);
}
private Task WaitForMessageResume(IDialogContext context, IAwaitable<object> result)
{
context.Wait(MessageReceived);
return Task.CompletedTask;
}

How to switch between two luis.ai dialog with different languages

i have created a bot in bot framework using also luis.ai.
In my luis account i have created two app with different language culture. One app in english and other in french. Both have their intents.
In my code i call one time english dialog, and other time french luis dialog .
My problem is that when i start conversation in english facebook channel ( messenger ) i get the right answer. Inside this bot and channel when i type in french , my bot don't call french dialog .
When i start conversation in french version of facebook ...the bot can't recognize the right dialog ...but catch an error : "Ooops! There are some problems with our system
I try to type english utterance and then i get : Ooops! Too many attemps :(. But don't worry, I'm handling that exception and you can try again!
My idea is that : when i'm inside facebook in english language and click : Get Started ...my conversation to start in english dialog ( AlltheBot.cs). If i type french word like : salut, demarrer the bot can forward to french dialog ( FrenchLuis.cs) . And the other way around, when i'm in facebook in french version my conversation when i click on Demarrer to start in french , and then if i type hello to forward in english dialog.
My code is here :
MessageController.cs
namespace MultiDialogsBot
{
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;
using System.Web.Http;
using Microsoft.Bot.Builder.Dialogs;
using Microsoft.Bot.Connector;
using FirstBotApplication.Dialogs;
using System.Linq;
using System;
[BotAuthentication]
public class MessagesController : ApiController
{
/// <summary>
/// POST: api/Messages
/// Receive a message from a user and reply to it
/// </summary>
public async Task<HttpResponseMessage> Post([FromBody]Activity activity)
{
if (activity.Type == ActivityTypes.Message)
{
await Conversation.SendAsync(activity, () => new RootDialog());
}
else
{
this.HandleSystemMessage(activity);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
return response;
}
private Activity HandleSystemMessage(Activity message)
{
if (message.Type == ActivityTypes.DeleteUserData)
{
// Implement user deletion here
// If we handle user deletion, return a real message
}
else if (message.Type == ActivityTypes.ConversationUpdate)
{
// Handle conversation state changes, like members being added
and removed
// Use Activity.MembersAdded and Activity.MembersRemoved and
Activity.Action for info
IConversationUpdateActivity update = message;
var client = new ConnectorClient(new Uri(message.ServiceUrl),
new MicrosoftAppCredentials());
if (update.MembersAdded != null && update.MembersAdded.Any())
{
foreach (var newMember in update.MembersAdded)
{
if (newMember.Id != message.Recipient.Id && newMember.Id
!= message.Conversation.Id)
{
var reply = message.CreateReply();
reply.Text = $"Welcome" + " " +
message.Recipient.Name + " ! You are a new member! If you want to see
help menu , type : help";
client.Conversations.ReplyToActivityAsync(reply);
}
}
}
// Not available in all channels
}
else if (message.Type == ActivityTypes.ContactRelationUpdate)
{
// Handle add/remove from contact lists
// Activity.From + Activity.Action represent what happened
}
else if (message.Type == ActivityTypes.Typing)
{
// Handle knowing tha the user is typing
}
else if (message.Type == ActivityTypes.Ping)
{
}
return null;
}
}
}
RootDialog.cs
namespace FirstBotApplication.Dialogs
{
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Bot.Builder.Dialogs;
using Microsoft.Bot.Connector;
[Serializable]
public class RootDialog : IDialog<object>
{
public async Task StartAsync(IDialogContext context)
{
context.Wait(this.MessageReceivedAsync);
}
public virtual async Task MessageReceivedAsync(IDialogContext context,
IAwaitable<IMessageActivity> result)
{
var message = await result;
if (message.Text.ToLower().Contains("Get Started") ||
message.Text.ToLower().Contains("hello") ||
message.Text.ToLower().Contains("hi"))
{
context.Call(new AllTheBot (), this.ResumeAfterOptionDialog);
}
else if (message.Text.ToLower().Contains("Démarrer") ||
message.Text.ToLower().Contains("salut") ||
message.Text.ToLower().Contains("french"))
{
context.Call(new FrenchLuis(), this.ResumeAfterOptionDialog);
}
else
{
await context.PostAsync($"Ooops! There are some problems with our system");
}
}
private async Task ResumeAfterOptionDialog(IDialogContext context,
IAwaitable<object> result)
{
await context.PostAsync($"Ooops! Too many attemps :(. But don't
worry, I'm handling that exception and you can try again!");
}
}
}
FrenchLuis.cs
using Microsoft.Bot.Builder.Dialogs;
using Microsoft.Bot.Builder.Luis;
using Microsoft.Bot.Builder.Luis.Models;
using Microsoft.Bot.Connector;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Web;
namespace FirstBotApplication
{
// [LuisModel("Please Enter Your LUIS Model ID", "Please Enter Your
LUIS
Subscription Key")]
[Serializable]
[LuisModel("aaaaaaa", "xxxxxxxxx")]
public class FrenchLuis : LuisDialog<object>
{
internal static string results;
// internal static string results;
[LuisIntent("None")]
[LuisIntent("")]
public async Task None(IDialogContext context, LuisResult result)
{
string message = $"Désolé je n'ai pas compris '{result.Query}'.
Veuillez reformuler votre question";
await context.PostAsync(message);
context.Wait(this.MessageReceived);
context.Done(true);
}
//french luis.ai
[LuisIntent("demarrerintent")]
public async Task demarrerintent(IDialogContext context,
IAwaitable<IMessageActivity> activity, LuisResult result)
{
await context.PostAsync("Bienvenue :) ");
context.Done(true);
}
[LuisIntent("denous")]
public async Task denous(IDialogContext context,
IAwaitable<IMessageActivity> activity, LuisResult result)
{
await context.PostAsync(" Nous sommes .....");
context.Done(true);
}
[LuisIntent("quisommes")]
public async Task quisommes(IDialogContext context, IAwaitable<IMessageActivity> activity, LuisResult result)
{
await context.PostAsync("Je suis un robot");
context.Done(true);
// context.Wait(MessageReceived);
}
}}
AllTheBot.cs
using Microsoft.Bot.Builder.Dialogs;
using Microsoft.Bot.Builder.Luis;
using Microsoft.Bot.Builder.Luis.Models;
using Microsoft.Bot.Connector;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using System.Web;
namespace FirstBotApplication
{
[LuisModel("bbbbbb", "xxxxxxx")]
[Serializable]
public class AllTheBot : LuisDialog<object>
{
internal static string results;
// internal static string results;
[LuisIntent("None")]
[LuisIntent("")]
public async Task None(IDialogContext context, LuisResult result)
{
string message = $"Sorry, I did not understand '{result.Query}'.
Please reformulate your question";
await context.PostAsync(message);
context.Done(true);
// context.Wait(this.MessageReceived);
}
[LuisIntent("grettings")]
[LuisIntent("intentfr")]
public async Task Greeting(IDialogContext context,
IAwaitable<IMessageActivity> activity, LuisResult result)
{
await context.PostAsync("Welcome ");
context.Done(true);
}
[LuisIntent("test")]
public async Task test(IDialogContext context,
IAwaitable<IMessageActivity> activity, LuisResult result)
{
await context.PostAsync("Do you want to test our bot ? We suggest to
type : hi or who are you, help etc..");
context.Wait(MessageReceived);
}
}}

I had a look to your project and got a few problems. You should go step by step to eliminate the problems as you are mixing many things (Dialog management, LUIS calls etc.)
RootDialog.cs
1st point:
message.Text.ToLower().Contains("Démarrer")
and
message.Text.ToLower().Contains("Get Started")
Those two tests can't be valid, as you are comparing something in lowercase and a word with an uppercase.
Moreover, there are better clever ways to get the events of Facebook Messenger 'Get Started' button click, but that's not the point here.
2nd point:
private async Task ResumeAfterOptionDialog(IDialogContext context, IAwaitable<object> result)
{
await context.PostAsync($"Ooops! Too many attemps :(. But don't worry, I'm handling that exception and you can try again!");
}
Your text here is quite strange for a dialog resume!
AllTheBot.cs and FrenchLuis.cs
When you call your 2 LuisDialog, you are never passing the value of the message to those dialogs, is this normal?
You should use context.Forward instead of context.Call: in that way your message will automatically be forwarded to the child dialog.
Global behaviour
I don't think you are going to the right way for managing languages. Why don't you use a valid Language Detection system to check which language is the content you received from the user?
The Text Analytics API from Microsoft Cognitive Services is here for this: https://azure.microsoft.com/en-gb/services/cognitive-services/text-analytics/
Dialog management in your case
I made a sample of the implementation of 2 dialogs management (without LUIS here) to show you what's working:
[Serializable]
public class Dialog44592511 : IDialog<object>
{
public async Task StartAsync(IDialogContext context)
{
context.Wait(MessageReceivedAsync);
}
public virtual async Task MessageReceivedAsync(IDialogContext context, IAwaitable<IMessageActivity> result)
{
var message = await result;
if (message.Text.ToLower().Contains("Get Started") ||
message.Text.ToLower().Contains("hello") ||
message.Text.ToLower().Contains("hi"))
{
await context.Forward(new Dialog44592511_EN(), this.ResumeAfterOptionDialog, message);
}
else if (message.Text.ToLower().Contains("Démarrer") || message.Text.ToLower().Contains("salut") || message.Text.ToLower().Contains("french"))
{
await context.Forward(new Dialog44592511_FR(), this.ResumeAfterOptionDialog, message);
}
else
{
await context.PostAsync($"Ooops! There are some problems with our system");
}
}
private async Task ResumeAfterOptionDialog(IDialogContext context, IAwaitable<object> result)
{
await context.PostAsync($"Resume!");
}
}
[Serializable]
public class Dialog44592511_FR : IDialog<object>
{
public async Task StartAsync(IDialogContext context)
{
context.Wait(MessageReceivedAsync);
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable<object> result)
{
var activity = await result as Activity;
await context.PostAsync($"Vous êtes dans le dialogue FR");
context.Done<object>(null);
}
}
[Serializable]
public class Dialog44592511_EN : IDialog<object>
{
public async Task StartAsync(IDialogContext context)
{
context.Wait(MessageReceivedAsync);
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable<object> result)
{
var activity = await result as Activity;
await context.PostAsync($"You are in the EN dialog");
context.Done<object>(null);
}
}
Don't hesitate to edit your question for more details

Instead of doing context.Call, you should use context.Forward, which will forward the message to the dialog.
With the context.Call you are just calling the dialog and leaving it ready to receive a new message.
You should review the different ways to initiate dialogs, explained here.

Bot Framework Forward Type Arguments Error

I am getting this following error
when trying to use the MS Bot Framework Example to call a different dialog. This is my code:
using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Bot.Builder.Dialogs;
using Microsoft.Bot.Connector;
namespace ReadMeBot.Dialogs
{
[Serializable]
public class RootDialog : IDialog<object>
{
public Task StartAsync(IDialogContext context)
{
context.Wait(MessageReceivedAsync);
return Task.CompletedTask;
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable<object> result)
{
var activity = await result as Activity;
if (activity != null && activity.Text.ToLower().Contains("what is"))
{
await
context.Forward(new InternetSearchDialog(), this.ResumeAfterInternetSearchDialog, activity, CancellationToken.None);
}
// calculate something for us to return
int length = (activity.Text ?? string.Empty).Length;
// return our reply to the user
await context.PostAsync($"You sent {activity.Text} which was {length} characters. Thank you!");
context.Wait(MessageReceivedAsync);
}
private async Task ResumeAfterInternetSearchDialog(IDialogContext context, IAwaitable<string> result)
{
}
}
}
How can I solve this? I googled around and nobody seems to have this issue. What am I doing wrong?

Since you are forwarding to another dialog, you don't need to wait in this dialog. You'll want to call context.Wait in the resume though.
Things should work as expected if you change your code to something like this:
[Serializable]
public class RootDialog : IDialog<object>
{
public Task StartAsync(IDialogContext context)
{
context.Wait(MessageReceivedAsync);
return Task.CompletedTask;
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable<object> result)
{
var activity = await result as Activity;
if (activity != null && activity.Text.ToLower().Contains("what is"))
{
await
context.Forward(new InternetSearchDialog(), this.ResumeAfterInternetSearchDialog, activity, CancellationToken.None);
}
else
{
// calculate something for us to return
int length = (activity.Text ?? string.Empty).Length;
// return our reply to the user
await context.PostAsync($"You sent {activity.Text} which was {length} characters. Thank you!");
context.Wait(MessageReceivedAsync);
}
}
private async Task ResumeAfterInternetSearchDialog(IDialogContext context, IAwaitable<string> result)
{
context.Wait(MessageReceivedAsync);
}
}