private UriBuilder BuildUri(LuisV3.LuisPredictionOptions options)
{
var path = new StringBuilder(Application.Endpoint);
path.Append($"/luis/prediction/v3.0/apps/{Application.ApplicationId}");
if (options.Version == null)
{
path.Append($"/slots/{options.Slot}/predict");
}
else
{
path.Append($"/versions/{options.Version}/predict");
}
var uri = new UriBuilder(path.ToString());
var query = HttpUtility.ParseQueryString(uri.Query);
query["verbose"] = options.IncludeInstanceData.ToString();
query["log"] = options.Log.ToString();
query["show-all-intents"] = options.IncludeAllIntents.ToString();
uri.Query = query.ToString();
return(uri);
}
public async Task UtteranceWithoutTurnContext()
{
const string utterance = "email about something wicked this way comes from bart simpson and also kb435";
const string responsePath = "Patterns.json";
var expectedPath = GetFilePath(responsePath);
JObject oracle;
using (var expectedJsonReader = new JsonTextReader(new StreamReader(expectedPath)))
{
oracle = (JObject)await JToken.ReadFromAsync(expectedJsonReader);
}
var mockResponse = oracle["v3"]["response"];
GetEnvironmentVars();
var mockHttp = GetMockHttpClientHandlerObject(utterance, new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(mockResponse))));
var options = new LuisV3.LuisPredictionOptions {
IncludeAllIntents = true, IncludeInstanceData = true
};
var luisRecognizer = GetLuisRecognizer(mockHttp, options) as LuisRecognizer;
var result = await luisRecognizer.RecognizeAsync(utterance);
Assert.NotNull(result);
Assert.Null(result.AlteredText);
Assert.Equal(utterance, result.Text);
Assert.NotNull(result.Intents);
Assert.NotNull(result.Entities);
}
internal override async Task <RecognizerResult> RecognizeInternalAsync(DialogContext dialogContext, Activity activity, HttpClient httpClient, CancellationToken cancellationToken)
{
var options = PredictionOptions;
if (ExternalEntityRecognizer != null)
{
// call external entity recognizer
var matches = await ExternalEntityRecognizer.RecognizeAsync(dialogContext, activity, cancellationToken).ConfigureAwait(false);
if (matches.Entities != null && matches.Entities.Count > 0)
{
options = new LuisV3.LuisPredictionOptions(options);
options.ExternalEntities = new List <LuisV3.ExternalEntity>();
var entities = matches.Entities;
var instance = entities["$instance"].ToObject <JObject>();
if (instance != null)
{
foreach (var child in entities)
{
// TODO: Checking for "text" because we get an extra non-real entity from the text recognizers
if (child.Key != "text" && child.Key != "$instance")
{
var instances = instance[child.Key]?.ToObject <JArray>();
var values = child.Value.ToObject <JArray>();
if (instances != null && values != null &&
instances.Count == values.Count)
{
for (var i = 0; i < values.Count; ++i)
{
var childInstance = instances[i].ToObject <JObject>();
if (childInstance != null &&
childInstance.ContainsKey("startIndex") &&
childInstance.ContainsKey("endIndex"))
{
var start = childInstance["startIndex"].Value <int>();
var end = childInstance["endIndex"].Value <int>();
options.ExternalEntities.Add(new LuisV3.ExternalEntity(child.Key, start, end - start, child.Value));
}
}
}
}
}
}
}
}
// call luis recognizer with options.ExternalEntities populated from externalEntityRecognizer.
return(await RecognizeAsync(dialogContext.Context, activity?.Text, options, httpClient, cancellationToken).ConfigureAwait(false));
}
private async Task <JObject> GetLuisResponseAsync(string utterance, LuisV3.LuisPredictionOptions options, HttpClient httpClient, CancellationToken cancellationToken)
{
var uri = BuildUri(options);
var content = BuildRequestBody(utterance, options);
using var request = new HttpRequestMessage(HttpMethod.Post, uri.Uri);
using var stringContent = new StringContent(content.ToString(), Encoding.UTF8, "application/json");
request.Content = stringContent;
request.Headers.Add("Ocp-Apim-Subscription-Key", Application.EndpointKey);
var response = await httpClient.SendAsync(request, cancellationToken).ConfigureAwait(false);
response.EnsureSuccessStatusCode();
return((JObject)JsonConvert.DeserializeObject(await response.Content.ReadAsStringAsync().ConfigureAwait(false)));
}
private async Task <RecognizerResult> RecognizeAsync(string utterance, LuisV3.LuisPredictionOptions options, HttpClient httpClient, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(utterance))
{
return(new RecognizerResult
{
Text = utterance
});
}
else
{
var luisResponse = await GetLuisResponseAsync(utterance, options, httpClient, cancellationToken).ConfigureAwait(false);
return(BuildRecognizerResultFromLuisResponse(luisResponse, utterance));
}
}
/// <summary>
/// Construct V3 recognizer options from the current dialog context.
/// </summary>
/// <param name="dialogContext">Context.</param>
/// <returns>LUIS Recognizer options.</returns>
public LuisRecognizerOptionsV3 RecognizerOptions(DialogContext dialogContext)
{
AI.LuisV3.LuisPredictionOptions options = new LuisV3.LuisPredictionOptions();
if (this.PredictionOptions != null)
{
options = new LuisV3.LuisPredictionOptions(this.PredictionOptions);
}
else if (this.Options != null)
{
options.DateTimeReference = this.Options.DateTimeReference?.GetValue(dialogContext);
options.ExternalEntities = this.Options.ExternalEntities?.GetValue(dialogContext);
options.IncludeAllIntents = this.Options.IncludeAllIntents?.GetValue(dialogContext) ?? false;
options.IncludeInstanceData = this.Options.IncludeInstanceData?.GetValue(dialogContext) ?? true;
options.IncludeAPIResults = this.Options.IncludeAPIResults?.GetValue(dialogContext) ?? false;
options.Log = this.Options.Log?.GetValue(dialogContext) ?? true;
options.PreferExternalEntities = this.Options.PreferExternalEntities?.GetValue(dialogContext) ?? true;
options.Slot = this.Options.Slot?.GetValue(dialogContext);
}
if (this.Version != null)
{
options.Version = this.Version?.GetValue(dialogContext.State);
}
if (DynamicLists != null)
{
var list = new List <AI.LuisV3.DynamicList>();
foreach (var listEntity in DynamicLists.GetValue(dialogContext.State))
{
list.Add(new AI.LuisV3.DynamicList(listEntity.Entity, listEntity.List));
}
options.DynamicLists = list;
}
var application = new LuisApplication(ApplicationId.GetValue(dialogContext.State), EndpointKey.GetValue(dialogContext.State), Endpoint.GetValue(dialogContext.State));
return(new LuisRecognizerOptionsV3(application)
{
ExternalEntityRecognizer = ExternalEntityRecognizer,
PredictionOptions = options,
TelemetryClient = TelemetryClient,
IncludeAPIResults = options.IncludeAPIResults,
});
}
private JObject BuildRequestBody(string utterance, LuisV3.LuisPredictionOptions options)
{
var content = new JObject
{
{ "query", utterance },
};
var queryOptions = new JObject
{
{ "preferExternalEntities", options.PreferExternalEntities },
};
if (!string.IsNullOrEmpty(options.DateTimeReference))
{
queryOptions.Add("datetimeReference", options.DateTimeReference);
}
content.Add("options", queryOptions);
var settings = new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
};
if (options.DynamicLists != null)
{
foreach (var list in options.DynamicLists)
{
list.Validate();
}
content.Add("dynamicLists", (JArray)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(options.DynamicLists, settings)));
}
if (options.ExternalEntities != null)
{
foreach (var entity in options.ExternalEntities)
{
entity.Validate();
}
content.Add("externalEntities", (JArray)JsonConvert.DeserializeObject(JsonConvert.SerializeObject(options.ExternalEntities, settings)));
}
return(content);
}
private IRecognizer GetLuisRecognizer(MockedHttpClientHandler httpClientHandler, LuisV3.LuisPredictionOptions options = null)
{
var luisApp = new LuisApplication(AppId, Key, Endpoint);
var luisRecognizerOptions = new LuisRecognizerOptionsV3(luisApp)
{
PredictionOptions = options,
IncludeAPIResults = options == null ? false : true,
};
return(new LuisRecognizer(luisRecognizerOptions, httpClientHandler));
// return new LuisRecognizer(luisApp, new LuisRecognizerOptions { HttpClient = httpClientHandler }, options);
}
private async Task <RecognizerResult> RecognizeAsync(ITurnContext turnContext, string utterance, LuisV3.LuisPredictionOptions options, HttpClient httpClient, CancellationToken cancellationToken)
{
RecognizerResult recognizerResult;
JObject luisResponse = null;
if (string.IsNullOrWhiteSpace(utterance))
{
recognizerResult = new RecognizerResult
{
Text = utterance
};
}
else
{
var uri = BuildUri(options);
var content = BuildRequestBody(utterance, options);
httpClient.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", Application.EndpointKey);
var response = await httpClient.PostAsync(uri.Uri, new StringContent(content.ToString(), System.Text.Encoding.UTF8, "application/json")).ConfigureAwait(false);
response.EnsureSuccessStatusCode();
httpClient.DefaultRequestHeaders.Remove("Ocp-Apim-Subscription-Key");
luisResponse = (JObject)JsonConvert.DeserializeObject(await response.Content.ReadAsStringAsync().ConfigureAwait(false));
var prediction = (JObject)luisResponse["prediction"];
recognizerResult = new RecognizerResult();
recognizerResult.Text = utterance;
recognizerResult.AlteredText = prediction["alteredQuery"]?.Value <string>();
recognizerResult.Intents = LuisV3.LuisUtil.GetIntents(prediction);
recognizerResult.Entities = LuisV3.LuisUtil.ExtractEntitiesAndMetadata(prediction);
LuisV3.LuisUtil.AddProperties(prediction, recognizerResult);
if (IncludeAPIResults)
{
recognizerResult.Properties.Add("luisResult", luisResponse);
}
if (PredictionOptions.IncludeInstanceData)
{
var instanceObject = recognizerResult.Entities["$instance"];
if (instanceObject == null)
{
recognizerResult.Entities.Add("$instance", new JObject());
}
}
}
var traceInfo = JObject.FromObject(
new
{
recognizerResult,
luisModel = new
{
ModelID = Application.ApplicationId,
},
luisOptions = options,
luisResult = luisResponse,
});
await turnContext.TraceActivityAsync("LuisRecognizer", traceInfo, LuisTraceType, LuisTraceLabel, cancellationToken).ConfigureAwait(false);
return(recognizerResult);
}
private async Task <RecognizerResult> RecognizeAsync(ITurnContext turnContext, string utterance, LuisV3.LuisPredictionOptions options, HttpClient httpClient, CancellationToken cancellationToken)
{
RecognizerResult recognizerResult;
JObject luisResponse = null;
if (string.IsNullOrWhiteSpace(utterance))
{
recognizerResult = new RecognizerResult
{
Text = utterance
};
}
else
{
luisResponse = await GetLuisResponseAsync(utterance, options, httpClient, cancellationToken).ConfigureAwait(false);
recognizerResult = BuildRecognizerResultFromLuisResponse(luisResponse, utterance);
}
var traceInfo = JObject.FromObject(
new
{
recognizerResult,
luisModel = new
{
ModelID = Application.ApplicationId,
},
luisOptions = options,
luisResult = luisResponse,
});
await turnContext.TraceActivityAsync("LuisRecognizer", traceInfo, LuisTraceType, LuisTraceLabel, cancellationToken).ConfigureAwait(false);
return(recognizerResult);
}
