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); }