From d2be98ee2a7de16fafa8479ae51c3a5a8ae11a11 Mon Sep 17 00:00:00 2001 From: kami Date: Fri, 31 Jul 2026 12:31:55 +0400 Subject: [PATCH] Say out loud when she gives up instead of dropping the request MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit An unclear answer used to end the request on the spot. Now she re-asks the same question while attempts remain, and when they run out she says "Прости, я не поняла. Скажи, пожалуйста, по-другому." — silence would leave him thinking it was handled. Same reply when the missing slot has no question to ask, and as a floor in finishClarified so an empty reply can never ship. Tests: three questions allowed, the fourth gives up out loud, the cap is configurable, and a restated time is the one that lands. Co-Authored-By: Claude Opus 5 Claude-Session: https://claude.ai/code/session_01CGeSZxh1DCtRxmFVSYVGvJ --- cmd/mavend/clarify.go | 61 ++++++++++++++++++++-------- cmd/mavend/clarify_test.go | 83 +++++++++++++++++++++++++++++++++----- cmd/mavend/voice.go | 14 +++++-- 3 files changed, 126 insertions(+), 32 deletions(-) diff --git a/cmd/mavend/clarify.go b/cmd/mavend/clarify.go index 4d4a3f1..22266e7 100644 --- a/cmd/mavend/clarify.go +++ b/cmd/mavend/clarify.go @@ -40,9 +40,10 @@ var clarifyQuestions = map[dialogue.Slot]string{ dialogue.SlotFn: "Что сделать?", } -// clarifyDropped — she asked once, the answer still did not fill the gap, so -// the request is gone. Said plainly, once, with no second question. -const clarifyDropped = "Не разобрала — скажи целиком, пожалуйста." +// clarifyGaveUp — she is out of questions and still does not have the slot. She +// says so out loud: dropping the request in silence would leave him thinking it +// landed. Feminine self-reference ("поняла"), as everywhere. +const clarifyGaveUp = "Прости, я не поняла. Скажи, пожалуйста, по-другому." // missingFor returns the slots a decision still needs, most important first. // Empty ⇒ there is nothing identifiable to ask about. @@ -79,13 +80,14 @@ func (h *reactiveHandler) askClarify(dec router.Decision) (string, bool) { return "", false } h.clarifyStore.Put(voiceDialogueID, &dialogue.PendingQuestion{ - Intent: dialogue.Intent(dec.Intent), - Slots: toDialogueSlots(dec.Slots), - Missing: []dialogue.Slot{slot}, - Utterance: dec.Utterance, - Asked: h.now(), - TTL: clarifyTTL, - Attempts: 1, // asked once; MaxAttempts is 1, so there is no second ask + Intent: dialogue.Intent(dec.Intent), + Slots: toDialogueSlots(dec.Slots), + Missing: []dialogue.Slot{slot}, + Utterance: dec.Utterance, + Asked: h.now(), + TTL: clarifyTTL, + Attempts: 1, // this ask + MaxAttempts: h.clarifyMaxAttempts, }) log.Printf("voice: clarify — asked about %s for intent=%s", slot, dec.Intent) return question, true @@ -97,8 +99,9 @@ func (h *reactiveHandler) askClarify(dec router.Decision) (string, bool) { // resolveConfirm and checked in the same place. // // The answer is parsed with the same extractor the router uses, for the intent -// she parked — no second parser. If it still does not fill the gap the request -// is dropped: she does not ask again. +// she parked — no second parser. If it still does not fill the gap she asks +// again, up to MaxAttempts; after that she says out loud that she did not +// understand. She never drops the request in silence. func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string) (string, bool) { if h.clarifyStore == nil { return "", false @@ -107,17 +110,14 @@ func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string) if q == nil { return "", false } - // One shot either way: the question is consumed whether or not the answer - // works, so a failed answer can't leave the question armed. - h.clarifyStore.Delete(voiceDialogueID) intent := router.Intent(q.Intent) answer := h.extractor.Extract(ctx, intent, text, h.now()) merged := q.Answer(text, toDialogueSlots(answer)) if len(dialogue.StillMissing(q.Missing, merged)) > 0 { - log.Printf("voice: clarify — answer %q did not fill %v, dropping", text, q.Missing) - return clarifyDropped, true + return h.reaskOrGiveUp(q, merged, text), true } + h.clarifyStore.Delete(voiceDialogueID) // Rebuild the decision as if it had routed cleanly, then run it down the // normal path. Clarify is deliberately false and the intent is unchanged: @@ -133,6 +133,29 @@ func (h *reactiveHandler) resolveClarifyAnswer(ctx context.Context, text string) return h.finishClarified(ctx, dec), true } +// reaskOrGiveUp handles an answer that left the gap open: ask the same question +// again while she has attempts left, otherwise say she did not understand and +// let the request go. Never returns "" — a mute give-up reads as "done". +func (h *reactiveHandler) reaskOrGiveUp(q *dialogue.PendingQuestion, merged dialogue.Slots, text string) string { + question := "" + if len(q.Missing) > 0 { + question = clarifyQuestions[q.Missing[0]] + } + if question == "" || !q.CanAsk() { + h.clarifyStore.Delete(voiceDialogueID) + log.Printf("voice: clarify — gave up on %v after %d question(s), answer was %q", q.Missing, q.Attempts, text) + return clarifyGaveUp + } + // Re-park with whatever the answer DID give, the clock restarted and one + // more question spent. + q.Slots = merged + q.Attempts++ + q.Asked = h.now() + h.clarifyStore.Put(voiceDialogueID, q) + log.Printf("voice: clarify — answer %q did not fill %v, asking again (attempt %d)", text, q.Missing, q.Attempts) + return question +} + // finishClarified runs a completed decision through the same steps a freshly // routed one takes: remember the turn, act, then phrase. func (h *reactiveHandler) finishClarified(ctx context.Context, dec router.Decision) string { @@ -146,6 +169,10 @@ func (h *reactiveHandler) finishClarified(ctx context.Context, dec router.Decisi if reply == "" { reply = h.replier.Reply(dec) } + if reply == "" { + // Belt: an empty reply here would be a silent drop. + reply = clarifyGaveUp + } return reply } diff --git a/cmd/mavend/clarify_test.go b/cmd/mavend/clarify_test.go index d83ec68..31178bc 100644 --- a/cmd/mavend/clarify_test.go +++ b/cmd/mavend/clarify_test.go @@ -86,7 +86,7 @@ func TestClarifyReminderCompletesOnAnswer(t *testing.T) { if !handled { t.Fatal("the answer to an open question must be consumed as an answer") } - if reply == clarifyDropped { + if reply == clarifyGaveUp { t.Fatalf("a good answer must not drop the request: %q", reply) } @@ -111,7 +111,7 @@ func TestClarifyFactCompletesOnAnswer(t *testing.T) { if _, asked := h.askClarify(clarifyDec(router.IntentFact, router.Slots{Text: "запиши"}, "запиши")); !asked { t.Fatal("a fact with no key should be asked about") } - if reply, handled := h.resolveClarifyAnswer(ctx, "пил воду"); !handled || reply == clarifyDropped { + if reply, handled := h.resolveClarifyAnswer(ctx, "пил воду"); !handled || reply == clarifyGaveUp { t.Fatalf("answer should complete the fact, handled=%v reply=%q", handled, reply) } if fact, err := st.LatestFact(ctx, "water"); err != nil || fact.Key != "water" { @@ -137,26 +137,87 @@ func TestClarifyAnswerAfterTTLIsANewRequest(t *testing.T) { } } -// TestClarifyUnclearAnswerDropsWithoutAskingAgain — MaxAttempts is 1. -func TestClarifyUnclearAnswerDropsWithoutAskingAgain(t *testing.T) { +// TestClarifyAsksThreeTimesThenSaysSo — three questions are allowed, the fourth +// is not, and running out is SPOKEN. Silence would read as "handled". +func TestClarifyAsksThreeTimesThenSaysSo(t *testing.T) { ctx := context.Background() h, st, _ := newClarifyHandler(t) if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked { - t.Fatal("expected a question") + t.Fatal("expected a first question") } + // Two more unclear answers ⇒ two more questions (3 asks in total). + for i := 2; i <= 3; i++ { + reply, handled := h.resolveClarifyAnswer(ctx, "ну не знаю") + if !handled { + t.Fatalf("answer %d must be consumed as an answer", i) + } + if reply != "На когда напомнить?" { + t.Fatalf("attempt %d should ask again, got %q", i, reply) + } + if h.clarifyStore.Get(voiceDialogueID, h.now()) == nil { + t.Fatalf("attempt %d must leave the question armed", i) + } + } + reply, handled := h.resolveClarifyAnswer(ctx, "ну не знаю") - if !handled || reply != clarifyDropped { - t.Fatalf("an unclear answer should drop the request, handled=%v reply=%q", handled, reply) + if !handled || reply != clarifyGaveUp { + t.Fatalf("the fourth try must give up out loud, handled=%v reply=%q", handled, reply) } - if strings.Contains(reply, "?") { - t.Fatalf("she must not ask a second question: %q", reply) + if reply == "" || strings.Contains(reply, "?") { + t.Fatalf("giving up must be spoken and must not be another question: %q", reply) } if h.clarifyStore.Get(voiceDialogueID, h.now()) != nil { - t.Fatal("a dropped request must leave no armed question") + t.Fatal("a given-up request must leave no armed question") } if reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour)); err != nil || len(reminders) != 0 { - t.Fatalf("a dropped request must not create anything: reminders=%v err=%v", reminders, err) + t.Fatalf("a given-up request must not create anything: reminders=%v err=%v", reminders, err) + } +} + +// TestClarifyMaxAttemptsIsConfigurable — one question when the config says one. +func TestClarifyMaxAttemptsIsConfigurable(t *testing.T) { + ctx := context.Background() + h, _, _ := newClarifyHandler(t) + h.clarifyMaxAttempts = 1 + + if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{Text: "напомни"}, "напомни")); !asked { + t.Fatal("expected a question") + } + if reply, handled := h.resolveClarifyAnswer(ctx, "ну не знаю"); !handled || reply != clarifyGaveUp { + t.Fatalf("with max 1 she must give up at once, handled=%v reply=%q", handled, reply) + } +} + +// TestClarifyRestatedAnswerWins — «в 11:00», then «нет, в 15:00». The second +// value is the one that lands. +func TestClarifyRestatedAnswerWins(t *testing.T) { + ctx := context.Background() + h, st, _ := newClarifyHandler(t) + + if _, asked := h.askClarify(clarifyDec(router.IntentReminder, router.Slots{Text: "напомни позвонить маме"}, "напомни позвонить маме")); !asked { + t.Fatal("expected a question") + } + // First answer parses, but re-park it by hand as if she had asked again: + // what matters here is that Answer prefers the newer value over the parked + // one, which is the case the daemon hits on a re-ask. + q := h.clarifyStore.Get(voiceDialogueID, h.now()) + if q == nil { + t.Fatal("expected an armed question") + } + first := h.extractor.Extract(ctx, router.IntentReminder, "в 11:00", h.now()) + q.Slots = q.Answer("в 11:00", toDialogueSlots(first)) + + if reply, handled := h.resolveClarifyAnswer(ctx, "нет, в 15:00"); !handled || reply == clarifyGaveUp { + t.Fatalf("the restated answer should complete the request, handled=%v reply=%q", handled, reply) + } + reminders, err := st.DueReminders(ctx, h.now().Add(48*time.Hour)) + if err != nil || len(reminders) != 1 { + t.Fatalf("expected one reminder: %v err=%v", reminders, err) + } + want := h.extractor.Extract(ctx, router.IntentReminder, "в 15:00", h.now()) + if !reminders[0].FireTs.Equal(want.Time) { + t.Fatalf("reminder at %v, want the restated %v", reminders[0].FireTs, want.Time) } } diff --git a/cmd/mavend/voice.go b/cmd/mavend/voice.go index 8e59a86..c7571c7 100644 --- a/cmd/mavend/voice.go +++ b/cmd/mavend/voice.go @@ -253,10 +253,12 @@ func wireVoice(cfg *config.Config, coreAPI ipc.CoreAPI, phr phraser.Phraser, mem dataStore: dataStore, dialogueSessions: dialogueSessions, clarifyStore: clarifyStore, - extractor: router.Extractor{Time: timeParser, Acts: matcher, Facts: router.DefaultFactParser{}}, - queryMinScore: cfg.Voice.QueryMinScore, - timeParser: timeParser, - ecosystem: eco, + // 0 here (unset config) ⇒ the dialogue default. + clarifyMaxAttempts: cfg.Voice.ClarifyMaxAttempts, + extractor: router.Extractor{Time: timeParser, Acts: matcher, Facts: router.DefaultFactParser{}}, + queryMinScore: cfg.Voice.QueryMinScore, + timeParser: timeParser, + ecosystem: eco, } // ----- the server (TCP listener) ----- @@ -312,6 +314,10 @@ type reactiveHandler struct { // clarify.go). nil ⇒ she falls back to the canned "не поняла" reply. clarifyStore *dialogue.ClarifyStore + // clarifyMaxAttempts — questions per request before she gives up out loud. + // 0 ⇒ dialogue.DefaultMaxAttempts (3). Set from VoiceConfig. + clarifyMaxAttempts int + // extractor parses the answer to an open question, with the same parsers // the router's own stage-2 uses. extractor router.Extractor