public static VmIntentResponse FromIntentResponse(IntentResponse intentResponse) { var response = new VmIntentResponse { Action = intentResponse.Action }; response.AffectedContexts = intentResponse.Contexts.Select(ctx => ctx.ToObject <VmIntentResponseContext>()).ToList(); response.Parameters = intentResponse.Parameters.Select(p => VmIntentResponseParameter.FromIntentResponseParameter(p)).ToList(); response.Messages = intentResponse.Messages.Select(msg => { if (msg.Speech == null) { return(new VmIntentResponseMessage()); } return(new VmIntentResponseMessage { Payload = msg.Payload, Type = msg.Type, Speeches = JsonConvert.DeserializeObject <List <String> >(msg.Speech) }); }).ToList(); return(response); }
public IntentResponse CreateIntent(string workspaceId, CreateIntent body) { if (string.IsNullOrEmpty(workspaceId)) { throw new ArgumentNullException(nameof(workspaceId)); } if (body == null) { throw new ArgumentNullException(nameof(body)); } if (string.IsNullOrEmpty(VersionDate)) { throw new ArgumentNullException("versionDate cannot be null. Use 'CONVERSATION_VERSION_DATE_2017_05_26'"); } IntentResponse result = null; try { result = this.Client.WithAuthentication(this.UserName, this.Password) .PostAsync($"{this.Endpoint}/v1/workspaces/{workspaceId}/intents") .WithArgument("version", VersionDate) .WithBody <CreateIntent>(body) .As <IntentResponse>() .Result; } catch (AggregateException ae) { throw ae.Flatten(); } return(result); }
public static Type GetIntentType(this IntentResponse intent) { switch (intent.Intent) { case "PlaySong": return(typeof(WidgetDeezer)); case "TurnOnTv": case "FullScreenTv": case "ReduceScreenTv": return(typeof(WidgetTv)); case "TurnOnRadio": return(typeof(WidgetRadio)); case "BlancheNeige": //Vm.SpeakCommand.Execute("Si je m'en tiens aux personnes que je connais, je peux affirmer que tu es le plus beau."); case "Tweet": case "HideAll": case "StartScreen": case "DisplayWidget": case "DisplayMail": case "AddReminder": case "TakePhoto": case "TurnOff": default: return(null); } }
private void Client_OnMessageReceived(object sender, TwitchLib.Client.Events.OnMessageReceivedArgs e) { string botCommandResponse = _chatMessageService.HandleBotCommands(e.ChatMessage.Message.Trim()); if (string.IsNullOrEmpty(botCommandResponse)) // do something with luis { // Run async method in this sync method (read https://cpratt.co/async-tips-tricks/) IntentResponse intentResponse = AsyncHelper.RunSync(() => _luisService.GetIntentAsync(e.ChatMessage.Message.Trim())); decimal certaintyThreshold; if (!decimal.TryParse(_luisConfiguration.LuisChatCertaintyThreshold, out certaintyThreshold)) { throw new ArgumentException(nameof(_luisConfiguration.LuisChatCertaintyThreshold)); } if (intentResponse.Certainty > certaintyThreshold) { string luisMappedResponse = _chatMessageService.MapLuisIntentToResponse(intentResponse); _twitchClient.SendMessage(_twitchConfiguration.ChannelName, luisMappedResponse); } AddTwitchUserChatRecordToDb(e, intentResponse); } else // do something with explicit bot commands { _twitchClient.SendMessage(_twitchConfiguration.ChannelName, botCommandResponse); } }
public IntentResponse UpdateIntent(string workspaceId, string intent, UpdateIntent request) { IntentResponse result = null; if (string.IsNullOrEmpty(workspaceId)) { throw new ArgumentNullException("parameter: workspaceId"); } if (string.IsNullOrEmpty(intent)) { throw new ArgumentNullException("parameter: intent"); } if (request == null) { throw new ArgumentNullException("parameter: request"); } try { result = this.Client.WithAuthentication(this.UserName, this.Password) .PostAsync($"{this.Endpoint}{PATH_CONVERSATION}/{workspaceId}") .WithArgument("version", VERSION_DATE_2017_05_26) .WithHeader("accept", HttpMediaType.TEXT_HTML) .WithBody <UpdateIntent>(request, MediaTypeHeaderValue.Parse(HttpMediaType.APPLICATION_JSON)) .As <IntentResponse>() .Result; } catch (AggregateException ae) { throw ae.Flatten(); } return(result); }
private void Client_OnMessageReceived(object sender, TwitchLib.Client.Events.OnMessageReceivedArgs e) { string botMessageResponse = _chatMessageService.HandleBotCommands(e); IntentResponse intentResponse = new IntentResponse { Certainty = null, EmbeddedUrl = null, Intent = null }; // create with an empty default, for bot-command messages (those that are not fed through LUIS) if (string.IsNullOrEmpty(botMessageResponse)) // nothing from bot-commands, so try doing something with LUIS { // Run async method in this sync method (read https://cpratt.co/async-tips-tricks/) intentResponse = AsyncHelper.RunSync(() => _luisService.GetIntentAsync(e.ChatMessage.Message.Trim())); decimal certaintyThreshold; if (!decimal.TryParse(_luisConfiguration.LuisChatCertaintyThreshold, out certaintyThreshold)) { throw new ArgumentException(nameof(_luisConfiguration.LuisChatCertaintyThreshold)); } if (intentResponse.Certainty > certaintyThreshold) { botMessageResponse = _chatMessageService.MapLuisIntentToResponse(intentResponse); } } AddTwitchUserChatRecordToDb(e, intentResponse); _twitchClient.SendMessage(_twitchConfiguration.ChannelName, botMessageResponse); }
public static void HandleContext(Database dc, AIConfiguration AiConfig, IntentResponse intentResponse, AIResponse aiResponse) { if (intentResponse == null) { return; } // Merge context lifespan // override if exists, otherwise add, delete if lifespan is zero dc.DbTran(() => { var sessionContexts = dc.Table <ConversationContext>().Where(x => x.ConversationId == AiConfig.SessionId).ToList(); // minus 1 round sessionContexts.Where(x => !intentResponse.Contexts.Select(ctx => ctx.Name).Contains(x.Context)) .ToList() .ForEach(ctx => ctx.Lifespan = ctx.Lifespan - 1); intentResponse.Contexts.ForEach(ctx => { var session1 = sessionContexts.FirstOrDefault(x => x.Context == ctx.Name); if (session1 != null) { if (ctx.Lifespan == 0) { dc.Table <ConversationContext>().Remove(session1); } else { session1.Lifespan = ctx.Lifespan; } } else { dc.Table <ConversationContext>().Add(new ConversationContext { ConversationId = AiConfig.SessionId, Context = ctx.Name, Lifespan = ctx.Lifespan }); } }); }); aiResponse.Result.Contexts = dc.Table <ConversationContext>() .Where(x => x.Lifespan > 0 && x.ConversationId == AiConfig.SessionId) .Select(x => new AIContext { Name = x.Context.ToLower(), Lifespan = x.Lifespan }) .ToArray(); }
public string MapLuisIntentToResponse(IntentResponse intentResponse) { string intent = intentResponse.Intent.ToLower(); switch (intent) { case "compliment": return(_luisChatResponses.Compliment); case "greeting": return(_luisChatResponses.Greeting); case "hostile": return(_luisChatResponses.Hostile); case "howdoesbotwork": return(_luisChatResponses.Howdoesbotwork); case "howlongprogramming": return(_luisChatResponses.Howlongprogramming); case "lowlongstream": return(_luisChatResponses.Howlongstream); case "innapropriate": return(_luisChatResponses.Innapropriate); case "provideurllink": return(_luisChatResponses.Provideurllink); case "whatareyoudoing": return(_luisChatResponses.Whatareyoudoing); case "whatlanguage": return(_luisChatResponses.Whatlanguage); case "whendoyoustream": return(_luisChatResponses.Whendoyoustream); case "whichide": return(_luisChatResponses.WhichIDE); case "whoareyou": return(_luisChatResponses.Whoareyou); default: return(string.Empty); } }
public IntentResponse ToIntentResponse(IntentResponse intentResponse = null) { if (intentResponse == null) { intentResponse = new IntentResponse { Id = Guid.NewGuid().ToString(), ResetContexts = ResetContexts, Contexts = AffectedContexts.Select(x => x.ToObject <IntentResponseContext>()).ToList(), Parameters = Parameters.Select(x => x.ToObject <IntentResponseParameter>()).ToList(), Messages = Messages.Select(x => x.ToIntentResponseMessage()).ToList() }; } return(intentResponse); }
private List <AIContext> HandleContexts(string sessionId, IntentResponse response) { var newContexts = response.Contexts.Select(x => new AIContext { Name = x.Name, Lifespan = x.Lifespan, Parameters = response.Parameters.Select(p => new KeyValuePair <string, object>(p.Name, p.Value)).ToDictionary(d => d.Key, d => d.Value == null ? String.Empty : d.Value) }).ToList(); // persist var ctxStore = contextStorageFactory.Get(); ctxStore.Persist(sessionId, newContexts.ToArray()); return(newContexts); }
private void AddTwitchUserChatRecordToDb(OnMessageReceivedArgs e, IntentResponse intentResponse) { // create new chat record TwitchUserChat twitchUserChat = new TwitchUserChat { TwitchUserId = e.ChatMessage.UserId.ToString(), TwitchUserType = e.ChatMessage.UserType.ToString(), TwitchUserDisplayName = e.ChatMessage.DisplayName.ToString(), ChatMessage = e.ChatMessage.Message, ExtractedUrl = intentResponse.EmbeddedUrl, LuisIntent = intentResponse.Intent, LuisCertainty = intentResponse.Certainty }; // add chat record to DB AsyncHelper.RunSync(() => _twitchUserChatRepository.CreateAsync(twitchUserChat)); }
public static void HandleMessage(IntentResponse intentResponse) { if (intentResponse == null) { return; } var missingRequiredParameter = intentResponse.Parameters.FirstOrDefault(x => x.Required && String.IsNullOrEmpty(x.Value)); if (missingRequiredParameter != null) { intentResponse.Messages = new List <IntentResponseMessage> { new IntentResponseMessage { Type = AIResponseMessageType.Text, Speech = ArrayHelper.GetRandom(missingRequiredParameter.Prompts).Prompt, IntentResponseId = intentResponse.Id, UpdatedTime = DateTime.UtcNow } }; } else { intentResponse.Messages = intentResponse.Messages.OrderBy(x => x.UpdatedTime).ToList(); } intentResponse.Messages.ToList() .ForEach(msg => { if (msg.Type == AIResponseMessageType.Custom) { } else { if (msg.Speech != "[]") { msg.Speech = msg.Speech.StartsWith("[") ? ArrayHelper.GetRandom(msg.Speech.Substring(2, msg.Speech.Length - 4).Split("\",\"").ToList()) : msg.Speech; msg.Speech = ReplaceParameters4Response(intentResponse.Parameters, msg.Speech); } } }); }
/// <summary> /// /// </summary> /// <param name="agent"></param> /// <param name="intentResponse"></param> /// <param name="response"></param> /// <param name="request"></param> /// <returns>Required field is missed</returns> public static void HandleParameter(AgentModel agent, IntentResponse intentResponse, RasaResponse response, AiRequest aiRequest) { if (intentResponse == null) { return; } intentResponse.Parameters.ForEach(p => { string query = aiRequest.Text; var entity = response.Entities.FirstOrDefault(x => x.Entity == p.Name || x.Entity.Split(':').Contains(p.Name)); if (entity != null) { p.Value = query.Substring(entity.Start, entity.End - entity.Start); } // convert to Standard entity value /*if (!String.IsNullOrEmpty(p.Value) && !p.DataType.StartsWith("sys.")) * { * p.Value = agent.Entities * .FirstOrDefault(x => x.Entity == p.DataType) * .Entries * .FirstOrDefault((entry) => * { * return entry.Value.ToLower() == p.Value.ToLower() || * entry.Synonyms.Select(synonym => synonym.Synonym.ToLower()).Contains(p.Value.ToLower()); * })?.Value; * }*/ // fixed entity per request /*if (aiRequest.Entities != null) * { * var fixedEntity = request.Entities.FirstOrDefault(x => x.Name == p.Name); * if (fixedEntity != null) * { * if (query.ToLower().Contains(fixedEntity.Entries.First().Value.ToLower())) * { * p.Value = fixedEntity.Entries.First().Value; * } * } * }*/ }); }
/// <summary> /// /// </summary> /// <param name="agent"></param> /// <param name="intentResponse"></param> /// <param name="response"></param> /// <param name="request"></param> /// <returns>Required field is missed</returns> public static void HandleParameter(Agent agent, IntentResponse intentResponse, RasaResponse response, AIRequest request) { if (intentResponse == null) { return; } intentResponse.Parameters.ForEach(p => { string query = request.Query.First(); var entity = response.Entities.FirstOrDefault(x => x.Entity == p.Name || x.Entity.Split(":").Contains(p.Name)); if (entity != null) { p.Value = query.Substring(entity.Start, entity.End - entity.Start); } // convert to Standard entity value if (!String.IsNullOrEmpty(p.Value) && !p.DataType.StartsWith("sys.")) { p.Value = agent.Entities .FirstOrDefault(x => x.Name == p.DataType) .Entries .FirstOrDefault((entry) => { return(entry.Value.ToLower() == p.Value.ToLower() || entry.Synonyms.Select(synonym => synonym.Synonym.ToLower()).Contains(p.Value.ToLower())); })?.Value; } // fixed entity per request if (request.Entities != null) { var fixedEntity = request.Entities.FirstOrDefault(x => x.Name == p.Name); if (fixedEntity != null) { if (query.ToLower().Contains(fixedEntity.Entries.First().Value.ToLower())) { p.Value = fixedEntity.Entries.First().Value; } } } }); }
private static IntentResponse CreateResponse(AvailabilityMessageModel messages) { var cardMessage = messages.CardMessages.First(); var assistantResponse = messages.SimpleResponses.First(); var response = new IntentResponse { FulfillmentText = messages.FulFillmentMessage, FulfillmentMessages = new List <Models.Response.Fulfillmentmessage> { new Models.Response.Fulfillmentmessage { Card = new Card { Title = cardMessage.Title, Subtitle = cardMessage.SubTitle } } }, Payload = new Models.Response.Payload { Google = new Models.Response.Google { ExpectUserResponse = false, RichResponse = new Richresponse { Items = new List <Item> { new Item { SimpleResponse = assistantResponse } } } } } }; return(response); }
public async Task <IntentResponse> GetIntentAsync(string phrase) { var luisApiIntentUri = new Uri(this.LuisApiUri, $"?subscription-key={this.LuisInstanceKey}&verbose=true&timezoneOffset=0&q={phrase}"); var luisResponse = await this.GetLuisIntent(luisApiIntentUri); var intentResponse = new IntentResponse(); intentResponse.Intent = luisResponse.TopScoringIntent.Intent; foreach (var entity in luisResponse.Entities) { intentResponse.Entities.Add( new Entity { Name = entity.Entity, Score = entity.Score, StartIndex = entity.StartIndex, EndIndex = entity.EndIndex, Type = entity.Type }); } return(intentResponse); }
public ActionMessage(IntentResponse intent) { Intent = intent; }