feat: evolve Domovoy cognitive provider catalog
CI / test (push) Failing after 16s

This commit is contained in:
m
2026-08-21 18:37:04 +03:00
parent 0482e6ac14
commit 3d7836d37c
15 changed files with 537 additions and 123 deletions
@@ -19,16 +19,16 @@ func BuildDiscoveryRegistration(snapshot capability.CognitiveDiscoverySnapshot)
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: snapshot.Health, ObservedAtUnixMillis: snapshot.ObservedAtUnixMillis}
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))
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}
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}
@@ -98,14 +98,14 @@ func stableRevision(parts ...string) int64 {
}
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 {
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 {
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
@@ -148,10 +148,18 @@ func SelectCognitiveBinding(requirement capability.CognitiveRequirement, candida
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]) })
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
@@ -173,7 +181,28 @@ func supportsCapabilities(candidate capability.ResolvedCognitiveBinding, require
return true
}
func betterCandidate(left, right capability.ResolvedCognitiveBinding) bool {
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
@@ -200,6 +229,44 @@ func betterCandidate(left, right capability.ResolvedCognitiveBinding) bool {
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) {
@@ -7,6 +7,8 @@ import (
)
func TestBuildDiscoveryRegistrationCarriesObservedHealthToCanaryPrecondition(t *testing.T) {
inputCost := int64(2)
intelligence := int64(820)
registration, err := BuildDiscoveryRegistration(capability.CognitiveDiscoverySnapshot{
ProviderInstanceID: "local-lifeboat",
ProviderKind: "openai-compatible-chat-v1",
@@ -17,15 +19,19 @@ func TestBuildDiscoveryRegistrationCarriesObservedHealthToCanaryPrecondition(t *
LimitPolicyRef: "creator-advisory-local-v1",
Health: capability.HealthAvailable,
ObservedAtUnixMillis: 1000,
BillingMode: capability.BillingPerInput,
AuthMode: capability.AuthKey,
InputCostMicros: &inputCost,
Models: []capability.DiscoveredModelSnapshot{{
ProviderModelID: "domovoy-lifeboat",
Fingerprint: "fingerprint",
MaxContextBytes: 32768,
Modalities: []capability.ModelModality{capability.ModalityText},
Capabilities: []capability.ModelCapability{capability.CapabilityAdvisory},
Installed: capability.OperationalYes,
Loaded: capability.OperationalNotObserved,
Invokable: capability.OperationalYes,
ProviderModelID: "domovoy-lifeboat",
Fingerprint: "fingerprint",
MaxContextBytes: 32768,
Modalities: []capability.ModelModality{capability.ModalityText},
Capabilities: []capability.ModelCapability{capability.CapabilityAdvisory},
Installed: capability.OperationalYes,
Loaded: capability.OperationalNotObserved,
Invokable: capability.OperationalYes,
IntelligenceScoreMillis: &intelligence,
}},
})
if err != nil {
@@ -37,6 +43,17 @@ func TestBuildDiscoveryRegistrationCarriesObservedHealthToCanaryPrecondition(t *
if registration.Models[0].Health != capability.HealthAvailable || registration.Bindings[0].Health != capability.HealthAvailable {
t.Fatalf("discovery health was not carried into canary candidates: model=%s binding=%s", registration.Models[0].Health, registration.Bindings[0].Health)
}
if registration.Provider.AuthMode != capability.AuthKey || registration.Provider.InputCostMicros == nil || *registration.Provider.InputCostMicros != inputCost || registration.Models[0].IntelligenceScoreMillis == nil || *registration.Models[0].IntelligenceScoreMillis != intelligence {
t.Fatalf("discovery profile was not carried into registry: provider=%+v model=%+v", registration.Provider, registration.Models[0])
}
inputCostChanged := int64(3)
changed, err := BuildDiscoveryRegistration(capability.CognitiveDiscoverySnapshot{
ProviderInstanceID: "local-lifeboat", ProviderKind: "openai-compatible-chat-v1", EndpointRef: "local-lifeboat-v1", OwnerPrincipalID: "domovoy-creator-principal", CapabilityID: "creator-advisory", DataPolicy: capability.DataPolicyLocalOnly, LimitPolicyRef: "creator-advisory-local-v1", Health: capability.HealthAvailable, ObservedAtUnixMillis: 1001, BillingMode: capability.BillingPerInput, AuthMode: capability.AuthKey, InputCostMicros: &inputCostChanged,
Models: []capability.DiscoveredModelSnapshot{{ProviderModelID: "domovoy-lifeboat", Fingerprint: "fingerprint", MaxContextBytes: 32768, Modalities: []capability.ModelModality{capability.ModalityText}, Capabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, Installed: capability.OperationalYes, Loaded: capability.OperationalNotObserved, Invokable: capability.OperationalYes, IntelligenceScoreMillis: &intelligence}},
})
if err != nil || changed.Provider.Revision == registration.Provider.Revision {
t.Fatalf("provider profile change did not create a new revision: first=%d changed=%d err=%v", registration.Provider.Revision, changed.Provider.Revision, err)
}
}
func TestBuildActivationPromotionRequiresHealthyCanary(t *testing.T) {
@@ -57,3 +74,31 @@ func TestBuildActivationPromotionRequiresHealthyCanary(t *testing.T) {
t.Fatal("expected inactive binding to be rejected")
}
}
func TestSelectCognitiveBindingUsesObjectiveAndCost(t *testing.T) {
quality := int64(800)
critical := int64(0)
fast := int64(100)
slow := int64(900)
cheap := int64(1)
expensive := int64(10)
candidate := func(id string, intelligence, latency, cost int64) capability.ResolvedCognitiveBinding {
return capability.ResolvedCognitiveBinding{
Binding: capability.CognitiveBinding{ID: capability.CapabilityBindingID(id), Revision: 1, CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", ProviderInstanceID: capability.ProviderInstanceID(id), ProviderRevision: 1, ModelDescriptorID: capability.ModelDescriptorID(id), ModelRevision: 1, DataPolicy: capability.DataPolicyLocalOnly, Qualification: capability.QualificationValidated, Activation: capability.ActivationActive, Health: capability.HealthAvailable, LimitPolicyRef: "limits"},
Provider: capability.ProviderInstance{ID: capability.ProviderInstanceID(id), Revision: 1, Kind: "builtin", EndpointRef: capability.EndpointBindingRef(id), Enabled: true, Qualification: capability.QualificationValidated, Health: capability.HealthAvailable, ObservedAtUnixMillis: 1, BillingMode: capability.BillingPerRequest, RequestCostMicros: &cost},
Model: capability.ModelDescriptor{ID: capability.ModelDescriptorID(id), Revision: 1, ProviderInstanceID: capability.ProviderInstanceID(id), ProviderModelID: capability.ProviderModelID(id), MaxContextBytes: 10000, Modalities: []capability.ModelModality{capability.ModalityText}, Capabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, Qualification: capability.QualificationValidated, Health: capability.HealthAvailable, ObservedAtUnixMillis: 1, IntelligenceScoreMillis: &intelligence},
Evaluation: &capability.EvaluatedCapability{ID: capability.EvaluationID("eval-" + id), Result: capability.EvaluationSupported, QualityScoreMillis: &quality, CriticalFailureMillis: &critical},
Performance: &capability.PerformanceEvidence{LatencyMicros: &latency},
}
}
qualityCandidate := candidate("quality", slow, slow, expensive)
fastCandidate := candidate("fast", fast, fast, cheap)
selected, err := SelectCognitiveBinding(capability.CognitiveRequirement{CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", DataPolicy: capability.DataPolicyLocalOnly, RequiredModalities: []capability.ModelModality{capability.ModalityText}, RequiredCapabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, MaxOutputBytes: 10, Objective: capability.SelectionQuality}, []capability.ResolvedCognitiveBinding{qualityCandidate, fastCandidate})
if err != nil || selected.Binding.ID != "quality" {
t.Fatalf("quality selection=%+v err=%v", selected, err)
}
selected, err = SelectCognitiveBinding(capability.CognitiveRequirement{CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", DataPolicy: capability.DataPolicyLocalOnly, RequiredModalities: []capability.ModelModality{capability.ModalityText}, RequiredCapabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, MaxOutputBytes: 10, Objective: capability.SelectionEconomy, MaxCostMicros: &cheap}, []capability.ResolvedCognitiveBinding{qualityCandidate, fastCandidate})
if err != nil || selected.Binding.ID != "fast" {
t.Fatalf("economy selection=%+v err=%v", selected, err)
}
}