679 lines
25 KiB
Go
679 lines
25 KiB
Go
package domain
|
|
|
|
import (
|
|
"errors"
|
|
"strings"
|
|
"time"
|
|
"unicode/utf8"
|
|
|
|
"git.cin.su/m/Assistant/contracts/identity"
|
|
"git.cin.su/m/Assistant/contracts/interaction"
|
|
"git.cin.su/m/Assistant/platform/ids"
|
|
)
|
|
|
|
const MaxHumanUtteranceBytes = 16 << 10
|
|
|
|
var (
|
|
ErrEmptyMessage = errors.New("empty human message")
|
|
ErrMessageTooLarge = errors.New("human message too large")
|
|
ErrInvalidPrincipal = errors.New("invalid interaction principal")
|
|
)
|
|
|
|
type Clock func() time.Time
|
|
|
|
func NewConversation(actorID identity.ActorID, principalID identity.PrincipalID, now time.Time) (interaction.Conversation, error) {
|
|
if actorID == "" || principalID == "" {
|
|
return interaction.Conversation{}, ErrInvalidPrincipal
|
|
}
|
|
id, err := ids.New()
|
|
if err != nil {
|
|
return interaction.Conversation{}, err
|
|
}
|
|
millis := now.UnixMilli()
|
|
return interaction.Conversation{
|
|
ID: interaction.ConversationID(id),
|
|
ActorID: actorID,
|
|
PrincipalID: principalID,
|
|
Channel: interaction.ChannelWebChat,
|
|
State: interaction.ConversationOpen,
|
|
CreatedAtUnixMillis: millis,
|
|
UpdatedAtUnixMillis: millis,
|
|
}, nil
|
|
}
|
|
|
|
func NewHumanUtterance(conversation interaction.Conversation, request interaction.ChatMessageRequest, now time.Time) (interaction.HumanUtterance, interaction.OriginalHumanIntent, []interaction.InteractionRelation, error) {
|
|
message := strings.TrimSpace(request.Message)
|
|
if message == "" {
|
|
return interaction.HumanUtterance{}, interaction.OriginalHumanIntent{}, nil, ErrEmptyMessage
|
|
}
|
|
if len(message) > MaxHumanUtteranceBytes || !utf8.ValidString(message) {
|
|
return interaction.HumanUtterance{}, interaction.OriginalHumanIntent{}, nil, ErrMessageTooLarge
|
|
}
|
|
utteranceID, err := ids.New()
|
|
if err != nil {
|
|
return interaction.HumanUtterance{}, interaction.OriginalHumanIntent{}, nil, err
|
|
}
|
|
intentID, err := ids.New()
|
|
if err != nil {
|
|
return interaction.HumanUtterance{}, interaction.OriginalHumanIntent{}, nil, err
|
|
}
|
|
millis := now.UnixMilli()
|
|
candidate := BuildDeterministicCandidate(message, request.CorrectsUtteranceID, millis)
|
|
speechAct := candidate.PrimarySpeechAct
|
|
utterance := interaction.HumanUtterance{
|
|
ID: interaction.HumanUtteranceID(utteranceID),
|
|
ConversationID: conversation.ID,
|
|
ActorID: conversation.ActorID,
|
|
PrincipalID: conversation.PrincipalID,
|
|
Channel: interaction.ChannelWebChat,
|
|
ReceivedAtUnixMillis: millis,
|
|
CorrelationID: request.CorrelationID,
|
|
Content: message,
|
|
ContentRef: "interaction:utterance:" + string(utteranceID),
|
|
SpeechAct: speechAct,
|
|
InterpretationState: interaction.InterpretationInterpreted,
|
|
CorrectsUtteranceID: request.CorrectsUtteranceID,
|
|
}
|
|
intent := interaction.OriginalHumanIntent{
|
|
ID: interaction.OriginalHumanIntentID(intentID),
|
|
UtteranceID: utterance.ID,
|
|
RecordedAtUnixMillis: millis,
|
|
Text: message,
|
|
}
|
|
var relations []interaction.InteractionRelation
|
|
if request.CorrectsUtteranceID != "" || speechAct == interaction.SpeechActCorrection {
|
|
relationID, err := ids.New()
|
|
if err != nil {
|
|
return interaction.HumanUtterance{}, interaction.OriginalHumanIntent{}, nil, err
|
|
}
|
|
relations = append(relations, interaction.InteractionRelation{
|
|
ID: interaction.InteractionRelationID(relationID),
|
|
FromUtteranceID: utterance.ID,
|
|
ToUtteranceID: request.CorrectsUtteranceID,
|
|
Kind: interaction.RelationCorrects,
|
|
RecordedAtUnixMillis: millis,
|
|
})
|
|
}
|
|
return utterance, intent, relations, nil
|
|
}
|
|
|
|
func ClassifySpeechAct(message string, corrects interaction.HumanUtteranceID) interaction.SpeechAct {
|
|
return BuildDeterministicCandidate(message, corrects, time.Now().UnixMilli()).PrimarySpeechAct
|
|
}
|
|
|
|
func NeedsCognition(act interaction.SpeechAct) bool {
|
|
return act == interaction.SpeechActQuestion || act == interaction.SpeechActRequestToInvestigate
|
|
}
|
|
|
|
func FallbackText(act interaction.SpeechAct) string {
|
|
switch act {
|
|
case interaction.SpeechActDirective:
|
|
return "Я понял действие как просьбу, но без отдельного Authority/Commit шага не выполняю мутацию."
|
|
case interaction.SpeechActAssertion:
|
|
return "Я записал это как утверждение человека. Это не считается проверенным фактом."
|
|
case interaction.SpeechActCorrection:
|
|
return "Исправление записано отдельной репликой; история не переписана."
|
|
case interaction.SpeechActQuestion, interaction.SpeechActRequestToInvestigate:
|
|
return "Когнитивный маршрут сейчас недоступен, но сообщение сохранено и может быть обработано позже."
|
|
default:
|
|
return "Сообщение записано."
|
|
}
|
|
}
|
|
|
|
func BuildDeterministicCandidate(message string, corrects interaction.HumanUtteranceID, millis int64) interaction.SemanticCandidate {
|
|
id, _ := ids.New()
|
|
tokens := semanticTokens(message)
|
|
hasQuestionMark := strings.Contains(message, "?")
|
|
scores := semanticScores(tokens, hasQuestionMark, corrects != "")
|
|
primary, primaryScore := topAct(scores)
|
|
secondary, secondaryScore := secondAct(scores, primary)
|
|
candidate := interaction.SemanticCandidate{
|
|
ID: interaction.SemanticCandidateID(id),
|
|
UtteranceID: "",
|
|
Source: interaction.CandidateSourceDeterministic,
|
|
SelectionState: interaction.CandidateObserved,
|
|
PrimarySpeechAct: primary,
|
|
SecondarySpeechAct: secondary,
|
|
ConfidenceMillis: boundedConfidence(primaryScore, secondaryScore, scores),
|
|
Applicability: applicabilityFor(primary, secondary, primaryScore, secondaryScore, tokens, corrects != ""),
|
|
RequestedOutcome: requestedOutcome(message, primary),
|
|
Clarification: interaction.ClarificationNotRequired,
|
|
NeedsCognition: needsCognitionForCandidate(primary, secondary, tokens),
|
|
SelectionReason: deterministicReason(primary, secondary, tokens),
|
|
CapabilityHints: capabilityHintsFor(primary, secondary, tokens),
|
|
RecordedAtUnixMillis: millis,
|
|
}
|
|
if candidate.PrimarySpeechAct == interaction.SpeechActUnknown {
|
|
candidate.PrimarySpeechAct = interaction.SpeechActAssertion
|
|
}
|
|
if candidate.Applicability == interaction.SemanticCandidateClarify {
|
|
candidate.Clarification = interaction.ClarificationRequired
|
|
candidate.NeedsCognition = false
|
|
}
|
|
return candidate
|
|
}
|
|
|
|
func semanticTokens(message string) []string {
|
|
lower := strings.ToLower(strings.TrimSpace(message))
|
|
replacer := strings.NewReplacer(".", " ", ",", " ", "!", " ", "?", " ", ":", " ", ";", " ", "(", " ", ")", " ", "\"", " ", "'", " ", "«", " ", "»", " ", "+", " + ", "-", " - ", "/", " / ")
|
|
normalized := replacer.Replace(lower)
|
|
return strings.Fields(normalized)
|
|
}
|
|
|
|
func semanticScores(tokens []string, hasQuestionMark bool, explicitCorrection bool) map[interaction.SpeechAct]int {
|
|
scores := map[interaction.SpeechAct]int{
|
|
interaction.SpeechActAssertion: 1,
|
|
interaction.SpeechActDirective: 0,
|
|
interaction.SpeechActQuestion: 0,
|
|
interaction.SpeechActRequestToInvestigate: 0,
|
|
interaction.SpeechActCorrection: 0,
|
|
interaction.SpeechActDecision: 0,
|
|
interaction.SpeechActPreference: 0,
|
|
interaction.SpeechActHypothesis: 0,
|
|
interaction.SpeechActConfirmation: 0,
|
|
interaction.SpeechActRejection: 0,
|
|
interaction.SpeechActConversational: 0,
|
|
}
|
|
if hasQuestionMark {
|
|
scores[interaction.SpeechActQuestion] += 4
|
|
scores[interaction.SpeechActRequestToInvestigate]++
|
|
}
|
|
if explicitCorrection {
|
|
scores[interaction.SpeechActCorrection] += 6
|
|
}
|
|
first := ""
|
|
if len(tokens) > 0 {
|
|
first = tokens[0]
|
|
}
|
|
if first == "нет" || first == "не" {
|
|
scores[interaction.SpeechActCorrection] += 2
|
|
scores[interaction.SpeechActRejection]++
|
|
}
|
|
if first == "да" {
|
|
scores[interaction.SpeechActConfirmation] += 2
|
|
}
|
|
questionWords := map[string]struct{}{"кто": {}, "что": {}, "как": {}, "почему": {}, "зачем": {}, "где": {}, "когда": {}, "сколько": {}, "какой": {}, "какая": {}, "какие": {}, "чей": {}}
|
|
conversationWords := []string{"привет", "здравствуйте", "спасибо", "ку", "здравствуй", "добрый"}
|
|
investigateStems := []string{"разбер", "проверь", "провери", "проанализ", "исслед", "выясн", "узнай"}
|
|
directiveStems := []string{"сдел", "запуст", "созд", "настро", "добав", "измени", "помен", "поменя", "измен", "использ", "удал", "напом", "подключ", "исправ", "обрати", "поправ", "обнов", "ответь", "посмотри", "проверь"}
|
|
preferenceStems := []string{"предпоч", "хочу", "лучше", "не используй"}
|
|
hypothesisStems := []string{"думаю", "кажется", "гипотез", "похоже"}
|
|
decisionStems := []string{"решил", "решение", "выбираю"}
|
|
arithmeticMarker := false
|
|
for index, token := range tokens {
|
|
if firstPersonPastReport(tokens, index) && containsStem(token, directiveStems...) {
|
|
continue
|
|
}
|
|
if _, ok := questionWords[token]; ok && !(token == "что" && index+1 < len(tokens) && tokens[index+1] == "нибудь") {
|
|
scores[interaction.SpeechActQuestion] += 4
|
|
}
|
|
if containsStem(token, conversationWords...) {
|
|
scores[interaction.SpeechActConversational] += 4
|
|
}
|
|
if containsStem(token, investigateStems...) {
|
|
scores[interaction.SpeechActRequestToInvestigate] += 3
|
|
scores[interaction.SpeechActQuestion] += 1
|
|
}
|
|
if containsStem(token, directiveStems...) {
|
|
scores[interaction.SpeechActDirective] += 3
|
|
}
|
|
if containsStem(token, preferenceStems...) {
|
|
scores[interaction.SpeechActPreference] += 3
|
|
}
|
|
if containsStem(token, hypothesisStems...) {
|
|
scores[interaction.SpeechActHypothesis] += 3
|
|
}
|
|
if containsStem(token, decisionStems...) {
|
|
scores[interaction.SpeechActDecision] += 3
|
|
}
|
|
if token == "+" || token == "-" || token == "/" || token == "*" || token == "плюс" || token == "минус" {
|
|
arithmeticMarker = true
|
|
}
|
|
}
|
|
if looksLikeInstructionWithoutPunctuationAfterLead(tokens) {
|
|
scores[interaction.SpeechActQuestion] += 4
|
|
scores[interaction.SpeechActRequestToInvestigate] += 2
|
|
}
|
|
if arithmeticMarker {
|
|
scores[interaction.SpeechActQuestion] += 2
|
|
}
|
|
if len(tokens) > 0 && startsWithModalRequest(tokens) {
|
|
scores[interaction.SpeechActQuestion] += 2
|
|
scores[interaction.SpeechActRequestToInvestigate] += 2
|
|
}
|
|
if looksLikeInformationRequest(tokens) {
|
|
scores[interaction.SpeechActQuestion] += 4
|
|
scores[interaction.SpeechActRequestToInvestigate] += 2
|
|
}
|
|
if !hasQuestionMark && containsInterrogative(tokens) {
|
|
scores[interaction.SpeechActQuestion] += 4
|
|
scores[interaction.SpeechActRequestToInvestigate] += 2
|
|
}
|
|
if containsModelReference(tokens) {
|
|
scores[interaction.SpeechActQuestion] += 2
|
|
scores[interaction.SpeechActDirective] += 1
|
|
}
|
|
if !hasQuestionMark && scores[interaction.SpeechActQuestion] == 0 && scores[interaction.SpeechActRequestToInvestigate] == 0 &&
|
|
scores[interaction.SpeechActDirective] <= 1 && scores[interaction.SpeechActCorrection] == 0 {
|
|
scores[interaction.SpeechActAssertion] += 2
|
|
}
|
|
return scores
|
|
}
|
|
|
|
func topAct(scores map[interaction.SpeechAct]int) (interaction.SpeechAct, int) {
|
|
bestAct, bestScore := interaction.SpeechActUnknown, -1
|
|
for _, act := range []interaction.SpeechAct{
|
|
interaction.SpeechActQuestion,
|
|
interaction.SpeechActRequestToInvestigate,
|
|
interaction.SpeechActDirective,
|
|
interaction.SpeechActCorrection,
|
|
interaction.SpeechActConversational,
|
|
interaction.SpeechActPreference,
|
|
interaction.SpeechActHypothesis,
|
|
interaction.SpeechActDecision,
|
|
interaction.SpeechActConfirmation,
|
|
interaction.SpeechActRejection,
|
|
interaction.SpeechActAssertion,
|
|
} {
|
|
if score := scores[act]; score > bestScore {
|
|
bestAct, bestScore = act, score
|
|
}
|
|
}
|
|
return bestAct, bestScore
|
|
}
|
|
|
|
func secondAct(scores map[interaction.SpeechAct]int, primary interaction.SpeechAct) (interaction.SpeechAct, int) {
|
|
second, score := interaction.SpeechActUnknown, -1
|
|
for act, value := range scores {
|
|
if act == primary {
|
|
continue
|
|
}
|
|
if value > score {
|
|
second, score = act, value
|
|
}
|
|
}
|
|
if score <= 0 {
|
|
return interaction.SpeechActUnknown, 0
|
|
}
|
|
return second, score
|
|
}
|
|
|
|
func applicabilityFor(primary, secondary interaction.SpeechAct, primaryScore, secondaryScore int, tokens []string, explicitCorrection bool) interaction.SemanticApplicability {
|
|
if primary == interaction.SpeechActAssertion && !containsInterrogative(tokens) && secondaryScore <= 1 {
|
|
return interaction.SemanticApplicable
|
|
}
|
|
if primaryScore < 2 {
|
|
return interaction.SemanticNeedsBroaderInterpret
|
|
}
|
|
if explicitCorrection && secondaryScore >= 3 && (secondary == interaction.SpeechActDirective || secondary == interaction.SpeechActRequestToInvestigate) {
|
|
return interaction.SemanticMixedIntent
|
|
}
|
|
if primary == interaction.SpeechActCorrection && secondaryScore >= 3 && (secondary == interaction.SpeechActDirective || secondary == interaction.SpeechActRequestToInvestigate) {
|
|
return interaction.SemanticMixedIntent
|
|
}
|
|
if primary == interaction.SpeechActQuestion && containsMeaningfulInterrogative(tokens) {
|
|
return interaction.SemanticNeedsBroaderInterpret
|
|
}
|
|
if primary == interaction.SpeechActDirective && likelyConsequential(tokens) {
|
|
return interaction.SemanticCandidateClarify
|
|
}
|
|
if primary == interaction.SpeechActDirective && containsStemInTokens(tokens, "обрати", "спрос") && containsModelReference(tokens) {
|
|
return interaction.SemanticLowConfidence
|
|
}
|
|
if primary == interaction.SpeechActDirective && containsStemInTokens(tokens, "убери", "снеси", "удали", "удал", "стер") && len(tokens) > 1 {
|
|
return interaction.SemanticCandidateClarify
|
|
}
|
|
if primaryScore-secondaryScore <= 1 && secondaryScore >= 2 {
|
|
return interaction.SemanticLowConfidence
|
|
}
|
|
if primary == interaction.SpeechActQuestion || primary == interaction.SpeechActRequestToInvestigate {
|
|
if primaryScore < 4 {
|
|
return interaction.SemanticNeedsBroaderInterpret
|
|
}
|
|
}
|
|
if primary == interaction.SpeechActConversational {
|
|
return interaction.SemanticApplicable
|
|
}
|
|
if primary == interaction.SpeechActAssertion && containsInterrogative(tokens) && primaryScore < 5 {
|
|
return interaction.SemanticNeedsBroaderInterpret
|
|
}
|
|
return interaction.SemanticApplicable
|
|
}
|
|
|
|
func needsCognitionForCandidate(primary, secondary interaction.SpeechAct, tokens []string) bool {
|
|
if primary == interaction.SpeechActConversational && secondary == interaction.SpeechActDirective {
|
|
return true
|
|
}
|
|
if primary == interaction.SpeechActQuestion && containsMeaningfulInterrogative(tokens) {
|
|
return true
|
|
}
|
|
if isAssistantStatusProbe(primary, secondary, tokens) {
|
|
return true
|
|
}
|
|
if primary == interaction.SpeechActAssertion && containsModelReference(tokens) && containsStemInTokens(tokens, "работает", "падает", "растет", "растёет", "свободно", "виснет") {
|
|
return true
|
|
}
|
|
if primary == interaction.SpeechActQuestion || primary == interaction.SpeechActRequestToInvestigate {
|
|
return true
|
|
}
|
|
if secondary == interaction.SpeechActQuestion || secondary == interaction.SpeechActRequestToInvestigate {
|
|
return true
|
|
}
|
|
if primary == interaction.SpeechActDirective && (containsInterrogative(tokens) || containsModelReference(tokens) || containsStemInTokens(tokens, "обрати", "посмотри", "разбер", "исправ", "обнов", "добав")) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func deterministicReason(primary, secondary interaction.SpeechAct, tokens []string) string {
|
|
reasons := []string{"deterministic candidate from token-shape, interrogative, imperative and context cues"}
|
|
if primary == interaction.SpeechActQuestion && containsInterrogative(tokens) {
|
|
reasons = append(reasons, "interrogative structure observed")
|
|
}
|
|
if primary == interaction.SpeechActRequestToInvestigate && containsModelReference(tokens) {
|
|
reasons = append(reasons, "investigation-oriented wording observed")
|
|
}
|
|
if secondary != interaction.SpeechActUnknown {
|
|
reasons = append(reasons, "secondary competing semantic signal observed")
|
|
}
|
|
return strings.Join(reasons, "; ")
|
|
}
|
|
|
|
func capabilityHintsFor(primary, secondary interaction.SpeechAct, tokens []string) []string {
|
|
seen := map[string]struct{}{}
|
|
add := func(kind string) {
|
|
if kind != "" {
|
|
seen[kind] = struct{}{}
|
|
}
|
|
}
|
|
if primary == interaction.SpeechActQuestion || primary == interaction.SpeechActRequestToInvestigate || secondary == interaction.SpeechActQuestion || secondary == interaction.SpeechActRequestToInvestigate {
|
|
add("COGNITIVE_REASONING")
|
|
}
|
|
if isAssistantStatusProbe(primary, secondary, tokens) {
|
|
add("COGNITIVE_REASONING")
|
|
}
|
|
if isExplicitReminder(tokens) {
|
|
add("SCHEDULE_REMINDER")
|
|
}
|
|
if isExplicitEmailAction(tokens) || containsToken(tokens, "письма") || containsToken(tokens, "почту") || containsToken(tokens, "почта") {
|
|
add("SEND_EMAIL")
|
|
add("READ_EMAIL")
|
|
}
|
|
if primary == interaction.SpeechActDirective && containsStemInTokens(tokens, "добав", "реализ", "поддержк") {
|
|
add("MODIFY_CODE")
|
|
}
|
|
if containsToken(tokens, "напомни") || containsToken(tokens, "напомин") {
|
|
add("SCHEDULE_REMINDER")
|
|
}
|
|
if primary == interaction.SpeechActRequestToInvestigate || (primary == interaction.SpeechActQuestion && containsInterrogative(tokens) && containsStemInTokens(tokens, "почему", "как", "что")) {
|
|
add("COGNITIVE_REASONING")
|
|
}
|
|
if containsInterrogative(tokens) && containsArithmetic(tokens) {
|
|
add("COGNITIVE_REASONING")
|
|
}
|
|
if containsStemInTokens(tokens, "тормоз", "медлен", "почему", "что", "сервис", "база", "падает") {
|
|
add("INSPECT_PROJECT")
|
|
add("READ_DATABASE")
|
|
add("QUERY_LOGS")
|
|
}
|
|
if containsToken(tokens, "свободно") || containsToken(tokens, "гб") || containsToken(tokens, "модель") || containsToken(tokens, "postgres") || containsToken(tokens, "база") {
|
|
add("VERIFY_FACT")
|
|
}
|
|
values := make([]string, 0, len(seen))
|
|
for kind := range seen {
|
|
values = append(values, kind)
|
|
}
|
|
return values
|
|
}
|
|
|
|
func boundedConfidence(primaryScore, secondaryScore int, scores map[interaction.SpeechAct]int) int64 {
|
|
total := 0
|
|
for _, score := range scores {
|
|
if score > 0 {
|
|
total += score
|
|
}
|
|
}
|
|
if total == 0 {
|
|
return 200
|
|
}
|
|
confidence := int64(400 + (primaryScore * 100))
|
|
if secondaryScore > 0 {
|
|
confidence -= int64(secondaryScore * 40)
|
|
}
|
|
if confidence < 200 {
|
|
confidence = 200
|
|
}
|
|
if confidence > 980 {
|
|
confidence = 980
|
|
}
|
|
return confidence
|
|
}
|
|
|
|
func containsStem(token string, stems ...string) bool {
|
|
for _, stem := range stems {
|
|
if strings.Contains(token, stem) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func containsStemInTokens(tokens []string, stems ...string) bool {
|
|
for _, token := range tokens {
|
|
if containsStem(token, stems...) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func requestedOutcome(message string, act interaction.SpeechAct) string {
|
|
if act == interaction.SpeechActDirective || act == interaction.SpeechActDecision || act == interaction.SpeechActRequestToInvestigate {
|
|
return strings.TrimSpace(message)
|
|
}
|
|
return ""
|
|
}
|
|
|
|
func containsToken(tokens []string, expected string) bool {
|
|
for _, token := range tokens {
|
|
if token == expected {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func startsWithModalRequest(tokens []string) bool {
|
|
if len(tokens) == 0 {
|
|
return false
|
|
}
|
|
switch tokens[0] {
|
|
case "можешь", "можете", "сможешь", "сможете", "давай", "допусти":
|
|
return true
|
|
}
|
|
if len(tokens) >= 3 && tokens[0] == "не" && strings.HasPrefix(tokens[1], "мог") && tokens[2] == "бы" {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func containsInterrogative(tokens []string) bool {
|
|
for _, token := range tokens {
|
|
if token == "-" {
|
|
continue
|
|
}
|
|
switch token {
|
|
case "кто", "что", "как", "почему", "зачем", "где", "когда", "сколько", "какой", "какая", "какие", "чей":
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func containsMeaningfulInterrogative(tokens []string) bool {
|
|
for index, token := range tokens {
|
|
if token == "что" && followsNibud(tokens[index+1:]) {
|
|
continue
|
|
}
|
|
switch token {
|
|
case "кто", "что", "как", "почему", "зачем", "где", "когда", "сколько", "какой", "какая", "какие", "чей":
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func containsArithmetic(tokens []string) bool {
|
|
digits := 0
|
|
for _, token := range tokens {
|
|
if token == "+" || token == "-" || token == "*" || token == "/" || token == "плюс" || token == "минус" {
|
|
return true
|
|
}
|
|
for _, r := range token {
|
|
if r >= '0' && r <= '9' {
|
|
digits++
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return digits >= 2
|
|
}
|
|
|
|
func looksLikeInstructionWithoutPunctuation(first string) bool {
|
|
if first == "" {
|
|
return false
|
|
}
|
|
switch {
|
|
case strings.HasSuffix(first, "й"), strings.HasSuffix(first, "и"), strings.HasSuffix(first, "ите"):
|
|
return utf8.RuneCountInString(first) > 3
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func looksLikeInstructionWithoutPunctuationAfterLead(tokens []string) bool {
|
|
if len(tokens) < 2 {
|
|
return false
|
|
}
|
|
if utf8.RuneCountInString(tokens[0]) > 3 {
|
|
return false
|
|
}
|
|
switch tokens[0] {
|
|
case "про", "по", "на", "в", "за":
|
|
default:
|
|
return false
|
|
}
|
|
for _, token := range tokens[1:] {
|
|
if utf8.RuneCountInString(token) <= 3 {
|
|
continue
|
|
}
|
|
switch {
|
|
case strings.HasSuffix(token, "ешь"), strings.HasSuffix(token, "и"), strings.HasSuffix(token, "й"), strings.HasSuffix(token, "те"), strings.HasSuffix(token, "йте"):
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func looksLikeInformationRequest(tokens []string) bool {
|
|
if len(tokens) < 2 {
|
|
return false
|
|
}
|
|
if !containsSuffix(tokens[0], "й", "и", "те", "йте") {
|
|
return false
|
|
}
|
|
for _, token := range tokens[1:] {
|
|
if containsStem(token, "что", "как", "почему", "зачем", "когда", "кто", "какой", "какая", "какие", "об", "про", "подроб") {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func containsSuffix(value string, suffixes ...string) bool {
|
|
for _, suffix := range suffixes {
|
|
if strings.HasSuffix(value, suffix) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func likelyConsequential(tokens []string) bool {
|
|
for _, token := range tokens {
|
|
if containsStem(token, "удал", "снес", "замен", "миграц", "парол", "опубли", "перезапуст", "смени", "купи", "установ", "внедр") {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func followsNibud(tokens []string) bool {
|
|
for _, token := range tokens {
|
|
if token == "-" || token == "ни" {
|
|
continue
|
|
}
|
|
return token == "нибудь"
|
|
}
|
|
return false
|
|
}
|
|
|
|
func firstPersonPastReport(tokens []string, index int) bool {
|
|
if len(tokens) == 0 || index == 0 {
|
|
return false
|
|
}
|
|
if tokens[0] != "я" && tokens[0] != "мы" {
|
|
return false
|
|
}
|
|
if index < 2 {
|
|
return false
|
|
}
|
|
for _, token := range tokens[:index] {
|
|
if token == "всё" || token == "все" || token == "сейчас" || token == "уже" {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func containsModelReference(tokens []string) bool {
|
|
for _, token := range tokens {
|
|
if token == "модель" || token == "модели" || token == "postgres" || token == "postgresql" || strings.Contains(token, "gemma") || strings.Contains(token, "гемма") || strings.Contains(token, "qwen") {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func isAssistantStatusProbe(primary, secondary interaction.SpeechAct, tokens []string) bool {
|
|
if primary != interaction.SpeechActAssertion && primary != interaction.SpeechActCorrection && primary != interaction.SpeechActQuestion && primary != interaction.SpeechActRequestToInvestigate && primary != interaction.SpeechActUnknown {
|
|
return false
|
|
}
|
|
if !(containsToken(tokens, "домовой") || containsToken(tokens, "ассистент") || containsToken(tokens, "бот") || containsToken(tokens, "ты") || containsToken(tokens, "ии") || containsToken(tokens, "ai") || containsToken(tokens, "gpt")) {
|
|
return false
|
|
}
|
|
if containsToken(tokens, "не") && containsStemInTokens(tokens, "вид", "виж", "понима", "ответ", "отвеч", "работа", "реагир", "слыш", "слуш", "ищ", "уведом", "чувств") {
|
|
return true
|
|
}
|
|
for index := 0; index < len(tokens)-1; index++ {
|
|
if tokens[index] == "не" && (containsStem(tokens[index+1], "вид", "виж", "понима", "ответ", "отвеч", "работа", "реагир", "слыш", "слуш", "ищ", "уведом", "чувств")) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func isExplicitEmailAction(tokens []string) bool {
|
|
hasMailObject := containsToken(tokens, "письмо") || containsToken(tokens, "письма") || containsToken(tokens, "почту") || containsToken(tokens, "почта")
|
|
hasMailVerb := containsStemInTokens(tokens, "отправ", "ответ", "напиш", "пиши", "напишите")
|
|
return hasMailObject && hasMailVerb
|
|
}
|
|
|
|
func isExplicitReminder(tokens []string) bool {
|
|
hasReminder := containsToken(tokens, "напомни") || containsToken(tokens, "напомин")
|
|
if hasReminder {
|
|
return true
|
|
}
|
|
return containsStemInTokens(tokens, "напомин", "напомни")
|
|
}
|