DEV-000066 human response continuation semantics
This commit is contained in:
@@ -0,0 +1,170 @@
|
||||
package domain
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"fmt"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"git.cin.su/m/Assistant/contracts/authority"
|
||||
contract "git.cin.su/m/Assistant/contracts/continuity"
|
||||
"git.cin.su/m/Assistant/contracts/identity"
|
||||
)
|
||||
|
||||
var ErrInvalidHumanResponse = errors.New("invalid human response")
|
||||
|
||||
type ResponseCandidate struct {
|
||||
Attention contract.AttentionItem
|
||||
Prospective contract.ProspectiveItem
|
||||
}
|
||||
|
||||
func InterpretHumanResponse(request contract.HumanResponseRequest, owner identity.PrincipalID, scope authority.ScopeID, id contract.HumanResponseID, candidates []ResponseCandidate, now time.Time) (contract.HumanResponseResult, error) {
|
||||
message := strings.TrimSpace(request.Message)
|
||||
if id == "" || owner == "" || scope == "" || request.SourceUtteranceID == "" || request.SourceIntentID == "" || message == "" || request.RequestedAtUnixMillis < 1 {
|
||||
return contract.HumanResponseResult{}, ErrInvalidHumanResponse
|
||||
}
|
||||
operation, snoozeUntil := detectResponseOperation(message, now)
|
||||
response := contract.HumanResponse{
|
||||
ID: id,
|
||||
OwnerPrincipalID: owner,
|
||||
ScopeID: scope,
|
||||
SourceUtteranceID: strings.TrimSpace(request.SourceUtteranceID),
|
||||
SourceIntentID: strings.TrimSpace(request.SourceIntentID),
|
||||
Operation: operation,
|
||||
TargetKind: contract.ResponseTargetUnknown,
|
||||
ResolutionState: contract.ResponseNoop,
|
||||
Outcome: contract.ResponseOutcomeNoop,
|
||||
SnoozeUntilUnixMillis: snoozeUntil.UnixMilli(),
|
||||
RecordedAtUnixMillis: now.UnixMilli(),
|
||||
Revision: 1,
|
||||
UserReportedNotVerified: false,
|
||||
}
|
||||
if operation == contract.ResponseUnknown || operation == contract.ResponseContinue || operation == contract.ResponseReject {
|
||||
return contract.HumanResponseResult{Response: response, Handled: false}, nil
|
||||
}
|
||||
if len(candidates) == 0 {
|
||||
response.ResolutionState = contract.ResponseNoTarget
|
||||
response.Outcome = contract.ResponseOutcomeClarificationNeeded
|
||||
response.Clarification = "Я не вижу активного ожидания, к которому это относится."
|
||||
return contract.HumanResponseResult{Response: response, Handled: true, Reply: response.Clarification}, nil
|
||||
}
|
||||
if len(candidates) > 1 {
|
||||
response.ResolutionState = contract.ResponseAmbiguous
|
||||
response.Outcome = contract.ResponseOutcomeClarificationNeeded
|
||||
response.Clarification = "У меня есть несколько возможных ожиданий. Уточните, о каком именно речь: " + candidateSummary(candidates)
|
||||
return contract.HumanResponseResult{Response: response, Handled: true, Reply: response.Clarification}, nil
|
||||
}
|
||||
candidate := candidates[0]
|
||||
response.TargetKind = contract.ResponseTargetAttentionItem
|
||||
response.TargetAttentionID = candidate.Attention.ID
|
||||
response.TargetProspectiveID = candidate.Attention.SourceProspectiveID
|
||||
response.ResolutionState = contract.ResponseResolved
|
||||
switch operation {
|
||||
case contract.ResponseComplete:
|
||||
response.Outcome = contract.ResponseOutcomeUserReportedComplete
|
||||
response.UserReportedNotVerified = true
|
||||
return contract.HumanResponseResult{Response: response, Handled: true, Reply: "Готово, я закрыл это напоминание. Записал как «сообщено человеком», без внешней проверки."}, nil
|
||||
case contract.ResponseSnooze:
|
||||
if response.SnoozeUntilUnixMillis <= now.UnixMilli() {
|
||||
response.ResolutionState = contract.ResponseNoop
|
||||
response.Outcome = contract.ResponseOutcomeClarificationNeeded
|
||||
response.Clarification = "На сколько отложить? Например: «Отложи на 10 минут»."
|
||||
return contract.HumanResponseResult{Response: response, Handled: true, Reply: response.Clarification}, nil
|
||||
}
|
||||
response.Outcome = contract.ResponseOutcomeSnoozed
|
||||
return contract.HumanResponseResult{Response: response, Handled: true, Reply: "Отложил. Напомню " + humanResponseTime(snoozeUntil) + "."}, nil
|
||||
case contract.ResponseCancel:
|
||||
response.Outcome = contract.ResponseOutcomeCancelled
|
||||
return contract.HumanResponseResult{Response: response, Handled: true, Reply: "Отменил. Больше не буду напоминать об этом."}, nil
|
||||
case contract.ResponseAcknowledge, contract.ResponseDismiss:
|
||||
response.Outcome = contract.ResponseOutcomeDismissed
|
||||
return contract.HumanResponseResult{Response: response, Handled: true, Reply: "Принял, убрал это из текущего внимания."}, nil
|
||||
default:
|
||||
response.ResolutionState = contract.ResponseNoop
|
||||
response.Outcome = contract.ResponseOutcomeNoop
|
||||
return contract.HumanResponseResult{Response: response, Handled: false}, nil
|
||||
}
|
||||
}
|
||||
|
||||
func detectResponseOperation(message string, now time.Time) (contract.HumanResponseOperation, time.Time) {
|
||||
lower := strings.ToLower(strings.TrimSpace(message))
|
||||
if containsAny(lower, "отложи", "перенеси", "позже", "потом") {
|
||||
if until, ok := parseSnoozeUntil(lower, now); ok {
|
||||
return contract.ResponseSnooze, until
|
||||
}
|
||||
return contract.ResponseSnooze, time.Time{}
|
||||
}
|
||||
if containsAny(lower, "отмени", "отменить", "не надо", "не нужно", "больше не напоминай") {
|
||||
return contract.ResponseCancel, time.Time{}
|
||||
}
|
||||
if containsAny(lower, "готово", "сделал", "сделала", "выполнено", "закрыл", "закрыла") {
|
||||
return contract.ResponseComplete, time.Time{}
|
||||
}
|
||||
if lower == "ок" || lower == "понял" || lower == "поняла" || lower == "принято" {
|
||||
return contract.ResponseAcknowledge, time.Time{}
|
||||
}
|
||||
if containsAny(lower, "продолжай", "дальше") {
|
||||
return contract.ResponseContinue, time.Time{}
|
||||
}
|
||||
if containsAny(lower, "отклоняю", "нет", "не согласен", "не согласна") {
|
||||
return contract.ResponseReject, time.Time{}
|
||||
}
|
||||
return contract.ResponseUnknown, time.Time{}
|
||||
}
|
||||
|
||||
func parseSnoozeUntil(lower string, now time.Time) (time.Time, bool) {
|
||||
relative := regexp.MustCompile(`(?:через|на)\s+(\d{1,3})\s*(минуту|минуты|минут|час|часа|часов)`)
|
||||
if match := relative.FindStringSubmatch(lower); len(match) > 0 {
|
||||
value, err := strconv.Atoi(match[1])
|
||||
if err != nil || value < 1 {
|
||||
return time.Time{}, false
|
||||
}
|
||||
if strings.HasPrefix(match[2], "час") {
|
||||
if value > 72 {
|
||||
return time.Time{}, false
|
||||
}
|
||||
return now.Add(time.Duration(value) * time.Hour), true
|
||||
}
|
||||
if value > 24*60 {
|
||||
return time.Time{}, false
|
||||
}
|
||||
return now.Add(time.Duration(value) * time.Minute), true
|
||||
}
|
||||
if strings.Contains(lower, "позже") || strings.Contains(lower, "потом") {
|
||||
return now.Add(time.Hour), true
|
||||
}
|
||||
return time.Time{}, false
|
||||
}
|
||||
|
||||
func candidateSummary(candidates []ResponseCandidate) string {
|
||||
parts := make([]string, 0, len(candidates))
|
||||
for _, candidate := range candidates {
|
||||
text := strings.TrimSpace(candidate.Attention.Summary)
|
||||
if text == "" {
|
||||
text = "ожидание"
|
||||
}
|
||||
parts = append(parts, text)
|
||||
}
|
||||
if len(parts) > 3 {
|
||||
parts = parts[:3]
|
||||
}
|
||||
return strings.Join(parts, "; ")
|
||||
}
|
||||
|
||||
func humanResponseTime(value time.Time) string {
|
||||
if value.IsZero() {
|
||||
return "позже"
|
||||
}
|
||||
return fmt.Sprintf("%02d.%02d в %02d:%02d", value.Day(), value.Month(), value.Hour(), value.Minute())
|
||||
}
|
||||
|
||||
func containsAny(value string, needles ...string) bool {
|
||||
for _, needle := range needles {
|
||||
if strings.Contains(value, needle) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
@@ -0,0 +1,86 @@
|
||||
package domain
|
||||
|
||||
import (
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"git.cin.su/m/Assistant/contracts/authority"
|
||||
"git.cin.su/m/Assistant/contracts/continuity"
|
||||
"git.cin.su/m/Assistant/contracts/identity"
|
||||
)
|
||||
|
||||
func TestInterpretHumanResponseCompletesSingleDeliveredReminder(t *testing.T) {
|
||||
result := interpretResponseForTest(t, "Готово", []ResponseCandidate{responseCandidate("a1", "p1", "позвонить врачу")})
|
||||
if !result.Handled || result.Response.Operation != continuity.ResponseComplete || result.Response.Outcome != continuity.ResponseOutcomeUserReportedComplete || !result.Response.UserReportedNotVerified {
|
||||
t.Fatalf("unexpected complete response: %#v", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInterpretHumanResponseSnoozesSingleReminder(t *testing.T) {
|
||||
result := interpretResponseForTest(t, "Отложи на 10 минут", []ResponseCandidate{responseCandidate("a1", "p1", "проверить базу")})
|
||||
if !result.Handled || result.Response.Operation != continuity.ResponseSnooze || result.Response.Outcome != continuity.ResponseOutcomeSnoozed {
|
||||
t.Fatalf("unexpected snooze response: %#v", result)
|
||||
}
|
||||
if result.Response.SnoozeUntilUnixMillis != time.Unix(100, 0).Add(10*time.Minute).UnixMilli() {
|
||||
t.Fatalf("unexpected snooze time: %d", result.Response.SnoozeUntilUnixMillis)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInterpretHumanResponseCancelsSingleReminder(t *testing.T) {
|
||||
result := interpretResponseForTest(t, "Отмени", []ResponseCandidate{responseCandidate("a1", "p1", "встретить курьера")})
|
||||
if !result.Handled || result.Response.Operation != continuity.ResponseCancel || result.Response.Outcome != continuity.ResponseOutcomeCancelled {
|
||||
t.Fatalf("unexpected cancel response: %#v", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInterpretHumanResponseAmbiguousTargetAsksClarificationWithoutResolvedMutation(t *testing.T) {
|
||||
result := interpretResponseForTest(t, "Готово", []ResponseCandidate{responseCandidate("a1", "p1", "первое"), responseCandidate("a2", "p2", "второе")})
|
||||
if !result.Handled || result.Response.ResolutionState != continuity.ResponseAmbiguous || result.Response.Outcome != continuity.ResponseOutcomeClarificationNeeded || !strings.Contains(result.Reply, "несколько") {
|
||||
t.Fatalf("expected ambiguity clarification, got %#v", result)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInterpretHumanResponseNoTargetAsksClarification(t *testing.T) {
|
||||
result := interpretResponseForTest(t, "Готово", nil)
|
||||
if !result.Handled || result.Response.ResolutionState != continuity.ResponseNoTarget || result.Response.Outcome != continuity.ResponseOutcomeClarificationNeeded {
|
||||
t.Fatalf("expected no-target clarification, got %#v", result)
|
||||
}
|
||||
}
|
||||
|
||||
func interpretResponseForTest(t *testing.T, message string, candidates []ResponseCandidate) continuity.HumanResponseResult {
|
||||
t.Helper()
|
||||
result, err := InterpretHumanResponse(continuity.HumanResponseRequest{
|
||||
SourceUtteranceID: "utterance-1",
|
||||
SourceIntentID: "intent-1",
|
||||
Message: message,
|
||||
RequestedAtUnixMillis: time.Unix(100, 0).UnixMilli(),
|
||||
}, identity.PrincipalID("principal-1"), authority.ScopeID("scope-1"), continuity.HumanResponseID("response-1"), candidates, time.Unix(100, 0))
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
func responseCandidate(attentionID continuity.AttentionItemID, prospectiveID continuity.ProspectiveItemID, summary string) ResponseCandidate {
|
||||
return ResponseCandidate{
|
||||
Attention: continuity.AttentionItem{
|
||||
ID: attentionID,
|
||||
OwnerPrincipalID: "principal-1",
|
||||
ScopeID: "scope-1",
|
||||
SourceKind: continuity.AttentionSourceProspectiveReminder,
|
||||
SourceProspectiveID: prospectiveID,
|
||||
State: continuity.AttentionDelivered,
|
||||
Summary: summary,
|
||||
Revision: 1,
|
||||
},
|
||||
Prospective: continuity.ProspectiveItem{
|
||||
ID: prospectiveID,
|
||||
OwnerPrincipalID: "principal-1",
|
||||
ScopeID: "scope-1",
|
||||
Summary: summary,
|
||||
State: continuity.ProspectiveDelivered,
|
||||
Revision: 1,
|
||||
},
|
||||
}
|
||||
}
|
||||
@@ -112,7 +112,7 @@ func projectReferences(utterance interaction.HumanUtterance, projects []situatio
|
||||
}
|
||||
}
|
||||
}
|
||||
if len(refs) == 0 && previousFocus != nil && strings.Contains(lower, "туда") {
|
||||
if len(refs) == 0 && previousFocus != nil && inheritedFocusAllowed(utterance.SpeechAct, utterance.Content) {
|
||||
ref, err := newProjectReference(utterance.ID, previousFocus.ProjectID, previousFocus.ProjectDisplayName, interaction.ProjectRolePrimary, situation.ProjectResolutionInheritedFocus, 700, millis)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
@@ -196,7 +196,17 @@ func requestedOutcome(message string, act interaction.SpeechAct) string {
|
||||
}
|
||||
|
||||
func inheritedFocusAllowed(act interaction.SpeechAct, message string) bool {
|
||||
return strings.Contains(strings.ToLower(message), "туда") && act != interaction.SpeechActUnknown
|
||||
lower := strings.ToLower(message)
|
||||
if act == interaction.SpeechActUnknown {
|
||||
return false
|
||||
}
|
||||
if strings.Contains(lower, "туда") || strings.Contains(lower, "там") || strings.Contains(lower, "в этом проекте") {
|
||||
return true
|
||||
}
|
||||
if act == interaction.SpeechActQuestion || act == interaction.SpeechActRequestToInvestigate {
|
||||
return strings.Contains(lower, "база") || strings.Contains(lower, "сервер") || strings.Contains(lower, "почему тормозит") || strings.Contains(lower, "что там")
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
func isAmbiguousDestructive(act interaction.SpeechAct, message string, projects []interaction.ProjectReference) bool {
|
||||
|
||||
@@ -73,6 +73,25 @@ func TestInterpretUtteranceInheritedFocusForThere(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestProjectFocusIsContextualEvidenceNotGlobalMode(t *testing.T) {
|
||||
explicit := interpretForTest(t, "Сейчас работаем с УПО.", nil, "")
|
||||
if explicit.ActiveFocus == nil || explicit.ActiveFocus.ProjectID != "upo" {
|
||||
t.Fatalf("expected explicit UPO focus, got %#v", explicit.ActiveFocus)
|
||||
}
|
||||
focusedQuestion := interpretForTest(t, "Почему тормозит база?", activeFocus("upo", "УПО"), "")
|
||||
if len(focusedQuestion.Projects) != 1 || focusedQuestion.Projects[0].ProjectID != "upo" || focusedQuestion.Projects[0].Provenance != situation.ProjectResolutionInheritedFocus {
|
||||
t.Fatalf("database follow-up can use previous project as contextual evidence, got %#v", focusedQuestion.Projects)
|
||||
}
|
||||
unrelated := interpretForTest(t, "Помоги ответить на письмо бухгалтеру.", activeFocus("upo", "УПО"), "")
|
||||
if len(unrelated.Projects) != 0 {
|
||||
t.Fatalf("unrelated mail intent must not inherit UPO focus, got %#v", unrelated.Projects)
|
||||
}
|
||||
returned := interpretForTest(t, "Вернемся к УПО.", activeFocus("assistant", "Assistant"), "")
|
||||
if returned.ActiveFocus == nil || returned.ActiveFocus.ProjectID != "upo" {
|
||||
t.Fatalf("expected explicit return to UPO, got %#v", returned.ActiveFocus)
|
||||
}
|
||||
}
|
||||
|
||||
func TestInterpretUtteranceMultiProjectReferenceRoles(t *testing.T) {
|
||||
result := interpretForTest(t, "Посмотри, как это сделано в Assistant, и сделай аналогично в УПО.", nil, "")
|
||||
if len(result.Projects) != 2 {
|
||||
|
||||
Reference in New Issue
Block a user