Assistant/cmd/core-runtime/cognitive_interpretation.go

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"hash/fnv"
	"net/http"
	"net/url"
	"time"

	"git.cin.su/m/Assistant/contracts/authority"
	"git.cin.su/m/Assistant/contracts/capability"
	"git.cin.su/m/Assistant/contracts/cognitive"
	"git.cin.su/m/Assistant/contracts/identity"
	"git.cin.su/m/Assistant/contracts/interaction"
	interactiondomain "git.cin.su/m/Assistant/modules/interaction/domain"
	"git.cin.su/m/Assistant/platform/ids"
)

type cognitiveInterpretationClient struct {
	baseURL *url.URL
	client  *http.Client
}

func newCognitiveInterpretationClient(rawURL string, client *http.Client) (cognitiveInterpretationClient, error) {
	base, err := url.Parse(rawURL)
	if err != nil || base.Scheme == "" || base.Host == "" {
		return cognitiveInterpretationClient{}, fmt.Errorf("invalid Cognitive Runtime URL")
	}
	if client == nil {
		client = http.DefaultClient
	}
	return cognitiveInterpretationClient{baseURL: base, client: client}, nil
}

func (c cognitiveInterpretationClient) Interpret(ctx context.Context, request cognitive.GatewayInterpretationRequest) (cognitive.GatewayInterpretationResponse, error) {
	target := *c.baseURL
	target.Path = "/v1/interpretations"
	payload, err := json.Marshal(request)
	if err != nil {
		return cognitive.GatewayInterpretationResponse{}, err
	}
	upstream, err := http.NewRequestWithContext(ctx, http.MethodPost, target.String(), bytes.NewReader(payload))
	if err != nil {
		return cognitive.GatewayInterpretationResponse{}, err
	}
	upstream.Header.Set("Content-Type", "application/json")
	response, err := c.client.Do(upstream)
	if err != nil {
		return cognitive.GatewayInterpretationResponse{}, err
	}
	defer response.Body.Close()
	if response.StatusCode != http.StatusOK {
		return cognitive.GatewayInterpretationResponse{}, fmt.Errorf("cognitive interpretation status %d", response.StatusCode)
	}
	var result cognitive.GatewayInterpretationResponse
	if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
		return cognitive.GatewayInterpretationResponse{}, err
	}
	return result, nil
}

func shouldRequestBroaderInterpretation(result interactiondomain.SemanticResult) bool {
	return shouldRequestSemanticInterpretation(result)
}

// shouldRequestSemanticInterpretation keeps the deterministic layer as a
// fast reflex, not as the meaning authority. Questions, requests, directives,
// mixed signals and capability-bearing messages go through cognitive
// interpretation; only stable low-risk conversational/assertive reflexes may
// answer without it.
func shouldRequestSemanticInterpretation(result interactiondomain.SemanticResult) bool {
	if result.Interpretation.Clarification == interaction.ClarificationRequired {
		return false
	}
	// Structured, read-only information intents already have a semantic owner
	// in core-runtime. Sending them through the slower advisory interpretation
	// path only adds latency and can make a healthy runtime look unavailable.
	if result.InformationRequestKind != "" {
		return false
	}
	if result.NeedsCognition || len(result.CapabilityHints) > 0 {
		return true
	}
	if result.Interpretation.Applicability != interaction.SemanticApplicable {
		return true
	}
	switch result.Interpretation.SpeechAct {
	case interaction.SpeechActConversational, interaction.SpeechActConfirmation, interaction.SpeechActRejection:
		return false
	case interaction.SpeechActAssertion:
		return result.Interpretation.ConfidenceMillis < 850
	default:
		return true
	}
}

const (
	deterministicReflexAuditInterval = 10 * time.Minute
	deterministicReflexAuditSample   = uint32(16)
)

