308 lines
20 KiB
Go
308 lines
20 KiB
Go
package domain
|
|
|
|
import (
|
|
"crypto/sha256"
|
|
"encoding/binary"
|
|
"encoding/hex"
|
|
"errors"
|
|
"fmt"
|
|
"slices"
|
|
"sort"
|
|
|
|
"git.cin.su/m/Assistant/contracts/capability"
|
|
)
|
|
|
|
var ErrInvalidCognitiveRegistryRecord = errors.New("invalid cognitive registry record")
|
|
var ErrNoInvocableCognitiveBinding = errors.New("no invocable cognitive binding")
|
|
|
|
func BuildDiscoveryRegistration(snapshot capability.CognitiveDiscoverySnapshot) (capability.CognitiveDiscoveryRegistration, error) {
|
|
if snapshot.ProviderInstanceID == "" || snapshot.ProviderKind == "" || snapshot.EndpointRef == "" || snapshot.OwnerPrincipalID == "" || snapshot.CapabilityID == "" || snapshot.LimitPolicyRef == "" || snapshot.ObservedAtUnixMillis < 1 || !validHealth(snapshot.Health) {
|
|
return capability.CognitiveDiscoveryRegistration{}, ErrInvalidCognitiveRegistryRecord
|
|
}
|
|
providerRevision := stableRevision(string(snapshot.ProviderKind), string(snapshot.EndpointRef), string(snapshot.CredentialRef), fmt.Sprint(snapshot.Enabled), string(snapshot.BillingMode), string(snapshot.AuthMode), fmt.Sprint(snapshot.InputCostMicros), fmt.Sprint(snapshot.OutputCostMicros), fmt.Sprint(snapshot.RequestCostMicros))
|
|
provider := capability.ProviderInstance{ID: snapshot.ProviderInstanceID, Revision: providerRevision, Kind: snapshot.ProviderKind, EndpointRef: snapshot.EndpointRef, CredentialRef: snapshot.CredentialRef, Enabled: snapshot.Enabled, Qualification: capability.QualificationDiscovered, Health: snapshot.Health, ObservedAtUnixMillis: snapshot.ObservedAtUnixMillis, BillingMode: snapshot.BillingMode, AuthMode: snapshot.AuthMode, InputCostMicros: snapshot.InputCostMicros, OutputCostMicros: snapshot.OutputCostMicros, RequestCostMicros: snapshot.RequestCostMicros}
|
|
registration := capability.CognitiveDiscoveryRegistration{Provider: provider, ProviderHealth: capability.ProviderHealthObservation{ProviderInstanceID: provider.ID, Health: snapshot.Health, ObservedAtUnixMillis: snapshot.ObservedAtUnixMillis, FailureClass: snapshot.FailureClass}}
|
|
for _, discovered := range snapshot.Models {
|
|
if discovered.ProviderModelID == "" || discovered.MaxContextBytes < 0 || len(discovered.Modalities) == 0 || len(discovered.Capabilities) == 0 || !validOperational(discovered.Installed) || !validOperational(discovered.Loaded) || !validOperational(discovered.Invokable) {
|
|
return capability.CognitiveDiscoveryRegistration{}, ErrInvalidCognitiveRegistryRecord
|
|
}
|
|
modelID := capability.ModelDescriptorID(stableID("model", string(snapshot.ProviderInstanceID), string(discovered.ProviderModelID)))
|
|
modelRevision := stableRevision(string(discovered.Fingerprint), fmt.Sprint(discovered.MaxContextBytes), fmt.Sprint(discovered.Modalities), fmt.Sprint(discovered.Capabilities), fmt.Sprint(discovered.IntelligenceScoreMillis))
|
|
model := capability.ModelDescriptor{ID: modelID, Revision: modelRevision, ProviderInstanceID: provider.ID, ProviderModelID: discovered.ProviderModelID, Fingerprint: discovered.Fingerprint, MaxContextBytes: discovered.MaxContextBytes, Modalities: append([]capability.ModelModality(nil), discovered.Modalities...), Capabilities: append([]capability.ModelCapability(nil), discovered.Capabilities...), Qualification: capability.QualificationDiscovered, Health: snapshot.Health, ObservedAtUnixMillis: snapshot.ObservedAtUnixMillis, IntelligenceScoreMillis: discovered.IntelligenceScoreMillis}
|
|
bindingID := capability.CapabilityBindingID(stableID("binding", string(snapshot.OwnerPrincipalID), string(snapshot.CapabilityID), string(provider.ID), string(model.ID)))
|
|
bindingRevision := stableRevision(fmt.Sprint(provider.Revision), fmt.Sprint(model.Revision), string(snapshot.DataPolicy), string(snapshot.LimitPolicyRef))
|
|
binding := capability.CognitiveBinding{ID: bindingID, Revision: bindingRevision, CapabilityID: snapshot.CapabilityID, OwnerPrincipalID: snapshot.OwnerPrincipalID, ProviderInstanceID: provider.ID, ProviderRevision: provider.Revision, ModelDescriptorID: model.ID, ModelRevision: model.Revision, DataPolicy: snapshot.DataPolicy, Qualification: capability.QualificationDiscovered, Activation: capability.ActivationInactive, Health: snapshot.Health, LimitPolicyRef: snapshot.LimitPolicyRef}
|
|
registration.Models = append(registration.Models, model)
|
|
registration.Bindings = append(registration.Bindings, binding)
|
|
registration.ModelAvailability = append(registration.ModelAvailability, capability.ModelOperationalObservation{ProviderInstanceID: provider.ID, ModelDescriptorID: model.ID, Installed: discovered.Installed, Loaded: discovered.Loaded, Invokable: discovered.Invokable, Health: snapshot.Health, ObservedAtUnixMillis: snapshot.ObservedAtUnixMillis})
|
|
}
|
|
return registration, nil
|
|
}
|
|
|
|
func BuildCanaryPromotion(request capability.CognitiveCanaryPromotionRequest, current capability.ResolvedCognitiveBinding) (capability.CognitiveCanaryPromotion, error) {
|
|
if request.PromotionID == "" || request.RequestedByPrincipalID == "" || request.CapabilityID == "" || request.BindingID == "" || request.ExpectedBindingRevision < 1 || request.ProviderInstanceID == "" || request.ExpectedProviderRevision < 1 || request.ModelDescriptorID == "" || request.ExpectedModelRevision < 1 || request.EvaluationID == "" || request.ObservedAtUnixMillis < 1 || current.Evaluation == nil {
|
|
return capability.CognitiveCanaryPromotion{}, ErrInvalidCognitiveRegistryRecord
|
|
}
|
|
if current.Binding.ID != request.BindingID || current.Binding.Revision != request.ExpectedBindingRevision || current.Binding.OwnerPrincipalID != request.RequestedByPrincipalID || current.Binding.CapabilityID != request.CapabilityID || current.Provider.ID != request.ProviderInstanceID || current.Provider.Revision != request.ExpectedProviderRevision || current.Model.ID != request.ModelDescriptorID || current.Model.Revision != request.ExpectedModelRevision || current.Evaluation.ID != request.EvaluationID || current.Evaluation.Result != capability.EvaluationSupported || current.Evaluation.QualityScoreMillis == nil || *current.Evaluation.QualityScoreMillis < 750 || current.Evaluation.CriticalFailureMillis == nil || *current.Evaluation.CriticalFailureMillis != 0 || current.Provider.Health != capability.HealthAvailable || current.Model.Health != capability.HealthAvailable || current.Binding.Activation != capability.ActivationInactive {
|
|
return capability.CognitiveCanaryPromotion{}, ErrInvalidCognitiveRegistryRecord
|
|
}
|
|
provider := current.Provider
|
|
provider.Revision = stableRevision(fmt.Sprint(provider.Revision), string(request.PromotionID), string(capability.QualificationValidated))
|
|
provider.Qualification, provider.Health, provider.ObservedAtUnixMillis = capability.QualificationValidated, capability.HealthAvailable, request.ObservedAtUnixMillis
|
|
model := current.Model
|
|
model.Revision = stableRevision(fmt.Sprint(model.Revision), string(request.PromotionID), string(capability.QualificationValidated))
|
|
model.Qualification, model.Health, model.ObservedAtUnixMillis = capability.QualificationValidated, capability.HealthAvailable, request.ObservedAtUnixMillis
|
|
binding := current.Binding
|
|
binding.Revision = stableRevision(fmt.Sprint(binding.Revision), fmt.Sprint(provider.Revision), fmt.Sprint(model.Revision), string(request.PromotionID), string(capability.ActivationCanary))
|
|
binding.ProviderRevision, binding.ModelRevision = provider.Revision, model.Revision
|
|
binding.Qualification, binding.Activation, binding.Health = capability.QualificationValidated, capability.ActivationCanary, capability.HealthAvailable
|
|
evaluation := *current.Evaluation
|
|
evaluation.ID = capability.EvaluationID(stableID("evaluation", string(request.PromotionID), string(binding.ID), fmt.Sprint(binding.Revision)))
|
|
evaluation.BindingRevision = binding.Revision
|
|
return capability.CognitiveCanaryPromotion{PromotionID: request.PromotionID, ExpectedBindingRevision: request.ExpectedBindingRevision, Provider: provider, Model: model, Binding: binding, Evaluation: evaluation}, nil
|
|
}
|
|
|
|
func BuildActivationPromotion(request capability.CognitiveActivationPromotionRequest, current capability.ResolvedCognitiveBinding) (capability.CognitiveActivationPromotion, error) {
|
|
if request.PromotionID == "" || request.RequestedByPrincipalID == "" || request.CapabilityID == "" || request.BindingID == "" || request.ExpectedBindingRevision < 1 || request.EvaluationID == "" || request.ObservedAtUnixMillis < 1 || current.Evaluation == nil {
|
|
return capability.CognitiveActivationPromotion{}, ErrInvalidCognitiveRegistryRecord
|
|
}
|
|
if current.Binding.ID != request.BindingID || current.Binding.Revision != request.ExpectedBindingRevision || current.Binding.OwnerPrincipalID != request.RequestedByPrincipalID || current.Binding.CapabilityID != request.CapabilityID || current.Evaluation.ID != request.EvaluationID || current.Evaluation.Result != capability.EvaluationSupported || current.Evaluation.QualityScoreMillis == nil || *current.Evaluation.QualityScoreMillis < 750 || current.Evaluation.CriticalFailureMillis == nil || *current.Evaluation.CriticalFailureMillis != 0 || current.Provider.Health != capability.HealthAvailable || current.Model.Health != capability.HealthAvailable || current.Binding.Qualification != capability.QualificationValidated || current.Binding.Activation != capability.ActivationCanary || current.Binding.Health != capability.HealthAvailable {
|
|
return capability.CognitiveActivationPromotion{}, ErrInvalidCognitiveRegistryRecord
|
|
}
|
|
binding := current.Binding
|
|
binding.Revision = stableRevision(fmt.Sprint(binding.Revision), string(request.PromotionID), string(capability.ActivationActive))
|
|
binding.Qualification, binding.Activation, binding.Health = capability.QualificationValidated, capability.ActivationActive, capability.HealthAvailable
|
|
evaluation := *current.Evaluation
|
|
evaluation.ID = capability.EvaluationID(stableID("evaluation", string(request.PromotionID), string(binding.ID), fmt.Sprint(binding.Revision)))
|
|
evaluation.BindingRevision = binding.Revision
|
|
return capability.CognitiveActivationPromotion{PromotionID: request.PromotionID, ExpectedBindingRevision: request.ExpectedBindingRevision, Binding: binding, Evaluation: evaluation}, nil
|
|
}
|
|
|
|
func stableID(kind string, parts ...string) string {
|
|
hash := sha256.New()
|
|
_, _ = hash.Write([]byte(kind))
|
|
for _, part := range parts {
|
|
_, _ = hash.Write([]byte{0})
|
|
_, _ = hash.Write([]byte(part))
|
|
}
|
|
return kind + "-" + hex.EncodeToString(hash.Sum(nil))[:24]
|
|
}
|
|
|
|
func stableRevision(parts ...string) int64 {
|
|
hash := sha256.New()
|
|
for _, part := range parts {
|
|
_, _ = hash.Write([]byte{0})
|
|
_, _ = hash.Write([]byte(part))
|
|
}
|
|
return int64(binary.BigEndian.Uint64(hash.Sum(nil)[:8])&0x3fffffffffffffff) + 1
|
|
}
|
|
|
|
func ValidateProviderInstance(value capability.ProviderInstance) error {
|
|
if value.ID == "" || value.Revision < 1 || value.Kind == "" || value.EndpointRef == "" || !validQualification(value.Qualification) || !validHealth(value.Health) || value.ObservedAtUnixMillis < 1 || !validBillingMode(value.BillingMode) || !validAuthMode(value.AuthMode) || !validNonNegative(value.InputCostMicros) || !validNonNegative(value.OutputCostMicros) || !validNonNegative(value.RequestCostMicros) {
|
|
return ErrInvalidCognitiveRegistryRecord
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func ValidateModelDescriptor(value capability.ModelDescriptor) error {
|
|
if value.ID == "" || value.Revision < 1 || value.ProviderInstanceID == "" || value.ProviderModelID == "" || value.MaxContextBytes < 0 || len(value.Modalities) == 0 || len(value.Capabilities) == 0 || !validQualification(value.Qualification) || !validHealth(value.Health) || value.ObservedAtUnixMillis < 1 || !validNonNegative(value.IntelligenceScoreMillis) {
|
|
return ErrInvalidCognitiveRegistryRecord
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func ValidateCognitiveBinding(value capability.CognitiveBinding) error {
|
|
if value.ID == "" || value.Revision < 1 || value.CapabilityID == "" || value.OwnerPrincipalID == "" || value.ProviderInstanceID == "" || value.ProviderRevision < 1 || value.ModelDescriptorID == "" || value.ModelRevision < 1 || value.LimitPolicyRef == "" || !validQualification(value.Qualification) || !validActivation(value.Activation) || !validHealth(value.Health) {
|
|
return ErrInvalidCognitiveRegistryRecord
|
|
}
|
|
switch value.DataPolicy {
|
|
case capability.DataPolicyLocalOnly, capability.DataPolicyExternalMessageOnly, capability.DataPolicyExternalMinimizedContext:
|
|
return nil
|
|
default:
|
|
return ErrInvalidCognitiveRegistryRecord
|
|
}
|
|
}
|
|
|
|
func SelectCognitiveBinding(requirement capability.CognitiveRequirement, candidates []capability.ResolvedCognitiveBinding) (capability.ResolvedCognitiveBinding, error) {
|
|
eligible := make([]capability.ResolvedCognitiveBinding, 0, len(candidates))
|
|
for _, candidate := range candidates {
|
|
binding, provider, model := candidate.Binding, candidate.Provider, candidate.Model
|
|
if slices.Contains(requirement.ExcludedBindingIDs, binding.ID) {
|
|
continue
|
|
}
|
|
if ValidateCognitiveBinding(binding) != nil || ValidateProviderInstance(provider) != nil || ValidateModelDescriptor(model) != nil {
|
|
continue
|
|
}
|
|
if binding.CapabilityID != requirement.CapabilityID || binding.OwnerPrincipalID != requirement.OwnerPrincipalID || !dataPolicySatisfies(binding.DataPolicy, requirement.DataPolicy) || binding.Qualification != capability.QualificationValidated || binding.Health != capability.HealthAvailable || !provider.Enabled || provider.Qualification != capability.QualificationValidated || provider.Health != capability.HealthAvailable || model.Qualification != capability.QualificationValidated || model.Health != capability.HealthAvailable {
|
|
continue
|
|
}
|
|
if binding.ProviderInstanceID != provider.ID || binding.ProviderRevision != provider.Revision || binding.ModelDescriptorID != model.ID || binding.ModelRevision != model.Revision || model.ProviderInstanceID != provider.ID || requirement.InputBytes+requirement.MaxOutputBytes > model.MaxContextBytes {
|
|
continue
|
|
}
|
|
if binding.Activation != capability.ActivationActive && !(requirement.AllowCanary && binding.Activation == capability.ActivationCanary) {
|
|
continue
|
|
}
|
|
if !containsAll(model.Modalities, requirement.RequiredModalities) || !supportsCapabilities(candidate, requirement.RequiredCapabilities) {
|
|
continue
|
|
}
|
|
if candidate.Evaluation != nil && candidate.Evaluation.Result == capability.EvaluationUnsupported {
|
|
continue
|
|
}
|
|
if requirement.MaxCostMicros != nil {
|
|
cost, known := estimatedCost(candidate.Provider, requirement.InputBytes, requirement.MaxOutputBytes)
|
|
if known && cost > *requirement.MaxCostMicros {
|
|
continue
|
|
}
|
|
}
|
|
eligible = append(eligible, candidate)
|
|
}
|
|
if len(eligible) > 0 {
|
|
sort.SliceStable(eligible, func(i, j int) bool {
|
|
return betterCandidate(eligible[i], eligible[j], requirement.Objective, requirement.InputBytes, requirement.MaxOutputBytes)
|
|
})
|
|
return eligible[0], nil
|
|
}
|
|
return capability.ResolvedCognitiveBinding{}, ErrNoInvocableCognitiveBinding
|
|
}
|
|
|
|
func dataPolicySatisfies(actual, allowed capability.DataPolicy) bool {
|
|
return actual == capability.DataPolicyLocalOnly || actual == allowed
|
|
}
|
|
|
|
func supportsCapabilities(candidate capability.ResolvedCognitiveBinding, required []capability.ModelCapability) bool {
|
|
for _, item := range required {
|
|
if slices.Contains(candidate.Model.Capabilities, item) {
|
|
continue
|
|
}
|
|
if candidate.Evaluation == nil || candidate.Evaluation.CapabilityID != candidate.Binding.CapabilityID || candidate.Evaluation.Result != capability.EvaluationSupported {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func betterCandidate(left, right capability.ResolvedCognitiveBinding, objective capability.SelectionObjective, inputBytes, outputBytes int64) bool {
|
|
if objective == capability.SelectionEconomy {
|
|
lc, lk := estimatedCost(left.Provider, inputBytes, outputBytes)
|
|
rc, rk := estimatedCost(right.Provider, inputBytes, outputBytes)
|
|
if lk != rk {
|
|
return lk
|
|
}
|
|
if lk && lc != rc {
|
|
return lc < rc
|
|
}
|
|
}
|
|
if objective == capability.SelectionSpeed {
|
|
if lp, rp := left.Performance, right.Performance; lp != nil && rp != nil && lp.LatencyMicros != nil && rp.LatencyMicros != nil && *lp.LatencyMicros != *rp.LatencyMicros {
|
|
return *lp.LatencyMicros < *rp.LatencyMicros
|
|
}
|
|
}
|
|
if objective == capability.SelectionQuality || objective == capability.SelectionBalanced || objective == "" {
|
|
li, ri := left.Model.IntelligenceScoreMillis, right.Model.IntelligenceScoreMillis
|
|
if li != nil && ri != nil && *li != *ri {
|
|
return *li > *ri
|
|
}
|
|
}
|
|
le, re := left.Evaluation, right.Evaluation
|
|
if le != nil && le.Result == capability.EvaluationSupported && (re == nil || re.Result != capability.EvaluationSupported) {
|
|
return true
|
|
}
|
|
if re != nil && re.Result == capability.EvaluationSupported && (le == nil || le.Result != capability.EvaluationSupported) {
|
|
return false
|
|
}
|
|
if le != nil && re != nil && le.QualityScoreMillis != nil && re.QualityScoreMillis != nil && *le.QualityScoreMillis != *re.QualityScoreMillis {
|
|
return *le.QualityScoreMillis > *re.QualityScoreMillis
|
|
}
|
|
if le != nil && re != nil && le.CriticalFailureMillis != nil && re.CriticalFailureMillis != nil && *le.CriticalFailureMillis != *re.CriticalFailureMillis {
|
|
return *le.CriticalFailureMillis < *re.CriticalFailureMillis
|
|
}
|
|
lp, rp := left.Performance, right.Performance
|
|
if lp != nil && rp != nil && lp.ReliabilityMillis != nil && rp.ReliabilityMillis != nil && *lp.ReliabilityMillis != *rp.ReliabilityMillis {
|
|
return *lp.ReliabilityMillis > *rp.ReliabilityMillis
|
|
}
|
|
if lp != nil && rp != nil && lp.LatencyMicros != nil && rp.LatencyMicros != nil && *lp.LatencyMicros != *rp.LatencyMicros {
|
|
return *lp.LatencyMicros < *rp.LatencyMicros
|
|
}
|
|
if lp != nil && rp != nil && lp.GenerationTPSMillis != nil && rp.GenerationTPSMillis != nil && *lp.GenerationTPSMillis != *rp.GenerationTPSMillis {
|
|
return *lp.GenerationTPSMillis > *rp.GenerationTPSMillis
|
|
}
|
|
return string(left.Binding.ID) < string(right.Binding.ID)
|
|
}
|
|
|
|
func estimatedCost(provider capability.ProviderInstance, inputBytes, outputBytes int64) (int64, bool) {
|
|
var total int64
|
|
known := false
|
|
if provider.InputCostMicros != nil {
|
|
total += *provider.InputCostMicros * inputBytes
|
|
known = true
|
|
}
|
|
if provider.OutputCostMicros != nil {
|
|
total += *provider.OutputCostMicros * outputBytes
|
|
known = true
|
|
}
|
|
if provider.RequestCostMicros != nil {
|
|
total += *provider.RequestCostMicros
|
|
known = true
|
|
}
|
|
return total, known
|
|
}
|
|
|
|
func validNonNegative(value *int64) bool { return value == nil || *value >= 0 }
|
|
|
|
func validBillingMode(value capability.BillingMode) bool {
|
|
switch value {
|
|
case "", capability.BillingUnknown, capability.BillingFree, capability.BillingPerInput, capability.BillingPerOutput, capability.BillingPerRequest:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func validAuthMode(value capability.AuthMode) bool {
|
|
switch value {
|
|
case "", capability.AuthNone, capability.AuthKey, capability.AuthBearer, capability.AuthUsernamePassword, capability.AuthOAuth, capability.AuthSecretFile:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
func containsAll[T comparable](actual, required []T) bool {
|
|
for _, item := range required {
|
|
if !slices.Contains(actual, item) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
func validQualification(value capability.QualificationState) bool {
|
|
switch value {
|
|
case capability.QualificationDiscovered, capability.QualificationProbing, capability.QualificationEvaluating, capability.QualificationValidated, capability.QualificationRejected:
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
func validActivation(value capability.ActivationState) bool {
|
|
switch value {
|
|
case capability.ActivationInactive, capability.ActivationCanary, capability.ActivationActive, capability.ActivationDeprecated, capability.ActivationRetired:
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
func validHealth(value capability.HealthState) bool {
|
|
switch value {
|
|
case capability.HealthUnknown, capability.HealthAvailable, capability.HealthDegraded, capability.HealthUnavailable:
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
func validOperational(value capability.OperationalState) bool {
|
|
switch value {
|
|
case capability.OperationalNotObserved, capability.OperationalYes, capability.OperationalNo:
|
|
return true
|
|
}
|
|
return false
|
|
}
|