private void OnConverse(ConverseResponse resp)
{
foreach (string r in resp.response)
{
Debug.Log("Watson: " + r);
}
}
private static WitContext GetForecast(ConverseRequest request, ConverseResponse response)
{
var context = request.Context;
var entities = request.Entities;
var loc = FirstEntityValue(entities, "location");
if (loc != null)
{
context["forecast"] = "sunny";
if (context.ContainsKey("missingLocation"))
{
context.Remove("missingLocation");
}
}
else
{
context["missingLocation"] = true;
if (context.ContainsKey("forecast"))
{
context.Remove("forecast");
}
}
return(context);
}
private static WitContext Merge(ConverseRequest request, ConverseResponse response)
{
var context = request.Context;
var entities = request.Entities;
if (context.ContainsKey("joke"))
{
context.Remove("joke");
}
var category = FirstEntityValue(entities, "category");
if (category != null)
{
context["cat"] = category;
}
var sentiment = FirstEntityValue(entities, "sentiment");
if (sentiment != null)
{
context["ack"] = (sentiment.Equals("positive")) ? "Glad you liked it." : "Hmm.";
}
else if (context.ContainsKey("ack"))
{
context.Remove("ack");
}
return(context);
}
private void ConverseResp(RESTConnector.Request req, RESTConnector.Response resp)
{
ConverseResponse response = new ConverseResponse();
if (resp.Success)
{
try
{
fsData data = null;
fsResult r = fsJsonParser.Parse(Encoding.UTF8.GetString(resp.Data), out data);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
object obj = response;
r = sm_Serializer.TryDeserialize(data, obj.GetType(), ref obj);
if (!r.Succeeded)
{
throw new WatsonException(r.FormattedMessages);
}
}
catch (Exception e)
{
Log.Error("NLC", "ConverseResp Exception: {0}", e.ToString());
resp.Success = false;
}
}
if (((ConverseReq)req).Callback != null)
{
((ConverseReq)req).Callback(resp.Success ? response : null);
}
}
public Task <bool> SendMessageAsync(string q)
{
var t = Task.Factory.StartNew <bool>(() =>
{
ConverseResponse response = client.Converse(conversationId, q, context);
return(recurringConverse(response));
});
return(t);
}
private static WitContext SelectJoke(ConverseRequest request, ConverseResponse response)
{
var context = request.Context;
var jokes = allJokes[context["cat"] || "default"];
Shuffle(jokes);
context["joke"] = jokes[0];
return(context);
}
private async Task <bool> RecurringConverseAsync(ConverseResponse prevResponse)
{
var doOneMoreStep = false;
var tempContext = default(T);
switch (prevResponse.TypeCode)
{
case MessageTypes.Merge:
{
tempContext = this.merge.Invoke(conversationId, context, prevResponse.Entities, prevResponse.Confidence);
doOneMoreStep = true;
break;
}
case MessageTypes.Msg:
{
this.say.Invoke(conversationId, context, prevResponse.Msg, prevResponse.Confidence);
doOneMoreStep = true;
break;
}
case MessageTypes.Action:
{
tempContext = this.action.Invoke(conversationId, context, prevResponse.Action, prevResponse.Entities, prevResponse.Confidence);
doOneMoreStep = true;
break;
}
case MessageTypes.Stop:
{
tempContext = this.stop.Invoke(conversationId, context);
doOneMoreStep = false;
break;
}
default:
{
break;
}
}
if (tempContext != null)
{
context = tempContext;
}
if (doOneMoreStep)
{
ConverseResponse response = await client.ConverseAsync(conversationId, null, context);
return(await RecurringConverseAsync(response));
}
return(true);
}
private void OnConverse(ConverseResponse resp)
{
Test(resp != null);
if (resp != null)
{
m_ClientID = resp.client_id;
m_ConversationID = resp.conversation_id;
foreach (var r in resp.response)
{
Log.Debug("TestDialog", "Response: {0}", r);
}
}
m_ConverseTested = true;
}
private bool recurringConverse(ConverseResponse prevResponse)
{
bool doOneMoreStep = false;
T tempContext = default(T);
switch (prevResponse.typeCode)
{
case ConverseResponse.Types.merge:
tempContext = _merge.Invoke(conversationId, context, prevResponse.entities, prevResponse.confidence);
doOneMoreStep = true;
break;
case ConverseResponse.Types.msg:
_say.Invoke(conversationId, context, prevResponse.msg, prevResponse.confidence);
doOneMoreStep = true;
break;
case ConverseResponse.Types.action:
tempContext = _action.Invoke(conversationId, context, prevResponse.action, prevResponse.entities, prevResponse.confidence);
doOneMoreStep = true;
break;
case ConverseResponse.Types.stop:
tempContext = _stop.Invoke(conversationId, context);
doOneMoreStep = false;
break;
default:
break;
}
if (tempContext != null)
{
context = tempContext;
}
if (doOneMoreStep)
{
ConverseResponse response = client.Converse(conversationId, null, context);
return(recurringConverse(response));
}
return(true);
}
private void OnConverse(ConverseResponse resp)
{
if (resp != null)
{
m_ClientID = resp.client_id;
m_ConversationID = resp.conversation_id;
foreach (var r in resp.response)
{
Log.Debug("DialogWidget", "Response: {0}", r);
AddDialog(r, m_AnswerPrefab);
if (m_ResultOutput.IsConnected)
{
m_ResultOutput.SendData(new TextToSpeechData(r));
}
}
}
}
private string ResponseToOutput(ConverseResponse currentResponse)
{
if (currentResponse.AudioOut != null)
{
return($"Response - AudioOut {currentResponse.AudioOut.AudioData.Length}");
}
if (currentResponse.Error != null)
{
return($"Response - Error:{currentResponse.Error}");
}
if (currentResponse.Result != null)
{
return($"Response - Result:{currentResponse.Result}");
}
if (currentResponse.EventType != ConverseResponse.Types.EventType.Unspecified)
{
return($"Response - EventType:{currentResponse.EventType}");
}
return("Response Empty?");
}
/// <summary>
/// Returns what your bot should do next. The next step can be either answering to the user, performing an action, or waiting for further requests.
/// </summary>
/// <param name="sessionId">A specific ID of your choosing representing the session your query belongs to</param>
/// <param name="message">A message from the user</param>
/// <param name="context">Chat context</param>
/// <param name="verbose">Calls the API in verbose mode</param>
/// <returns <see cref="ConverseResponse"/>>Converse response</returns>
public ConverseResponse Converse(string sessionId, string message, WitContext context, bool verbose = true)
{
if (context == null)
{
context = new WitContext();
}
var request = new RestRequest("converse", Method.POST);
request.AddJsonBody(context);
if (message != null)
{
request.AddQueryParameter("q", message);
}
request.AddQueryParameter("session_id", sessionId);
IRestResponse responseObject = client.Execute(request);
ConverseResponse response = JsonConvert.DeserializeObject <ConverseResponse>(responseObject.Content);
return(response);
}
public async Task <ConverseResponse> ConverseAsync(ConverseRequest req)
{
ConverseResponse res = null;
using (var client = new HttpClient())
{
client.BaseAddress = this.hostUri;
client.DefaultRequestHeaders.Accept.Clear();
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("application/json"));
var content = JsonConvert.SerializeObject(req);
// HTTP POST
HttpResponseMessage response = await client.PostAsync("AlmeApi/api/Conversation/converse", new StringContent(content, Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
string data = await response.Content.ReadAsStringAsync();
res = JsonConvert.DeserializeObject <ConverseResponse>(data);
}
}
return(res);
}
BotResponse _RunActions(string sessionId, int currentRequest,
string message, BotResponse response, int maxSteps = 5, bool verbose = true)
{
if (maxSteps <= 0)
{
throw new WitException("Max steps reached, stopping.");
}
var json = Converse(sessionId, message, response.Context, verbose);
if (json.Type == null)
{
throw new WitException("Couldn\'t find type in Wit response");
}
if (currentRequest != sessions[sessionId])
{
return(response);
}
// backwards-compatibility with API version 20160516
if (json.Type == "merge")
{
json.Type = "action";
json.Action = "merge";
}
if (json.Type == "error")
{
throw new Exception("Oops, I don\'t know what to do.");
}
if (json.Type == "stop")
{
return(response);
}
var request = new ConverseRequest();
request.SessionId = sessionId;
request.Context = response.Context;
request.Message = message;
request.Entities = json.Entities;
switch (json.Type)
{
case "msg":
ThrowIfActionMissing("send");
var converseResponse = new ConverseResponse();
converseResponse.Msg = json.Msg;
converseResponse.QuickReplies = json.QuickReplies;
// SDK is able to handle multiple bot responses at the same time
response.Messages.Add(converseResponse.Msg);
actions["send"](request, converseResponse);
// actions["send"](request);
break;
case "action":
var action = json.Action;
ThrowIfActionMissing(action);
response.Context = actions[action](request, null);
// context = this.actions[action](request);
if (response.Context == null)
{
Console.WriteLine("missing context - did you forget to return it?");
response.Context = new WitContext();
}
break;
default:
throw new WitException($"unknown type: {json.Type}");
}
if (currentRequest != sessions[sessionId])
{
return(response);
}
return(_RunActions(sessionId, currentRequest, null, response, maxSteps - 1, verbose));
}
private static WitContext Send(ConverseRequest request, ConverseResponse response)
{
Console.WriteLine(response.Msg);
return(request.Context);
}
public async Task <bool> SendMessageAsync(string q)
{
ConverseResponse response = await client.ConverseAsync(conversationId, q, context);
return(await RecurringConverseAsync(response));
}
private async Task WaitForResponse()
{
var response = await _responseStream.MoveNext();
if (response)
{
// multiple response elements are received per response, each can contain one of the Result, AudioOut or EventType fields
ConverseResponse currentResponse = _responseStream.Current;
// Debug output the whole response, useful for.. debugging.
OnDebug?.Invoke(ResponseToOutput(currentResponse));
// EndOfUtterance, Assistant has recognised something so stop sending audio
if (currentResponse.EventType == ConverseResponse.Types.EventType.EndOfUtterance)
{
ResetSendingAudio(false);
}
if (currentResponse.AudioOut != null)
{
_audioOut.AddBytesToPlay(currentResponse.AudioOut.AudioData.ToByteArray());
}
if (currentResponse.Result != null)
{
// if the assistant has recognised something, flag this so the failure notification isn't played
if (!String.IsNullOrEmpty(currentResponse.Result.SpokenRequestText))
{
_assistantResponseReceived = true;
}
switch (currentResponse.Result.MicrophoneMode)
{
// this is the end of the current conversation
case ConverseResult.Types.MicrophoneMode.CloseMicrophone:
StopRecording();
// play failure notification if nothing recognised.
if (!_assistantResponseReceived)
{
_audioOut.PlayNegativeNotification();
OnAssistantStateChanged?.Invoke(AssistantState.Inactive);
}
break;
case ConverseResult.Types.MicrophoneMode.DialogFollowOn:
// stop recording as the follow on is in a whole new conversation, so may as well restart the same flow
StopRecording();
_followOn = true;
break;
}
}
await WaitForResponse();
}
else
{
OnDebug?.Invoke("Response End");
// if we've received any audio... play it.
_audioOut.Play();
}
}
//public void Converse(string msg)
//{
// var res = _witClient.Converse(_sessionId, msg, new WitContext());
//}
WitContext Send(ConverseRequest request, ConverseResponse response)
{
Console.WriteLine(request.Message);
return request.Context;
}
WitContext TellTheTime(ConverseRequest request, ConverseResponse response)
{
request.Context.Add("currentTime", DateTime.Now.ToShortTimeString());
return request.Context;
}
private static WitContext Send(ConverseRequest request, ConverseResponse response)
{
// Do something with the Context
Console.WriteLine("Yay, got Wit.ai context: " + request.Context);
return(request.Context);
}