// shouldAuditDeterministicReflex samples stable reflexes in a time bucket.
// This is observability, not a correctness gate: a failed audit leaves the
// reflex usable, while a successful disagreement can replace it with the
// cognitive candidate and becomes durable evidence through the normal
// candidate store.
func shouldAuditDeterministicReflex(result interactiondomain.SemanticResult, utteranceID string, now time.Time) bool {
	if shouldRequestSemanticInterpretation(result) || utteranceID == "" {
		return false
	}
	bucket := now.Unix() / int64(deterministicReflexAuditInterval/time.Second)
	hash := fnv.New32a()
	_, _ = hash.Write([]byte(utteranceID))
	_, _ = hash.Write([]byte(fmt.Sprintf(":%d", bucket)))
	return hash.Sum32()%deterministicReflexAuditSample == 0
}

func isSimpleLocalQuestion(result interactiondomain.SemanticResult) bool {
	if result.Interpretation.SpeechAct != interaction.SpeechActQuestion || result.Interpretation.Clarification == interaction.ClarificationRequired {
		return false
	}
	for _, hint := range result.CapabilityHints {
		switch hint {
		case "MODIFY_CODE", "RUN_TESTS", "SEND_EMAIL", "SCHEDULE_REMINDER", "READ_DATABASE", "QUERY_LOGS":
			return false
		}
	}
	return true
}

func buildGatewayInterpretationRequest(session identity.CreatorSession, utterance interaction.HumanUtterance, semantic interactiondomain.SemanticResult, projectNames []string) cognitive.GatewayInterpretationRequest {
	requestID, _ := ids.New()
	return cognitive.GatewayInterpretationRequest{
		Version:                    cognitive.CreatorAdvisoryV1,
		RequestID:                  cognitive.RequestID(requestID),
		ActorID:                    session.ActorID,
		PrincipalID:                session.PrincipalID,
		ScopeID:                    authority.ScopeID("domovoy-global-scope"),
		Message:                    utterance.Content,
		Locale:                     "ru",
		MaxOutputBytes:             4096,
		DataPolicy:                 capability.DataPolicyLocalOnly,
		DeterministicSpeechAct:     string(semantic.Interpretation.SpeechAct),
		DeterministicSecondary:     string(semantic.Interpretation.SecondarySpeechAct),
		DeterministicConfidence:    semantic.Interpretation.ConfidenceMillis,
		DeterministicApplicability: cognitive.InterpretationApplicability(semantic.Interpretation.Applicability),
		RequestedOutcome:           semantic.Interpretation.RequestedOutcome,
		ProjectNames:               projectNames,
	}
}

func interactionCandidateFromGateway(utteranceID interaction.HumanUtteranceID, candidate cognitive.GatewayInterpretationCandidate, now interface{ UnixMilli() int64 }) (interaction.SemanticCandidate, error) {
	id, err := ids.New()
	if err != nil {
		return interaction.SemanticCandidate{}, err
	}
	return interaction.SemanticCandidate{
		ID:                   interaction.SemanticCandidateID(id),
		UtteranceID:          utteranceID,
		Source:               interaction.CandidateSourceCognitive,
		SelectionState:       interaction.CandidateSelected,
		PrimarySpeechAct:     interaction.SpeechAct(candidate.PrimarySpeechAct),
		SecondarySpeechAct:   interaction.SpeechAct(candidate.SecondarySpeechAct),
		ConfidenceMillis:     candidate.ConfidenceMillis,
		Applicability:        interaction.SemanticApplicability(candidate.Applicability),
		RequestedOutcome:     candidate.RequestedOutcome,
		Clarification:        interaction.ClarificationState(candidate.Clarification),
		NeedsCognition:       candidate.NeedsCognition,
		SelectionReason:      candidate.SelectionReason,
		CapabilityHints:      capabilityHintStrings(candidate.CapabilityHints),
		RecordedAtUnixMillis: now.UnixMilli(),
	}, nil
}

func capabilityHintStrings(values []capability.CapabilityKind) []string {
	result := make([]string, 0, len(values))
	for _, value := range values {
		if value == "" {
			continue
		}
		result = append(result, string(value))
	}
	return result
}