protected Task <bool> EndCurrentActionAsync(SequenceContext sequenceContext, CancellationToken cancellationToken = default) { if (sequenceContext.Actions.Any()) { sequenceContext.Actions.RemoveAt(0); } return(Task.FromResult(false)); }
/// <summary> /// Read event queues from memory. /// </summary> /// <param name="context">Context for memory.</param> /// <returns>Event queues.</returns> public static EntityEvents Read(SequenceContext context) { var dcState = context.GetState(); if (!dcState.TryGetValue <EntityEvents>(Events, out var queues)) { queues = new EntityEvents(); } return(queues); }
protected async Task <DialogTurnResult> OnEndOfActionsAsync(SequenceContext sequenceContext, CancellationToken cancellationToken = default) { // End dialog and return result if (sequenceContext.ActiveDialog != null) { if (ShouldEnd(sequenceContext)) { sequenceContext.State.TryGetValue <object>(DefaultResultProperty, out var result); return(await sequenceContext.EndDialogAsync(result, cancellationToken).ConfigureAwait(false)); } return(EndOfTurn); } return(new DialogTurnResult(DialogTurnStatus.Cancelled)); }
protected async Task <RecognizerResult> OnRecognize(SequenceContext sequenceContext, CancellationToken cancellationToken = default) { var context = sequenceContext.Context; if (Recognizer != null) { var result = await Recognizer.RecognizeAsync(sequenceContext, cancellationToken).ConfigureAwait(false); if (result.Intents.Any()) { // just deal with topIntent IntentScore topScore = null; var topIntent = string.Empty; foreach (var intent in result.Intents) { if (topScore == null || topScore.Score < intent.Value.Score) { topIntent = intent.Key; topScore = intent.Value; } } result.Intents.Clear(); result.Intents.Add(topIntent, topScore); } else { result.Intents.Add("None", new IntentScore { Score = 0.0 }); } return(result); } // none intent if there is no recognizer return(new RecognizerResult { Text = context.Activity.Text ?? string.Empty, Intents = new Dictionary <string, IntentScore> { { "None", new IntentScore { Score = 0.0 } } }, }); }
public override DialogContext CreateChildContext(DialogContext dc) { var activeDialogState = dc.ActiveDialog.State as Dictionary <string, object>; var state = activeDialogState[AdaptiveKey] as AdaptiveDialogState; if (state == null) { state = new AdaptiveDialogState(); activeDialogState[AdaptiveKey] = state; } if (state.Actions != null && state.Actions.Any()) { var ctx = new SequenceContext(this.Dialogs, dc, state.Actions.First(), state.Actions, changeTurnKey, this.Dialogs); ctx.Parent = dc; return(ctx); } return(null); }
private async Task <bool> QueueFirstMatchAsync(SequenceContext sequenceContext, DialogEvent dialogEvent, bool preBubble, CancellationToken cancellationToken) { var selection = await Selector.Select(sequenceContext, cancellationToken).ConfigureAwait(false); if (selection.Any()) { var evt = Triggers[selection.First()]; await sequenceContext.DebuggerStepAsync(evt, dialogEvent, cancellationToken).ConfigureAwait(false); Trace.TraceInformation($"Executing Dialog: {Id} Rule[{selection}]: {evt.GetType().Name}: {evt.GetExpression(new ExpressionEngine())}"); var changes = await evt.ExecuteAsync(sequenceContext).ConfigureAwait(false); if (changes != null && changes.Count > 0) { sequenceContext.QueueChanges(changes[0]); return(true); } } return(false); }
private SequenceContext ToSequenceContext(DialogContext dc) { var activeDialogState = dc.ActiveDialog.State as Dictionary <string, object>; var state = activeDialogState[AdaptiveKey] as AdaptiveDialogState; if (state == null) { state = new AdaptiveDialogState(); activeDialogState[AdaptiveKey] = state; } if (state.Actions == null) { state.Actions = new List <ActionState>(); } var sequenceContext = new SequenceContext(dc.Dialogs, dc, new DialogState { DialogStack = dc.Stack }, state.Actions, changeTurnKey, this.Dialogs); sequenceContext.Parent = dc.Parent; return(sequenceContext); }
protected async Task <bool> ProcessEventAsync(SequenceContext sequenceContext, DialogEvent dialogEvent, bool preBubble, CancellationToken cancellationToken = default) { // Save into turn sequenceContext.GetState().SetValue(TurnPath.DIALOGEVENT, dialogEvent); EnsureDependenciesInstalled(); // Look for triggered evt var handled = await QueueFirstMatchAsync(sequenceContext, dialogEvent, preBubble, cancellationToken).ConfigureAwait(false); if (handled) { return(true); } // Default processing if (preBubble) { switch (dialogEvent.Name) { case AdaptiveEvents.BeginDialog: if (sequenceContext.GetState().GetBoolValue(TurnPath.ACTIVITYPROCESSED) == false) { // Emit leading ActivityReceived event var activityReceivedEvent = new DialogEvent() { Name = AdaptiveEvents.ActivityReceived, Value = sequenceContext.Context.Activity, Bubble = false }; handled = await ProcessEventAsync(sequenceContext, dialogEvent : activityReceivedEvent, preBubble : true, cancellationToken : cancellationToken).ConfigureAwait(false); } break; case AdaptiveEvents.ActivityReceived: if (sequenceContext.Context.Activity.Type == ActivityTypes.Message) { // Recognize utterance (ignore handled) var recognizeUtteranceEvent = new DialogEvent { Name = AdaptiveEvents.RecognizeUtterance, Value = sequenceContext.Context.Activity, Bubble = false }; await ProcessEventAsync(sequenceContext, dialogEvent : recognizeUtteranceEvent, preBubble : true, cancellationToken : cancellationToken).ConfigureAwait(false); // Emit leading RecognizedIntent event var recognized = sequenceContext.GetState().GetValue <RecognizerResult>(TurnPath.RECOGNIZED); var recognizedIntentEvent = new DialogEvent { Name = AdaptiveEvents.RecognizedIntent, Value = recognized, Bubble = false }; handled = await ProcessEventAsync(sequenceContext, dialogEvent : recognizedIntentEvent, preBubble : true, cancellationToken : cancellationToken).ConfigureAwait(false); } // Has an interruption occured? // - Setting this value to true causes any running inputs to re-prompt when they're // continued. The developer can clear this flag if they want the input to instead // process the users uterrance when its continued. if (handled) { sequenceContext.GetState().SetValue(TurnPath.INTERRUPTED, true); } break; case AdaptiveEvents.RecognizeUtterance: if (sequenceContext.Context.Activity.Type == ActivityTypes.Message) { // Recognize utterance var recognized = await OnRecognize(sequenceContext, cancellationToken).ConfigureAwait(false); sequenceContext.GetState().SetValue(TurnPath.RECOGNIZED, recognized); var(name, score) = recognized.GetTopScoringIntent(); sequenceContext.GetState().SetValue(TurnPath.TOPINTENT, name); sequenceContext.GetState().SetValue(TurnPath.TOPSCORE, score); if (Recognizer != null) { await sequenceContext.DebuggerStepAsync(Recognizer, AdaptiveEvents.RecognizeUtterance, cancellationToken).ConfigureAwait(false); } handled = true; } break; } } else { switch (dialogEvent.Name) { case AdaptiveEvents.BeginDialog: if (sequenceContext.GetState().GetBoolValue(TurnPath.ACTIVITYPROCESSED) == false) { var activityReceivedEvent = new DialogEvent { Name = AdaptiveEvents.ActivityReceived, Value = sequenceContext.Context.Activity, Bubble = false }; handled = await ProcessEventAsync(sequenceContext, dialogEvent : activityReceivedEvent, preBubble : false, cancellationToken : cancellationToken).ConfigureAwait(false); } break; case AdaptiveEvents.ActivityReceived: var activity = sequenceContext.Context.Activity; if (activity.Type == ActivityTypes.Message) { // Empty sequence? if (!sequenceContext.Actions.Any()) { // Emit trailing unknownIntent event var unknownIntentEvent = new DialogEvent { Name = AdaptiveEvents.UnknownIntent, Bubble = false }; handled = await ProcessEventAsync(sequenceContext, dialogEvent : unknownIntentEvent, preBubble : false, cancellationToken : cancellationToken).ConfigureAwait(false); } else { handled = false; } } // Has an interruption occured? // - Setting this value to true causes any running inputs to re-prompt when they're // continued. The developer can clear this flag if they want the input to instead // process the users uterrance when its continued. if (handled) { sequenceContext.GetState().SetValue(TurnPath.INTERRUPTED, true); } break; } } return(handled); }
protected async Task <RecognizerResult> OnRecognize(SequenceContext sequenceContext, CancellationToken cancellationToken = default) { var context = sequenceContext.Context; var noneIntent = new RecognizerResult { Text = context.Activity.Text ?? string.Empty, Intents = new Dictionary <string, IntentScore> { { "None", new IntentScore { Score = 0.0 } } }, Entities = JObject.Parse("{}") }; var text = context.Activity.Text; if (context.Activity.Value != null) { var value = JObject.FromObject(context.Activity.Value); // Check for submission of an adaptive card if (string.IsNullOrEmpty(text) && value.Property("intent") != null) { // Map submitted values to a recognizer result var recognized = new RecognizerResult { Text = string.Empty }; foreach (var property in value.Properties()) { if (property.Name.ToLower() == "intent") { recognized.Intents[property.Value.ToString()] = new IntentScore { Score = 1.0 }; } else { if (recognized.Entities.Property(property.Name) == null) { recognized.Entities[property.Name] = new JArray(property.Value); } else { ((JArray)recognized.Entities[property.Name]).Add(property.Value); } } } return(recognized); } } if (Recognizer != null) { var result = await Recognizer.RecognizeAsync(context, cancellationToken).ConfigureAwait(false); // only allow one intent var topIntent = result.GetTopScoringIntent(); result.Intents.Clear(); result.Intents.Add(topIntent.intent, new IntentScore { Score = topIntent.score }); return(result); } return(noneIntent); }
/// <summary> /// Write state into memory. /// </summary> /// <param name="context">Memory context.</param> public void Write(SequenceContext context) => context.GetState().SetValue(Events, this);