private async Task ProcessRecognitionResultsAsync(SpeechRecognitionResult results, RequestExtras requestExtras)
{
if (!string.IsNullOrWhiteSpace(results.Text))
{
var request = new AIRequest();
request.Query = new[] { results.Text };
try
{
request.Confidence = new[] { Convert.ToSingle(results.RawConfidence) };
}
catch
{
}
try
{
if (requestExtras != null)
{
requestExtras.CopyTo(request);
}
var response = await dataService.RequestAsync(request);
FireOnResult(response);
}
catch (Exception e)
{
FireOnError(new AIServiceException(e));
}
}
}
private AIRequest CreateAIRequest(SpeechRecognitionResult recognitionResults)
{
var texts = new List <string> {
recognitionResults.Text
};
var confidences = new List <float> {
ConfidenceToFloat(recognitionResults.Confidence)
};
var aiRequest = new AIRequest();
var alternates = recognitionResults.GetAlternates(5);
if (alternates != null)
{
foreach (var a in alternates)
{
texts.Add(a.Text);
confidences.Add(ConfidenceToFloat(a.Confidence));
}
}
aiRequest.Query = texts.ToArray();
aiRequest.Confidence = confidences.ToArray();
return(aiRequest);
}
public async Task SessionTest()
{
var config = new AIConfiguration(SUBSCRIPTION_KEY, ACCESS_TOKEN, SupportedLanguage.English);
var firstService = new AIDataService(config);
var secondService = new AIDataService(config);
{
var weatherRequest = new AIRequest("weather");
var weatherResponse = await MakeRequestAsync(firstService, weatherRequest);
Assert.IsNotNull(weatherResponse);
}
{
var checkSecondRequest = new AIRequest("check weather");
var checkSecondResponse = await MakeRequestAsync(secondService, checkSecondRequest);
Assert.IsTrue(string.IsNullOrEmpty(checkSecondResponse.Result.Action));
}
{
var checkFirstRequest = new AIRequest("check weather");
var checkFirstResponse = await MakeRequestAsync(firstService, checkFirstRequest);
Assert.IsNotNull(checkFirstResponse.Result.Action);
Assert.IsTrue(checkFirstResponse.Result.Action.Equals("checked", StringComparison.CurrentCultureIgnoreCase));
}
}
public AIResponse TextRequest(AIRequest request)
{
var preditor = new BotPredictor();
var doc = preditor.Predict(agent, request).Result;
var parameters = new Dictionary <String, Object>();
doc.Sentences[0].Entities.ForEach(x => parameters.Add(x.Entity, x.Value));
return(new AIResponse
{
Lang = request.Language,
Timestamp = DateTime.UtcNow,
SessionId = request.SessionId,
Status = new AIResponseStatus(),
Result = new AIResponseResult
{
Score = doc.Sentences[0].Intent == null ? 0 : doc.Sentences[0].Intent.Confidence,
ResolvedQuery = doc.Sentences[0].Text,
Fulfillment = new AIResponseFulfillment {
},
Parameters = parameters,
Metadata = new AIResponseMetadata
{
IntentName = doc.Sentences[0].Intent?.Label
}
}
});
}
public AIResponse VoiceRequest(Stream voiceStream, RequestExtras requestExtras = null)
{
var request = new AIRequest();
request.Language = config.Language.code;
request.Timezone = TimeZone.CurrentTimeZone.StandardName;
request.SessionId = sessionId;
if (requestExtras != null)
{
requestExtras.CopyTo(request);
}
try
{
var httpRequest = (HttpWebRequest)WebRequest.Create(config.RequestUrl);
httpRequest.Method = "POST";
httpRequest.Accept = "application/json";
httpRequest.Headers.Add("Authorization", "Bearer " + config.ClientAccessToken);
httpRequest.Headers.Add("ocp-apim-subscription-key", config.SubscriptionKey);
var jsonSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
};
var jsonRequest = JsonConvert.SerializeObject(request, Formatting.None, jsonSettings);
if (config.DebugLog)
{
Debug.WriteLine("Request: " + jsonRequest);
}
var multipartClient = new MultipartHttpClient(httpRequest);
multipartClient.connect();
multipartClient.addStringPart("request", jsonRequest);
multipartClient.addFilePart("voiceData", "voice.wav", voiceStream);
multipartClient.finish();
var responseJsonString = multipartClient.getResponse();
if (config.DebugLog)
{
Debug.WriteLine("Response: " + responseJsonString);
}
var aiResponse = JsonConvert.DeserializeObject <AIResponse>(responseJsonString);
CheckForErrors(aiResponse);
return(aiResponse);
}
catch (Exception e)
{
throw new AIServiceException(e);
}
}
public async Task WrongEntitiesTest()
{
var config = new AIConfiguration(ACCESS_TOKEN, SupportedLanguage.English);
var dataService = new AIDataService(config);
var aiRequest = new AIRequest("hi nori");
var myDwarfs = new Entity("not_dwarfs");
myDwarfs.AddEntry(new EntityEntry("Ori", new[] { "ori", "Nori" }));
myDwarfs.AddEntry(new EntityEntry("bifur", new[] { "Bofur", "Bombur" }));
var extraEntities = new List <Entity> {
myDwarfs
};
aiRequest.Entities = extraEntities;
try
{
var aiResponse = await MakeRequestAsync(dataService, aiRequest);
Assert.IsTrue(false, "Request should throws bad_request exception");
}
catch (AIServiceException e)
{
Assert.IsTrue(true);
}
}
private void UpdateAndroidResult()
{
var wrapper = androidResultWrapper;
if (wrapper.IsReady)
{
var recognitionResult = wrapper.GetResult();
androidResultWrapper = null;
androidRecognizer.Clean();
if (recognitionResult.IsError)
{
FireOnError(new Exception(recognitionResult.ErrorMessage));
}
else
{
var request = new AIRequest
{
Query = recognitionResult.RecognitionResults,
Confidence = recognitionResult.Confidence
};
for (int i = 0; i < recognitionResult.RecognitionResults.Length; i++)
{
Debug.Log("Speech recognize: " + recognitionResult.RecognitionResults[i] + " " + recognitionResult.Confidence[i]);
}
d_OnNativeResult(recognitionResult.RecognitionResults, recognitionResult.Confidence);
//var aiResponse = apiAi.TextRequest(request);
//ProcessResult(aiResponse);
}
}
}
public AIResponse TextRequest(AIRequest request)
{
var preditor = new BotPreditor();
var text = preditor.Predict(agent, request);
return(null);
}
private void UpdateAndroidResult()
{
Debug.Log("UpdateAndroidResult");
var wrapper = androidResultWrapper;
if (wrapper.IsReady)
{
var recognitionResult = wrapper.GetResult();
androidResultWrapper = null;
androidRecognizer.Clean();
if (recognitionResult.IsError)
{
FireOnError(new Exception(recognitionResult.ErrorMessage));
}
else
{
var request = new AIRequest {
Query = recognitionResult.RecognitionResults,
Confidence = recognitionResult.Confidence
};
var aiResponse = apiAi.TextRequest(request);
ProcessResult(aiResponse);
}
}
}
public void InputContextLifespanTest()
{
var dataService = CreateDataService();
var aiRequest = new AIRequest("and for tomorrow");
var aiContext = new AIContext
{
Name = "weather",
Parameters = new Dictionary <string, string>
{
{ "location", "London" }
},
Lifespan = 3
};
aiRequest.Contexts =
new List <AIContext>
{
aiContext
};
var response = MakeRequest(dataService, aiRequest);
Assert.IsNotNull(response.Result.GetContext("weather"));
for (int i = 0; i < 2; i++)
{
response = MakeRequest(dataService, new AIRequest("next request"));
}
Assert.IsNotNull(response.Result.GetContext("weather"));
response = MakeRequest(dataService, new AIRequest("next request"));
Assert.IsNull(response.Result.GetContext("weather"));
}
public AiResponseExtract ProcessUserRequest(Conversation conversation, UserRequest userRequest)
{
AiResponseExtract response = new AiResponseExtract();
AIRequest aiRequest = new AIRequest(userRequest.Body);
AIContext aiContext = new AIContext()
{
Name = conversation.CurrentMessage.Name
};
aiRequest.Contexts = new List <AIContext>()
{
aiContext
};
AIResponse aiResponse = apiAi.TextRequest(aiRequest);
response.Intent = aiResponse.Result.Action;
if (aiResponse.Result.Action.Contains("smalltalk"))
{
response.SmallTalk = true;
}
response.Speech = aiResponse.Result.Fulfillment.Speech;
return(response);
}
public void SessionTest()
{
var config = new AIConfiguration(ACCESS_TOKEN, SupportedLanguage.English);
var firstService = new AIDataService(config);
var secondService = new AIDataService(config);
{
var weatherRequest = new AIRequest("weather");
var weatherResponse = MakeRequest(firstService, weatherRequest);
Assert.IsNotNull(weatherResponse);
}
{
var checkSecondRequest = new AIRequest("check weather");
var checkSecondResponse = MakeRequest(secondService, checkSecondRequest);
Assert.IsEmpty(checkSecondResponse.Result.Action);
}
{
var checkFirstRequest = new AIRequest("check weather");
var checkFirstResponse = MakeRequest(firstService, checkFirstRequest);
Assert.IsNotNull(checkFirstResponse.Result.Action);
Assert.IsTrue(checkFirstResponse.Result.Action.Equals("checked", StringComparison.InvariantCultureIgnoreCase));
}
}
public async Task DifferentAgentsTest()
{
var query = "I want pizza";
{
var config = new AIConfiguration(ACCESS_TOKEN, SupportedLanguage.English);
var dataService = new AIDataService(config);
var request = new AIRequest(query);
var response = await dataService.RequestAsync(request);
Assert.IsNotNull(response.Result);
Assert.AreEqual("pizza", response.Result.Action);
}
{
var config = new AIConfiguration("968235e8e4954cf0bb0dc07736725ecd", SupportedLanguage.English);
var dataService = new AIDataService(config);
var request = new AIRequest(query);
var response = await dataService.RequestAsync(request);
Assert.IsNotNull(response.Result);
Assert.IsTrue(string.IsNullOrEmpty(response.Result.Action));
}
}
public async Task <AIResponse> RequestAsync(AIRequest request, CancellationToken cancellationToken)
{
request.Language = config.Language.code;
request.Timezone = TimeZoneInfo.Local.StandardName;
request.SessionId = sessionId;
try
{
var jsonRequest = JsonConvert.SerializeObject(request, Formatting.None, jsonSettings);
if (config.DebugLog)
{
Debug.WriteLine($"Request: {jsonRequest}");
}
var content = new HttpStringContent(jsonRequest, UnicodeEncoding.Utf8, "application/json");
var response = await httpClient.PostAsync(new Uri(config.RequestUrl), content).AsTask(cancellationToken);
return(await ProcessResponse(response));
}
catch (AIServiceException)
{
throw;
}
catch (Exception e)
{
throw new AIServiceException(e);
}
}
public async Task <AIResponse> RequestAsync(AIRequest request)
{
request.Language = config.Language.code;
request.Timezone = TimeZoneInfo.Local.StandardName;
request.SessionId = sessionId;
try
{
var httpRequest = (HttpWebRequest)WebRequest.Create(config.RequestUrl);
httpRequest.Method = "POST";
httpRequest.ContentType = "application/json; charset=utf-8";
httpRequest.Accept = "application/json";
httpRequest.Headers["Authorization"] = "Bearer " + config.ClientAccessToken;
httpRequest.Headers["ocp-apim-subscription-key"] = config.SubscriptionKey;
var jsonSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
};
var jsonRequest = JsonConvert.SerializeObject(request, Formatting.None, jsonSettings);
if (config.DebugLog)
{
Debug.WriteLine("Request: " + jsonRequest);
}
var requestStream = await httpRequest.GetRequestStreamAsync();
using (var streamWriter = new StreamWriter(requestStream))
{
streamWriter.Write(jsonRequest);
streamWriter.Dispose();
}
var httpResponse = await httpRequest.GetResponseAsync() as HttpWebResponse;
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
if (config.DebugLog)
{
Debug.WriteLine("Response: " + result);
}
var aiResponse = JsonConvert.DeserializeObject <AIResponse>(result);
CheckForErrors(aiResponse);
return(aiResponse);
}
}
catch (Exception e)
{
throw new AIServiceException(e);
}
}
public AIResponse TextRequest(AIRequest request)
{
AIResponse aiResponse = new AIResponse();
string model = RasaRequestExtension.GetModelPerContexts(agent, AiConfig, request, dc);
var result = CallRasa(agent.Id, request.Query.First(), model);
result.Content.Log();
RasaResponse response = result.Data;
aiResponse.Id = Guid.NewGuid().ToString();
aiResponse.Lang = agent.Language;
aiResponse.Status = new AIResponseStatus {
};
aiResponse.SessionId = AiConfig.SessionId;
aiResponse.Timestamp = DateTime.UtcNow;
var intentResponse = RasaRequestExtension.HandleIntentPerContextIn(agent, AiConfig, request, result.Data, dc);
RasaRequestExtension.HandleParameter(agent, intentResponse, response, request);
RasaRequestExtension.HandleMessage(intentResponse);
aiResponse.Result = new AIResponseResult
{
Source = "agent",
ResolvedQuery = request.Query.First(),
Action = intentResponse?.Action,
Parameters = intentResponse?.Parameters?.ToDictionary(x => x.Name, x => (object)x.Value),
Score = response.Intent.Confidence,
Metadata = new AIResponseMetadata {
IntentId = intentResponse?.IntentId, IntentName = intentResponse?.IntentName
},
Fulfillment = new AIResponseFulfillment
{
Messages = intentResponse?.Messages?.Select(x => {
if (x.Type == AIResponseMessageType.Custom)
{
return((new
{
x.Type,
Payload = JsonConvert.DeserializeObject(x.PayloadJson)
}) as Object);
}
else
{
return((new { x.Type, x.Speech }) as Object);
}
}).ToList()
}
};
RasaRequestExtension.HandleContext(dc, AiConfig, intentResponse, aiResponse);
Console.WriteLine(JsonConvert.SerializeObject(aiResponse.Result));
return(aiResponse);
}
public AIResponse TextRequest(AIRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
return(dataService.Request(request));
}
public async Task <AIResponse> TextRequestAsync(AIRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
return(await dataService.RequestAsync(request));
}
public AIResponse Request(AIRequest request)
{
request.Language = config.Language.code;
request.Timezone = TimeZone.CurrentTimeZone.StandardName;
request.SessionId = SessionId;
try
{
var httpRequest = (HttpWebRequest)WebRequest.Create(config.RequestUrl);
httpRequest.Method = "POST";
httpRequest.ContentType = "application/json; charset=utf-8";
httpRequest.Accept = "application/json";
httpRequest.Headers.Add("Authorization", "Bearer " + config.ClientAccessToken);
var jsonSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
var jsonRequest = JsonConvert.SerializeObject(request, Formatting.None, jsonSettings);
if (config.DebugLog)
{
Debug.WriteLine("Request: " + jsonRequest);
}
using (var streamWriter = new StreamWriter(httpRequest.GetRequestStream()))
{
streamWriter.Write(jsonRequest);
streamWriter.Close();
}
var httpResponse = httpRequest.GetResponse() as HttpWebResponse;
using (var streamReader = new StreamReader(httpResponse.GetResponseStream()))
{
var result = streamReader.ReadToEnd();
if (config.DebugLog)
{
Debug.WriteLine("Response: " + result);
}
var aiResponse = JsonConvert.DeserializeObject <AIResponse>(result);
CheckForErrors(aiResponse);
return(aiResponse);
}
}
catch (Exception e)
{
throw new AIServiceException(e);
}
}
private async Task <AIResponse> MakeRequestAsync(AIDataService service, AIRequest request)
{
var aiResponse = await service.RequestAsync(request);
Assert.IsNotNull(aiResponse);
Assert.IsFalse(aiResponse.IsError);
Assert.IsFalse(string.IsNullOrEmpty(aiResponse.Id));
Assert.IsNotNull(aiResponse.Result);
return(aiResponse);
}
private AIResponse MakeRequest(AIDataService service, AIRequest request)
{
var aiResponse = service.Request(request);
Assert.IsNotNull(aiResponse);
Assert.IsFalse(aiResponse.IsError);
Assert.IsFalse(string.IsNullOrEmpty(aiResponse.Id));
Assert.IsNotNull(aiResponse.Result);
return(aiResponse);
}
static void WaitText()
{
string text = Console.ReadLine();
RequestExtras extras = new RequestExtras();
AIRequest request = new AIRequest(text);
request.SessionId = _SessionId;
AIResponse response = _ApiAi.TextRequest(request);
HandleResponse(response);
}
public static string getDialogflow(Request request)
{
var config = new AIConfiguration(accessToken, SupportedLanguage.English);
var dataService = new AIDataService(config);
var aiRequest = new AIRequest(request.Message);
var aiResponse = dataService.Request(aiRequest);
var dialogflowresult = aiResponse.Result.Fulfillment.Speech;
return(dialogflowresult);
}
public void TextRequestTest()
{
var dataService = CreateDataService();
var request = new AIRequest("Hello");
var response = dataService.Request(request);
Assert.IsNotNull(response);
Assert.AreEqual("greeting", response.Result.Action);
Assert.AreEqual("Hi! How are you?", response.Result.Fulfillment.Speech);
}
public void CopyTo(AIRequest request)
{
if (HasContexts)
{
request.Contexts = Contexts;
}
if (HasEntities)
{
request.Entities = Entities;
}
}
public async Task TestTextRequest()
{
var config = new AIConfiguration(ACCESS_TOKEN, SupportedLanguage.English);
var dataService = new AIDataService(config);
var request = new AIRequest("Hello");
var response = await dataService.RequestAsync(request);
Assert.IsNotNull(response);
Assert.AreEqual("greeting", response.Result.Action);
Assert.AreEqual("Hi! How are you?", response.Result.Fulfillment.Speech);
}
public void TextRequestStart(AIRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
AIResponseList = new List <AIResponse>();
for (var i = 0; i < m; i++)
{
tasks[i] = Task.Factory.StartNew(() => TextRequestExecAsync(request));
}
}
public void ContextsTest()
{
var dataService = CreateDataService();
var aiRequest = new AIRequest("weather");
dataService.ResetContexts();
var aiResponse = MakeRequest(dataService, aiRequest);
var action = aiResponse.Result.Action;
Assert.AreEqual("showWeather", action);
Assert.IsTrue(aiResponse.Result.Contexts.Any(c => c.Name == "weather"));
}
public void TextAIRequestTest()
{
var config = new AIConfiguration(ACCESS_TOKEN, SupportedLanguage.English);
var apiAi = new ApiAi(config);
var request = new AIRequest("hello");
var response = apiAi.TextRequest(request);
Assert.IsNotNull(response);
Assert.AreEqual("greeting", response.Result.Action);
Assert.AreEqual("Hi! How are you?", response.Result.Fulfillment.Speech);
}
public bool ResetContexts()
{
var cleanRequest = new AIRequest("empty_query_for_resetting_contexts");
cleanRequest.ResetContexts = true;
try {
var response = Request(cleanRequest);
return(!response.IsError);
} catch (AIServiceException e) {
Debug.WriteLine("Exception while contexts clean." + e);
return(false);
}
}
