feat(cognitive): add local provider registry and discovery
This commit is contained in:
@@ -0,0 +1,201 @@
|
||||
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))
|
||||
provider := capability.ProviderInstance{ID: snapshot.ProviderInstanceID, Revision: providerRevision, Kind: snapshot.ProviderKind, EndpointRef: snapshot.EndpointRef, CredentialRef: snapshot.CredentialRef, Enabled: snapshot.Enabled, Qualification: capability.QualificationDiscovered, Health: capability.HealthUnknown, ObservedAtUnixMillis: snapshot.ObservedAtUnixMillis}
|
||||
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))
|
||||
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: capability.HealthUnknown, ObservedAtUnixMillis: snapshot.ObservedAtUnixMillis}
|
||||
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: capability.HealthUnknown, 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 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 {
|
||||
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 {
|
||||
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
|
||||
}
|
||||
eligible = append(eligible, candidate)
|
||||
}
|
||||
if len(eligible) > 0 {
|
||||
sort.SliceStable(eligible, func(i, j int) bool { return betterCandidate(eligible[i], eligible[j]) })
|
||||
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) bool {
|
||||
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 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
|
||||
}
|
||||
@@ -14,4 +14,12 @@ type Repository interface {
|
||||
SaveBinding(context.Context, capability.Binding) error
|
||||
LoadBinding(context.Context, capability.CapabilityBindingID, int64) (capability.Binding, error)
|
||||
LoadActiveBinding(context.Context, capability.CapabilityID, identity.PrincipalID) (capability.Binding, error)
|
||||
SaveProviderInstance(context.Context, capability.ProviderInstance) error
|
||||
SaveModelDescriptor(context.Context, capability.ModelDescriptor) error
|
||||
SaveCognitiveBinding(context.Context, capability.CognitiveBinding) error
|
||||
LoadCognitiveCandidates(context.Context, capability.CapabilityID, identity.PrincipalID) ([]capability.ResolvedCognitiveBinding, error)
|
||||
SaveCognitiveUsageObservation(context.Context, capability.CognitiveUsageObservation) error
|
||||
SaveCognitiveDiscovery(context.Context, capability.CognitiveDiscoveryRegistration) error
|
||||
SaveEvaluatedCapability(context.Context, capability.EvaluatedCapability) error
|
||||
SavePerformanceEvidence(context.Context, capability.PerformanceEvidence) error
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user