DEV-000066 human response continuation semantics
CI / test (push) Successful in 21s
CI / test (pull_request) Successful in 16s

This commit is contained in:
m
2026-08-17 17:02:33 +03:00
parent e8e51ffdba
commit 8b9b841645
22 changed files with 1163 additions and 45 deletions
+170
View File
@@ -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,
},
}
}
+12 -2
View File
@@ -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 {