feat(cognitive): add local provider registry and discovery

This commit is contained in:
m
2026-08-17 09:28:33 +03:00
parent 9e99a04c76
commit a25a57ab69
38 changed files with 2344 additions and 116 deletions
+37
View File
@@ -0,0 +1,37 @@
package cognitive_providers_test
import (
"context"
"os"
"testing"
"time"
"git.cin.su/m/Assistant/adapters/models"
"git.cin.su/m/Assistant/contracts/capability"
)
func TestLiveReadOnlyDiscovery(t *testing.T) {
if os.Getenv("ASSISTANT_LIVE_LOCAL_DISCOVERY") != "1" {
t.Skip("set ASSISTANT_LIVE_LOCAL_DISCOVERY=1 for read-only local provider probes")
}
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
defer cancel()
cpu, err := models.NewOpenAICompatibleLocalAdapter("http://docker.cin.su:18082/v1", nil)
if err != nil {
t.Fatal(err)
}
cpuModels, cpuProbe := cpu.Discover(ctx)
if cpuProbe.Health != capability.HealthAvailable || len(cpuModels) == 0 {
t.Fatalf("CPU probe=%+v models=%+v", cpuProbe, cpuModels)
}
t.Logf("CPU probe=%+v models=%+v", cpuProbe, cpuModels)
gpu, err := models.NewOllamaAdapter("http://192.168.220.91:11434", nil)
if err != nil {
t.Fatal(err)
}
gpuModels, gpuProbe := gpu.Discover(ctx)
if gpuProbe.Health != capability.HealthAvailable || len(gpuModels) == 0 {
t.Fatalf("GPU probe=%+v models=%+v", gpuProbe, gpuModels)
}
t.Logf("GPU probe=%+v models=%+v", gpuProbe, gpuModels)
}
@@ -0,0 +1,86 @@
package cognitive_providers_test
import (
"context"
"io"
"net/http"
"net/http/httptest"
"strings"
"testing"
"git.cin.su/m/Assistant/adapters/models"
"git.cin.su/m/Assistant/contracts/capability"
capabilitydomain "git.cin.su/m/Assistant/modules/capability/domain"
)
func TestCPUDiscoveryIsReadOnlyAndCredentialFree(t *testing.T) {
requests := 0
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
requests++
if r.Method != http.MethodGet || r.URL.Path != "/v1/models" || r.Header.Get("Authorization") != "" {
t.Fatalf("unexpected request %s %s auth=%q", r.Method, r.URL.Path, r.Header.Get("Authorization"))
}
_, _ = io.WriteString(w, `{"data":[{"id":"same-name","created":1,"owned_by":"local","meta":{"n_ctx":2048,"n_params":3,"size":10,"ftype":"Q4"}}]}`)
}))
defer server.Close()
adapter, err := models.NewOpenAICompatibleLocalAdapter(server.URL+"/v1", nil)
if err != nil {
t.Fatal(err)
}
discovered, probe := adapter.Discover(context.Background())
if probe.Health != capability.HealthAvailable || len(discovered) != 1 || requests != 1 {
t.Fatalf("probe=%+v models=%+v requests=%d", probe, discovered, requests)
}
}
func TestOllamaDiscoveryDoesNotRunInference(t *testing.T) {
paths := []string{}
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
paths = append(paths, r.URL.Path)
switch r.URL.Path {
case "/api/version":
_, _ = io.WriteString(w, `{"version":"1.2.3"}`)
case "/api/tags":
_, _ = io.WriteString(w, `{"models":[{"name":"same-name","model":"same-name","size":20,"digest":"digest-a","details":{"format":"gguf","quantization_level":"Q4","context_length":4096},"capabilities":["completion"]}]}`)
default:
t.Fatalf("unexpected expensive endpoint %s", r.URL.Path)
}
}))
defer server.Close()
adapter, err := models.NewOllamaAdapter(server.URL, nil)
if err != nil {
t.Fatal(err)
}
discovered, probe := adapter.Discover(context.Background())
if probe.Health != capability.HealthAvailable || len(discovered) != 1 || strings.Join(paths, ",") != "/api/version,/api/tags" {
t.Fatalf("probe=%+v models=%+v paths=%v", probe, discovered, paths)
}
}
func TestDiscoveryIsIdempotentAndProviderScoped(t *testing.T) {
base := capability.CognitiveDiscoverySnapshot{ProviderInstanceID: "cpu", ProviderKind: "kind", EndpointRef: "endpoint", Enabled: true, OwnerPrincipalID: "owner", CapabilityID: "creator-advisory", DataPolicy: capability.DataPolicyLocalOnly, LimitPolicyRef: "limits", Health: capability.HealthAvailable, ObservedAtUnixMillis: 1, Models: []capability.DiscoveredModelSnapshot{{ProviderModelID: "same-name", Fingerprint: "digest-a", MaxContextBytes: 100, Modalities: []capability.ModelModality{capability.ModalityText}, Capabilities: []capability.ModelCapability{capability.CapabilityUnknown}, Installed: capability.OperationalYes, Loaded: capability.OperationalNotObserved, Invokable: capability.OperationalNotObserved}}}
first, err := capabilitydomain.BuildDiscoveryRegistration(base)
if err != nil {
t.Fatal(err)
}
second, err := capabilitydomain.BuildDiscoveryRegistration(base)
if err != nil {
t.Fatal(err)
}
if first.Models[0].ID != second.Models[0].ID || first.Models[0].Revision != second.Models[0].Revision || first.Bindings[0].Activation != capability.ActivationInactive {
t.Fatalf("discovery not idempotent/inactive: %+v %+v", first, second)
}
gpu := base
gpu.ProviderInstanceID = "gpu"
other, _ := capabilitydomain.BuildDiscoveryRegistration(gpu)
if first.Models[0].ID == other.Models[0].ID {
t.Fatal("same model name collided across providers")
}
changed := base
changed.Models = append([]capability.DiscoveredModelSnapshot(nil), base.Models...)
changed.Models[0].Fingerprint = "digest-b"
revision, _ := capabilitydomain.BuildDiscoveryRegistration(changed)
if revision.Models[0].Revision == first.Models[0].Revision {
t.Fatal("digest change silently reused revision")
}
}
+147
View File
@@ -0,0 +1,147 @@
package cognitive_registry_test
import (
"os"
"path/filepath"
"strings"
"testing"
"git.cin.su/m/Assistant/contracts/capability"
capabilitydomain "git.cin.su/m/Assistant/modules/capability/domain"
)
func validCandidate() capability.ResolvedCognitiveBinding {
return capability.ResolvedCognitiveBinding{
Binding: capability.CognitiveBinding{ID: "binding-1", Revision: 3, CapabilityID: "creator-advisory", OwnerPrincipalID: "principal-1", ProviderInstanceID: "provider-1", ProviderRevision: 2, ModelDescriptorID: "model-1", ModelRevision: 4, DataPolicy: capability.DataPolicyExternalMessageOnly, Qualification: capability.QualificationValidated, Activation: capability.ActivationActive, Health: capability.HealthAvailable, LimitPolicyRef: "limits-1"},
Provider: capability.ProviderInstance{ID: "provider-1", Revision: 2, Kind: "external-responses-v1", EndpointRef: "endpoint-1", CredentialRef: "credential-1", Enabled: true, Qualification: capability.QualificationValidated, Health: capability.HealthAvailable, ObservedAtUnixMillis: 1},
Model: capability.ModelDescriptor{ID: "model-1", Revision: 4, ProviderInstanceID: "provider-1", ProviderModelID: "snapshot-1", Fingerprint: "fingerprint-1", MaxContextBytes: 32768, Modalities: []capability.ModelModality{capability.ModalityText}, Capabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, Qualification: capability.QualificationValidated, Health: capability.HealthAvailable, ObservedAtUnixMillis: 1},
}
}
func requirement() capability.CognitiveRequirement {
return capability.CognitiveRequirement{CapabilityID: "creator-advisory", OwnerPrincipalID: "principal-1", DataPolicy: capability.DataPolicyExternalMessageOnly, RequiredModalities: []capability.ModelModality{capability.ModalityText}, RequiredCapabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, InputBytes: 100, MaxOutputBytes: 1000}
}
func TestRegisteredButDisabledProviderCannotBeInvoked(t *testing.T) {
candidate := validCandidate()
candidate.Provider.Enabled = false
if _, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{candidate}); err == nil {
t.Fatal("disabled provider was selected")
}
}
func TestDiscoveredInactiveBindingCannotBeInvoked(t *testing.T) {
candidate := validCandidate()
candidate.Binding.Qualification = capability.QualificationDiscovered
candidate.Binding.Activation = capability.ActivationInactive
if _, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{candidate}); err == nil {
t.Fatal("discovered inactive binding was selected")
}
}
func TestValidatedActiveBindingCanBeSelected(t *testing.T) {
selected, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{validCandidate()})
if err != nil || selected.Binding.ID != "binding-1" {
t.Fatalf("selected=%+v err=%v", selected, err)
}
}
func TestRetiredBindingCannotBeInvoked(t *testing.T) {
candidate := validCandidate()
candidate.Binding.Activation = capability.ActivationRetired
if _, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{candidate}); err == nil {
t.Fatal("retired binding was selected")
}
}
func TestHealthTransitionsChangeEligibility(t *testing.T) {
for _, state := range []capability.HealthState{capability.HealthUnknown, capability.HealthDegraded, capability.HealthUnavailable} {
candidate := validCandidate()
candidate.Binding.Health = state
if _, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{candidate}); err == nil {
t.Fatalf("binding health %s was selected", state)
}
}
if _, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{validCandidate()}); err != nil {
t.Fatalf("available binding rejected: %v", err)
}
}
func TestCreatorWebHasNoConcreteProviderModelOrBindingSelection(t *testing.T) {
root := filepath.Clean(filepath.Join("..", "..", "cmd", "creator-web"))
err := filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error {
if err != nil || entry.IsDir() || strings.HasSuffix(path, "_test.go") {
return err
}
contents, readErr := os.ReadFile(path)
if readErr != nil {
return readErr
}
lower := strings.ToLower(string(contents))
for _, forbidden := range []string{"openai", "ollama", "providerbindingid", "advisory_binding_mode", "gpt-"} {
if strings.Contains(lower, forbidden) {
t.Errorf("%s contains concrete selection token %q", path, forbidden)
}
}
return nil
})
if err != nil {
t.Fatal(err)
}
}
func TestRegistryPersistenceContainsReferencesNotCredentialMaterial(t *testing.T) {
for _, path := range []string{filepath.Join("..", "..", "database", "migrations", "012_capability_cognitive_registry.sql"), filepath.Join("..", "..", "contracts", "capability", "cognitive_registry.go")} {
contents, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
lower := strings.ToLower(string(contents))
if !strings.Contains(lower, "credentialref") && !strings.Contains(lower, "credential_ref") {
t.Fatalf("%s lacks credential reference", path)
}
for _, forbidden := range []string{"api_key", "access_token", "credential_bytes", "plaintext_password"} {
if strings.Contains(lower, forbidden) {
t.Fatalf("%s stores forbidden credential material field %q", path, forbidden)
}
}
}
}
func TestMigrationUsesOnlyCapabilityOwnerRoleAndSchema(t *testing.T) {
path := filepath.Join("..", "..", "database", "migrations", "012_capability_cognitive_registry.sql")
contents, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
lower := strings.ToLower(string(contents))
if strings.Count(lower, "set role capability_role") != 1 {
t.Fatal("migration must execute under capability_role")
}
for _, schema := range []string{"authority.", "commit.", "continuity.", "identity.", "situation.", "work."} {
if strings.Contains(lower, schema) {
t.Fatalf("migration touches foreign owner schema %s", schema)
}
}
}
func TestAuthorityAndCommitRemainCognitiveIndependent(t *testing.T) {
for _, directory := range []string{"authority", "commit"} {
for _, parent := range []string{"contracts", "modules"} {
root := filepath.Join("..", "..", parent, directory)
_ = filepath.WalkDir(root, func(path string, entry os.DirEntry, err error) error {
if err != nil || entry.IsDir() {
return err
}
contents, readErr := os.ReadFile(path)
if readErr != nil {
return readErr
}
if strings.Contains(string(contents), "contracts/cognitive") || strings.Contains(string(contents), "cognitive_registry") {
t.Errorf("%s depends on cognitive registry", path)
}
return nil
})
}
}
}
+46
View File
@@ -0,0 +1,46 @@
package cognitive_router_test
import (
"testing"
"git.cin.su/m/Assistant/contracts/capability"
capabilitydomain "git.cin.su/m/Assistant/modules/capability/domain"
)
func candidate(id string, health capability.HealthState) capability.ResolvedCognitiveBinding {
return capability.ResolvedCognitiveBinding{Binding: capability.CognitiveBinding{ID: capability.CapabilityBindingID(id), Revision: 1, CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", ProviderInstanceID: capability.ProviderInstanceID("provider-" + id), ProviderRevision: 1, ModelDescriptorID: capability.ModelDescriptorID("model-" + id), ModelRevision: 1, DataPolicy: capability.DataPolicyLocalOnly, Qualification: capability.QualificationValidated, Activation: capability.ActivationActive, Health: capability.HealthAvailable, LimitPolicyRef: "limits"}, Provider: capability.ProviderInstance{ID: capability.ProviderInstanceID("provider-" + id), Revision: 1, Kind: "kind", EndpointRef: capability.EndpointBindingRef("endpoint-" + id), Enabled: true, Qualification: capability.QualificationValidated, Health: health, ObservedAtUnixMillis: 1}, Model: capability.ModelDescriptor{ID: capability.ModelDescriptorID("model-" + id), Revision: 1, ProviderInstanceID: capability.ProviderInstanceID("provider-" + id), ProviderModelID: "snapshot", Fingerprint: "digest", MaxContextBytes: 10000, Modalities: []capability.ModelModality{capability.ModalityText}, Capabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, Qualification: capability.QualificationValidated, Health: capability.HealthAvailable, ObservedAtUnixMillis: 1}}
}
func requirement() capability.CognitiveRequirement {
return capability.CognitiveRequirement{CapabilityID: "creator-advisory", OwnerPrincipalID: "owner", DataPolicy: capability.DataPolicyExternalMessageOnly, RequiredModalities: []capability.ModelModality{capability.ModalityText}, RequiredCapabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, InputBytes: 10, MaxOutputBytes: 100}
}
func TestUnavailableGPUFallsBackToCPU(t *testing.T) {
gpu := candidate("gpu", capability.HealthUnavailable)
cpu := candidate("cpu", capability.HealthAvailable)
selected, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{gpu, cpu})
if err != nil || selected.Binding.ID != "cpu" {
t.Fatalf("selected=%+v err=%v", selected, err)
}
}
func TestObservedQualityRanksOnlyComparableEvidence(t *testing.T) {
left, right := candidate("left", capability.HealthAvailable), candidate("right", capability.HealthAvailable)
low, high := int64(600), int64(900)
left.Evaluation = &capability.EvaluatedCapability{CapabilityID: "creator-advisory", Result: capability.EvaluationSupported, QualityScoreMillis: &low}
right.Evaluation = &capability.EvaluatedCapability{CapabilityID: "creator-advisory", Result: capability.EvaluationSupported, QualityScoreMillis: &high}
selected, err := capabilitydomain.SelectCognitiveBinding(requirement(), []capability.ResolvedCognitiveBinding{left, right})
if err != nil || selected.Binding.ID != "right" {
t.Fatalf("selected=%+v err=%v", selected, err)
}
}
func TestExcludedFailedBindingSelectsAlternative(t *testing.T) {
gpu, cpu := candidate("gpu", capability.HealthAvailable), candidate("cpu", capability.HealthAvailable)
req := requirement()
req.ExcludedBindingIDs = []capability.CapabilityBindingID{"gpu"}
selected, err := capabilitydomain.SelectCognitiveBinding(req, []capability.ResolvedCognitiveBinding{gpu, cpu})
if err != nil || selected.Binding.ID != "cpu" {
t.Fatalf("selected=%+v err=%v", selected, err)
}
}