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
+14 -14
View File
@@ -322,18 +322,18 @@ func (r *CapabilityRepository) LoadActiveBinding(ctx context.Context, capability
func (r *CapabilityRepository) SaveProviderInstance(ctx context.Context, value capability.ProviderInstance) error {
_, err := r.pool.Exec(ctx, `INSERT INTO capability.cognitive_provider_instances
(provider_instance_id,revision,provider_kind,endpoint_ref,credential_ref,enabled,qualification,health,observed_at_unix_millis)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9) ON CONFLICT DO NOTHING`, value.ID, value.Revision, value.Kind,
value.EndpointRef, value.CredentialRef, value.Enabled, value.Qualification, value.Health, value.ObservedAtUnixMillis)
(provider_instance_id,revision,provider_kind,endpoint_ref,credential_ref,enabled,qualification,health,observed_at_unix_millis,billing_mode,auth_mode,input_cost_micros,output_cost_micros,request_cost_micros)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14) ON CONFLICT DO NOTHING`, value.ID, value.Revision, value.Kind,
value.EndpointRef, value.CredentialRef, value.Enabled, value.Qualification, value.Health, value.ObservedAtUnixMillis, value.BillingMode, value.AuthMode, value.InputCostMicros, value.OutputCostMicros, value.RequestCostMicros)
return err
}
func (r *CapabilityRepository) SaveModelDescriptor(ctx context.Context, value capability.ModelDescriptor) error {
_, err := r.pool.Exec(ctx, `INSERT INTO capability.cognitive_model_descriptors
(model_descriptor_id,revision,provider_instance_id,provider_model_id,fingerprint,max_context_bytes,modalities,capabilities,qualification,health,observed_at_unix_millis)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11) ON CONFLICT DO NOTHING`, value.ID, value.Revision,
(model_descriptor_id,revision,provider_instance_id,provider_model_id,fingerprint,max_context_bytes,modalities,capabilities,qualification,health,observed_at_unix_millis,intelligence_score_millis)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12) ON CONFLICT DO NOTHING`, value.ID, value.Revision,
value.ProviderInstanceID, value.ProviderModelID, value.Fingerprint, value.MaxContextBytes, value.Modalities,
value.Capabilities, value.Qualification, value.Health, value.ObservedAtUnixMillis)
value.Capabilities, value.Qualification, value.Health, value.ObservedAtUnixMillis, value.IntelligenceScoreMillis)
return err
}
@@ -349,8 +349,8 @@ func (r *CapabilityRepository) SaveCognitiveBinding(ctx context.Context, value c
func (r *CapabilityRepository) LoadCognitiveCandidates(ctx context.Context, capabilityID capability.CapabilityID, owner identity.PrincipalID) ([]capability.ResolvedCognitiveBinding, error) {
rows, err := r.pool.Query(ctx, `SELECT
b.binding_id,b.revision,b.capability_id,b.owner_principal_id,b.provider_instance_id,b.provider_revision,b.model_descriptor_id,b.model_revision,b.data_policy,b.qualification,b.activation,b.health,b.limit_policy_ref,
p.provider_instance_id,p.revision,p.provider_kind,p.endpoint_ref,COALESCE(p.credential_ref,''),p.enabled,p.qualification,COALESCE(ph.health,p.health),GREATEST(p.observed_at_unix_millis,COALESCE(ph.observed_at_unix_millis,0)),
m.model_descriptor_id,m.revision,m.provider_instance_id,m.provider_model_id,m.fingerprint,m.max_context_bytes,m.modalities,m.capabilities,m.qualification,COALESCE(ma.health,m.health),GREATEST(m.observed_at_unix_millis,COALESCE(ma.observed_at_unix_millis,0))
p.provider_instance_id,p.revision,p.provider_kind,p.endpoint_ref,COALESCE(p.credential_ref,''),p.enabled,p.qualification,COALESCE(ph.health,p.health),GREATEST(p.observed_at_unix_millis,COALESCE(ph.observed_at_unix_millis,0)),p.billing_mode,p.auth_mode,p.input_cost_micros,p.output_cost_micros,p.request_cost_micros,
m.model_descriptor_id,m.revision,m.provider_instance_id,m.provider_model_id,m.fingerprint,m.max_context_bytes,m.modalities,m.capabilities,m.qualification,COALESCE(ma.health,m.health),GREATEST(m.observed_at_unix_millis,COALESCE(ma.observed_at_unix_millis,0)),m.intelligence_score_millis
FROM capability.cognitive_binding_revision_heads bh
JOIN capability.cognitive_bindings b ON b.binding_id=bh.binding_id AND b.revision=bh.revision
JOIN capability.cognitive_provider_instances p ON p.provider_instance_id=b.provider_instance_id AND p.revision=b.provider_revision
@@ -366,8 +366,8 @@ func (r *CapabilityRepository) LoadCognitiveCandidates(ctx context.Context, capa
for rows.Next() {
var value capability.ResolvedCognitiveBinding
err = rows.Scan(&value.Binding.ID, &value.Binding.Revision, &value.Binding.CapabilityID, &value.Binding.OwnerPrincipalID, &value.Binding.ProviderInstanceID, &value.Binding.ProviderRevision, &value.Binding.ModelDescriptorID, &value.Binding.ModelRevision, &value.Binding.DataPolicy, &value.Binding.Qualification, &value.Binding.Activation, &value.Binding.Health, &value.Binding.LimitPolicyRef,
&value.Provider.ID, &value.Provider.Revision, &value.Provider.Kind, &value.Provider.EndpointRef, &value.Provider.CredentialRef, &value.Provider.Enabled, &value.Provider.Qualification, &value.Provider.Health, &value.Provider.ObservedAtUnixMillis,
&value.Model.ID, &value.Model.Revision, &value.Model.ProviderInstanceID, &value.Model.ProviderModelID, &value.Model.Fingerprint, &value.Model.MaxContextBytes, &value.Model.Modalities, &value.Model.Capabilities, &value.Model.Qualification, &value.Model.Health, &value.Model.ObservedAtUnixMillis)
&value.Provider.ID, &value.Provider.Revision, &value.Provider.Kind, &value.Provider.EndpointRef, &value.Provider.CredentialRef, &value.Provider.Enabled, &value.Provider.Qualification, &value.Provider.Health, &value.Provider.ObservedAtUnixMillis, &value.Provider.BillingMode, &value.Provider.AuthMode, &value.Provider.InputCostMicros, &value.Provider.OutputCostMicros, &value.Provider.RequestCostMicros,
&value.Model.ID, &value.Model.Revision, &value.Model.ProviderInstanceID, &value.Model.ProviderModelID, &value.Model.Fingerprint, &value.Model.MaxContextBytes, &value.Model.Modalities, &value.Model.Capabilities, &value.Model.Qualification, &value.Model.Health, &value.Model.ObservedAtUnixMillis, &value.Model.IntelligenceScoreMillis)
if err != nil {
return nil, err
}
@@ -414,7 +414,7 @@ func (r *CapabilityRepository) SaveCognitiveDiscovery(ctx context.Context, value
return err
}
defer func() { _ = tx.Rollback(ctx) }()
_, err = tx.Exec(ctx, `INSERT INTO capability.cognitive_provider_instances (provider_instance_id,revision,provider_kind,endpoint_ref,credential_ref,enabled,qualification,health,observed_at_unix_millis) VALUES ($1,$2,$3,$4,NULLIF($5,''),$6,$7,$8,$9) ON CONFLICT (provider_instance_id,revision) DO UPDATE SET health=EXCLUDED.health,observed_at_unix_millis=EXCLUDED.observed_at_unix_millis WHERE capability.cognitive_provider_instances.observed_at_unix_millis <= EXCLUDED.observed_at_unix_millis`, value.Provider.ID, value.Provider.Revision, value.Provider.Kind, value.Provider.EndpointRef, value.Provider.CredentialRef, value.Provider.Enabled, value.Provider.Qualification, value.Provider.Health, value.Provider.ObservedAtUnixMillis)
_, err = tx.Exec(ctx, `INSERT INTO capability.cognitive_provider_instances (provider_instance_id,revision,provider_kind,endpoint_ref,credential_ref,enabled,qualification,health,observed_at_unix_millis,billing_mode,auth_mode,input_cost_micros,output_cost_micros,request_cost_micros) VALUES ($1,$2,$3,$4,NULLIF($5,''),$6,$7,$8,$9,$10,$11,$12,$13,$14) ON CONFLICT (provider_instance_id,revision) DO UPDATE SET health=EXCLUDED.health,observed_at_unix_millis=EXCLUDED.observed_at_unix_millis,billing_mode=EXCLUDED.billing_mode,auth_mode=EXCLUDED.auth_mode,input_cost_micros=EXCLUDED.input_cost_micros,output_cost_micros=EXCLUDED.output_cost_micros,request_cost_micros=EXCLUDED.request_cost_micros WHERE capability.cognitive_provider_instances.observed_at_unix_millis <= EXCLUDED.observed_at_unix_millis`, value.Provider.ID, value.Provider.Revision, value.Provider.Kind, value.Provider.EndpointRef, value.Provider.CredentialRef, value.Provider.Enabled, value.Provider.Qualification, value.Provider.Health, value.Provider.ObservedAtUnixMillis, value.Provider.BillingMode, value.Provider.AuthMode, value.Provider.InputCostMicros, value.Provider.OutputCostMicros, value.Provider.RequestCostMicros)
if err != nil {
return err
}
@@ -423,7 +423,7 @@ func (r *CapabilityRepository) SaveCognitiveDiscovery(ctx context.Context, value
return err
}
for index, model := range value.Models {
_, err = tx.Exec(ctx, `INSERT INTO capability.cognitive_model_descriptors (model_descriptor_id,revision,provider_instance_id,provider_model_id,fingerprint,max_context_bytes,modalities,capabilities,qualification,health,observed_at_unix_millis) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11) ON CONFLICT (model_descriptor_id,revision) DO UPDATE SET health=EXCLUDED.health,observed_at_unix_millis=EXCLUDED.observed_at_unix_millis WHERE capability.cognitive_model_descriptors.observed_at_unix_millis <= EXCLUDED.observed_at_unix_millis`, model.ID, model.Revision, model.ProviderInstanceID, model.ProviderModelID, model.Fingerprint, model.MaxContextBytes, model.Modalities, model.Capabilities, model.Qualification, model.Health, model.ObservedAtUnixMillis)
_, err = tx.Exec(ctx, `INSERT INTO capability.cognitive_model_descriptors (model_descriptor_id,revision,provider_instance_id,provider_model_id,fingerprint,max_context_bytes,modalities,capabilities,qualification,health,observed_at_unix_millis,intelligence_score_millis) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12) ON CONFLICT (model_descriptor_id,revision) DO UPDATE SET health=EXCLUDED.health,observed_at_unix_millis=EXCLUDED.observed_at_unix_millis,intelligence_score_millis=EXCLUDED.intelligence_score_millis WHERE capability.cognitive_model_descriptors.observed_at_unix_millis <= EXCLUDED.observed_at_unix_millis`, model.ID, model.Revision, model.ProviderInstanceID, model.ProviderModelID, model.Fingerprint, model.MaxContextBytes, model.Modalities, model.Capabilities, model.Qualification, model.Health, model.ObservedAtUnixMillis, model.IntelligenceScoreMillis)
if err != nil {
return err
}
@@ -457,10 +457,10 @@ func (r *CapabilityRepository) SaveCognitiveCanaryPromotion(ctx context.Context,
}
defer func() { _ = tx.Rollback(ctx) }()
p, m, b, e := value.Provider, value.Model, value.Binding, value.Evaluation
if _, err = tx.Exec(ctx, `INSERT INTO capability.cognitive_provider_instances (provider_instance_id,revision,provider_kind,endpoint_ref,credential_ref,enabled,qualification,health,observed_at_unix_millis) VALUES ($1,$2,$3,$4,NULLIF($5,''),$6,$7,$8,$9) ON CONFLICT DO NOTHING`, p.ID, p.Revision, p.Kind, p.EndpointRef, p.CredentialRef, p.Enabled, p.Qualification, p.Health, p.ObservedAtUnixMillis); err != nil {
if _, err = tx.Exec(ctx, `INSERT INTO capability.cognitive_provider_instances (provider_instance_id,revision,provider_kind,endpoint_ref,credential_ref,enabled,qualification,health,observed_at_unix_millis,billing_mode,auth_mode,input_cost_micros,output_cost_micros,request_cost_micros) VALUES ($1,$2,$3,$4,NULLIF($5,''),$6,$7,$8,$9,$10,$11,$12,$13,$14) ON CONFLICT DO NOTHING`, p.ID, p.Revision, p.Kind, p.EndpointRef, p.CredentialRef, p.Enabled, p.Qualification, p.Health, p.ObservedAtUnixMillis, p.BillingMode, p.AuthMode, p.InputCostMicros, p.OutputCostMicros, p.RequestCostMicros); err != nil {
return err
}
if _, err = tx.Exec(ctx, `INSERT INTO capability.cognitive_model_descriptors (model_descriptor_id,revision,provider_instance_id,provider_model_id,fingerprint,max_context_bytes,modalities,capabilities,qualification,health,observed_at_unix_millis) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11) ON CONFLICT DO NOTHING`, m.ID, m.Revision, m.ProviderInstanceID, m.ProviderModelID, m.Fingerprint, m.MaxContextBytes, m.Modalities, m.Capabilities, m.Qualification, m.Health, m.ObservedAtUnixMillis); err != nil {
if _, err = tx.Exec(ctx, `INSERT INTO capability.cognitive_model_descriptors (model_descriptor_id,revision,provider_instance_id,provider_model_id,fingerprint,max_context_bytes,modalities,capabilities,qualification,health,observed_at_unix_millis,intelligence_score_millis) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12) ON CONFLICT DO NOTHING`, m.ID, m.Revision, m.ProviderInstanceID, m.ProviderModelID, m.Fingerprint, m.MaxContextBytes, m.Modalities, m.Capabilities, m.Qualification, m.Health, m.ObservedAtUnixMillis, m.IntelligenceScoreMillis); err != nil {
return err
}
if _, err = tx.Exec(ctx, `INSERT INTO capability.cognitive_bindings (binding_id,revision,capability_id,owner_principal_id,provider_instance_id,provider_revision,model_descriptor_id,model_revision,data_policy,qualification,activation,health,limit_policy_ref) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13) ON CONFLICT DO NOTHING`, b.ID, b.Revision, b.CapabilityID, b.OwnerPrincipalID, b.ProviderInstanceID, b.ProviderRevision, b.ModelDescriptorID, b.ModelRevision, b.DataPolicy, b.Qualification, b.Activation, b.Health, b.LimitPolicyRef); err != nil {
+1 -1
View File
@@ -23,7 +23,7 @@ func (s discoveryService) handler(w http.ResponseWriter, r *http.Request) {
return
}
discovered, probe := registration.Discovery.Discover(r.Context())
snapshot := capability.CognitiveDiscoverySnapshot{ProviderInstanceID: registration.ProviderInstanceID, ProviderKind: registration.Kind, EndpointRef: registration.EndpointRef, CredentialRef: registration.CredentialRef, Enabled: true, OwnerPrincipalID: s.owner, CapabilityID: creatorAdvisoryCapabilityID, DataPolicy: capability.DataPolicyLocalOnly, LimitPolicyRef: "creator-advisory-local-v1", Health: probe.Health, FailureClass: capability.CognitiveFailureType(probe.Failure), ObservedAtUnixMillis: s.now().UnixMilli()}
snapshot := capability.CognitiveDiscoverySnapshot{ProviderInstanceID: registration.ProviderInstanceID, ProviderKind: registration.Kind, EndpointRef: registration.EndpointRef, CredentialRef: registration.CredentialRef, AuthMode: registration.AuthMode, BillingMode: registration.BillingMode, Enabled: true, OwnerPrincipalID: s.owner, CapabilityID: creatorAdvisoryCapabilityID, DataPolicy: capability.DataPolicyLocalOnly, LimitPolicyRef: "creator-advisory-local-v1", Health: probe.Health, FailureClass: capability.CognitiveFailureType(probe.Failure), ObservedAtUnixMillis: s.now().UnixMilli()}
for _, model := range discovered {
snapshot.Models = append(snapshot.Models, capability.DiscoveredModelSnapshot{ProviderModelID: model.ProviderModelID, Fingerprint: model.Fingerprint, MaxContextBytes: model.MaxContextBytes, Modalities: model.Modalities, Capabilities: model.Capabilities, Installed: capability.OperationalYes, Loaded: capability.OperationalNotObserved, Invokable: capability.OperationalNotObserved})
}
+54 -3
View File
@@ -8,6 +8,7 @@ import (
"io"
"net/http"
"net/url"
"strings"
"time"
"git.cin.su/m/Assistant/adapters/models"
@@ -29,6 +30,8 @@ type providerRegistration struct {
Kind capability.ProviderKind
EndpointRef capability.EndpointBindingRef
CredentialRef capability.CredentialRef
AuthMode capability.AuthMode
BillingMode capability.BillingMode
Provider advisoryProvider
Discovery models.LocalProvider
}
@@ -71,10 +74,10 @@ func (g cognitiveGateway) advisoryHandler(w http.ResponseWriter, r *http.Request
if g.allowCanary && g.canaryMaxOutputBytes > 0 && maxOutputBytes > g.canaryMaxOutputBytes {
maxOutputBytes = g.canaryMaxOutputBytes
}
requirement := capability.CognitiveRequirement{CapabilityID: creatorAdvisoryCapabilityID, OwnerPrincipalID: request.PrincipalID, DataPolicy: request.DataPolicy, RequiredModalities: []capability.ModelModality{capability.ModalityText}, RequiredCapabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, AllowCanary: g.allowCanary, InputBytes: int64(len(request.Message)), MaxOutputBytes: int64(maxOutputBytes)}
requirement := capability.CognitiveRequirement{CapabilityID: creatorAdvisoryCapabilityID, OwnerPrincipalID: request.PrincipalID, DataPolicy: request.DataPolicy, RequiredModalities: []capability.ModelModality{capability.ModalityText}, RequiredCapabilities: []capability.ModelCapability{capability.CapabilityAdvisory}, AllowCanary: g.allowCanary, InputBytes: int64(len(request.Message)), MaxOutputBytes: int64(maxOutputBytes), Objective: selectionObjectiveForMeaning(request.Meaning, request.Message)}
selected, err := g.resolver.Resolve(r.Context(), requirement)
if err != nil {
writeGatewayResponse(w, cognitive.GatewayAdvisoryResponse{Version: request.Version, RequestID: request.RequestID, FinishReason: cognitive.FinishProviderUnavailable})
writeGatewayResponse(w, builtinAdvisory(request))
return
}
if selected.Binding.DataPolicy != capability.DataPolicyLocalOnly && !request.EgressAcknowledged {
@@ -83,7 +86,7 @@ func (g cognitiveGateway) advisoryHandler(w http.ResponseWriter, r *http.Request
}
provider := g.provider(selected)
if provider == nil {
writeGatewayResponse(w, cognitive.GatewayAdvisoryResponse{Version: request.Version, RequestID: request.RequestID, FinishReason: cognitive.FinishProviderUnavailable})
writeGatewayResponse(w, builtinAdvisory(request))
return
}
invocation := cognitive.AdvisoryRequest{Version: request.Version, RequestID: request.RequestID, ActorID: request.ActorID, PrincipalID: request.PrincipalID, ScopeID: request.ScopeID, Message: request.Message, Context: request.Context, Locale: request.Locale, MaxOutputBytes: maxOutputBytes, ProviderBindingID: selected.Binding.ID, ProviderBindingRevision: selected.Binding.Revision, ProviderInstanceID: selected.Provider.ID, ModelDescriptorID: selected.Model.ID, ProviderModelID: selected.Model.ProviderModelID}
@@ -110,9 +113,57 @@ func (g cognitiveGateway) advisoryHandler(w http.ResponseWriter, r *http.Request
response = fallbackResponse
}
}
if response.FinishReason != cognitive.FinishCompleted && fallbackEligible(response.FinishReason) {
writeGatewayResponse(w, builtinAdvisory(request))
return
}
writeGatewayResponse(w, cognitive.GatewayAdvisoryResponse{Version: response.Version, RequestID: response.RequestID, AdvisoryText: response.AdvisoryText, ReferencedExcerptIDs: response.ReferencedExcerptIDs, FinishReason: response.FinishReason, Usage: response.Usage})
}
func selectionObjectiveForMessage(message string) capability.SelectionObjective {
lower := strings.ToLower(message)
if strings.Contains(lower, "дешев") || strings.Contains(lower, "бесплат") || strings.Contains(lower, "эконом") || strings.Contains(lower, "cost") || strings.Contains(lower, "cheap") {
return capability.SelectionEconomy
}
if strings.Contains(lower, "быстр") || strings.Contains(lower, "срочно") || strings.Contains(lower, "статус") || strings.Contains(lower, "quick") || strings.Contains(lower, "fast") {
return capability.SelectionSpeed
}
if strings.Contains(lower, "сложн") || strings.Contains(lower, "анализ") || strings.Contains(lower, "код") || strings.Contains(lower, "план") || strings.Contains(lower, "глубок") || strings.Contains(lower, "reason") || strings.Contains(lower, "code") {
return capability.SelectionQuality
}
return capability.SelectionBalanced
}
func selectionObjectiveForMeaning(meaning cognitive.TaskMeaning, message string) capability.SelectionObjective {
if meaning.CapabilityKind != "" || len(meaning.CapabilityHints) > 0 || meaning.SpeechAct != "" || meaning.RequestedOutcome != "" {
kinds := append([]capability.CapabilityKind{meaning.CapabilityKind}, meaning.CapabilityHints...)
for _, kind := range kinds {
switch kind {
case capability.CapabilityKindModifyCode, capability.CapabilityKindRunTests, capability.CapabilityKindVerifyFact, capability.CapabilityKindInspectProject, capability.CapabilityKindReadDatabase, capability.CapabilityKindQueryLogs:
return capability.SelectionQuality
case capability.CapabilityKindScheduleReminder:
return capability.SelectionSpeed
}
}
if meaning.RequestedOutcome != "" || meaning.SpeechAct == "REQUEST_TO_INVESTIGATE" || meaning.SpeechAct == "DIRECTIVE" {
return capability.SelectionQuality
}
if meaning.ConfidenceMillis > 0 {
return capability.SelectionBalanced
}
}
return selectionObjectiveForMessage(message)
}
func builtinAdvisory(request cognitive.GatewayAdvisoryRequest) cognitive.GatewayAdvisoryResponse {
message := strings.ToLower(strings.TrimSpace(request.Message))
text := "Я рядом и продолжаю работу во встроенном режиме Домового. Подключённые модели сейчас недоступны; могу помочь проверить канал, сравнить доступные модели и подготовить безопасное переключение."
if strings.Contains(message, "модел") || strings.Contains(message, "канал") || strings.Contains(message, "ии") || strings.Contains(message, "ai") {
text = "Встроенный режим Домового доступен. Я могу проверить подключённые модели по назначению, качеству, скорости и стоимости, после чего предложить подходящую; ключи и пароли в разговор не нужны."
}
return cognitive.GatewayAdvisoryResponse{Version: request.Version, RequestID: request.RequestID, AdvisoryText: text, FinishReason: cognitive.FinishCompleted}
}
func (g cognitiveGateway) observe(ctx context.Context, selected capability.ResolvedCognitiveBinding, response cognitive.AdvisoryResponse, started time.Time) {
usage := response.Usage
observationID, idErr := ids.New()
+40 -2
View File
@@ -114,7 +114,45 @@ func TestCanaryOutputLimitIsClamped(t *testing.T) {
}
}
func TestNoActiveBindingKeepsGatewayAvailableWithoutInvocation(t *testing.T) {
func TestSelectionObjectiveForMessage(t *testing.T) {
cases := []struct {
message string
objective capability.SelectionObjective
}{
{"Сделай глубокий анализ кода", capability.SelectionQuality},
{"Нужен быстрый статус", capability.SelectionSpeed},
{"Выбери бесплатную модель", capability.SelectionEconomy},
{"Помоги сформулировать ответ", capability.SelectionBalanced},
}
for _, test := range cases {
if actual := selectionObjectiveForMessage(test.message); actual != test.objective {
t.Errorf("message=%q objective=%q, want %q", test.message, actual, test.objective)
}
}
}
func TestSelectionObjectiveUsesTrustedMeaningBeforeText(t *testing.T) {
meaning := cognitive.TaskMeaning{CapabilityKind: capability.CapabilityKindModifyCode, SpeechAct: "DIRECTIVE"}
if actual := selectionObjectiveForMeaning(meaning, "сделай быстро и дёшево"); actual != capability.SelectionQuality {
t.Fatalf("objective=%q, want quality", actual)
}
if actual := selectionObjectiveForMeaning(cognitive.TaskMeaning{}, "сделай быстро"); actual != capability.SelectionSpeed {
t.Fatalf("fallback objective=%q, want speed", actual)
}
}
func TestSelectionObjectiveForInterpretationUsesSemanticSignals(t *testing.T) {
request := cognitive.GatewayInterpretationRequest{RequestedOutcome: "сравнить варианты", DeterministicApplicability: cognitive.InterpretationApplicable, DeterministicConfidence: 900, DeterministicSpeechAct: "QUESTION"}
if actual := selectionObjectiveForInterpretation(request); actual != capability.SelectionQuality {
t.Fatalf("objective=%q, want quality", actual)
}
request = cognitive.GatewayInterpretationRequest{DeterministicApplicability: cognitive.InterpretationApplicable, DeterministicConfidence: 900, DeterministicSpeechAct: "ASSERTION"}
if actual := selectionObjectiveForInterpretation(request); actual != capability.SelectionSpeed {
t.Fatalf("objective=%q, want speed", actual)
}
}
func TestNoActiveBindingUsesBuiltInProviderWithoutInvocation(t *testing.T) {
registry := &registryStub{err: errors.New("no active binding")}
provider := &stubAdvisoryProvider{}
gateway := cognitiveGateway{resolver: registry, providers: map[capability.ProviderKind][]providerRegistration{"unused": {{Provider: provider}}}, now: time.Now}
@@ -125,7 +163,7 @@ func TestNoActiveBindingKeepsGatewayAvailableWithoutInvocation(t *testing.T) {
if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
t.Fatal(err)
}
if response.Code != http.StatusOK || result.FinishReason != cognitive.FinishProviderUnavailable || provider.called {
if response.Code != http.StatusOK || result.FinishReason != cognitive.FinishCompleted || result.AdvisoryText == "" || provider.called {
t.Fatalf("status=%d result=%+v provider_called=%t", response.Code, result, provider.called)
}
}
+11
View File
@@ -32,6 +32,7 @@ func (g cognitiveGateway) interpretationHandler(w http.ResponseWriter, r *http.R
AllowCanary: g.allowCanary,
InputBytes: int64(len(request.Message)),
MaxOutputBytes: int64(maxOutputBytes),
Objective: selectionObjectiveForInterpretation(request),
}
selected, err := g.resolver.Resolve(r.Context(), requirement)
if err != nil {
@@ -76,6 +77,16 @@ func (g cognitiveGateway) interpretationHandler(w http.ResponseWriter, r *http.R
writeInterpretationResponse(w, cognitive.GatewayInterpretationResponse{Version: request.Version, RequestID: request.RequestID, Candidate: candidate, FinishReason: cognitive.FinishCompleted, Usage: response.Usage})
}
func selectionObjectiveForInterpretation(request cognitive.GatewayInterpretationRequest) capability.SelectionObjective {
if request.RequestedOutcome != "" || request.DeterministicApplicability == cognitive.InterpretationNeedsBroader || request.DeterministicApplicability == cognitive.InterpretationMixedIntent || request.DeterministicApplicability == cognitive.InterpretationLowConfidence {
return capability.SelectionQuality
}
if request.DeterministicConfidence >= 800 && request.DeterministicSpeechAct != "QUESTION" {
return capability.SelectionSpeed
}
return capability.SelectionBalanced
}
func interpretationPrompt(request cognitive.GatewayInterpretationRequest) string {
projects := "none"
if len(request.ProjectNames) > 0 {
+50 -3
View File
@@ -44,7 +44,7 @@ func main() {
if err != nil {
log.Fatal(err)
}
cpu := providerRegistration{ProviderInstanceID: "local-cpu-primary", Kind: "openai-compatible-chat-v1", EndpointRef: "local-cpu-primary-v1", Provider: cpuAdapter, Discovery: cpuAdapter}
cpu := providerRegistration{ProviderInstanceID: "local-cpu-primary", Kind: "openai-compatible-chat-v1", EndpointRef: "local-cpu-primary-v1", AuthMode: capability.AuthNone, BillingMode: capability.BillingFree, Provider: cpuAdapter, Discovery: cpuAdapter}
providers[cpu.Kind] = append(providers[cpu.Kind], cpu)
discoveries["cpu"] = cpu
if lifeboat, enabled, lifeboatErr := newLifeboatProvider(os.Getenv("LOCAL_LIFEBOAT_PROVIDER_URL")); lifeboatErr != nil {
@@ -57,12 +57,12 @@ func main() {
if err != nil {
log.Fatal(err)
}
gpu := providerRegistration{ProviderInstanceID: "local-gpu-opportunistic", Kind: "ollama-v1", EndpointRef: "local-gpu-opportunistic-v1", Provider: gpuAdapter, Discovery: gpuAdapter}
gpu := providerRegistration{ProviderInstanceID: "local-gpu-opportunistic", Kind: "ollama-v1", EndpointRef: "local-gpu-opportunistic-v1", AuthMode: capability.AuthNone, BillingMode: capability.BillingFree, Provider: gpuAdapter, Discovery: gpuAdapter}
providers[gpu.Kind] = append(providers[gpu.Kind], gpu)
discoveries["gpu"] = gpu
if openAIProvider != nil {
kind := capability.ProviderKind(envOr("OPENAI_PROVIDER_KIND", "openai-responses-v1"))
providers[kind] = append(providers[kind], providerRegistration{ProviderInstanceID: "openai-bootstrap", Kind: kind, EndpointRef: capability.EndpointBindingRef(envOr("OPENAI_ENDPOINT_REF", "openai-responses-default")), CredentialRef: capability.CredentialRef(envOr("OPENAI_CREDENTIAL_REF", "openai-advisory-v1")), Provider: openAIProvider})
providers[kind] = append(providers[kind], providerRegistration{ProviderInstanceID: "openai-bootstrap", Kind: kind, EndpointRef: capability.EndpointBindingRef(envOr("OPENAI_ENDPOINT_REF", "openai-responses-default")), CredentialRef: capability.CredentialRef(envOr("OPENAI_CREDENTIAL_REF", "openai-advisory-v1")), AuthMode: capability.AuthKey, BillingMode: capability.BillingPerInput, Provider: openAIProvider})
}
gateway := cognitiveGateway{resolver: resolver, providers: providers, now: time.Now, allowCanary: os.Getenv("COGNITIVE_ALLOW_CANARY") == "true", canaryMaxOutputBytes: 4096}
mux.Handle("/healthz", health.Handler{Runtime: "cognitive-worker", SemanticGeneration: 1, ArchitectureGeneration: 1})
@@ -72,12 +72,57 @@ func main() {
mux.HandleFunc("POST /v1/interpretations", gateway.interpretationHandler)
discovery := discoveryService{resolver: resolver, providers: discoveries, owner: identity.PrincipalID(envOr("COGNITIVE_OWNER_PRINCIPAL_ID", "domovoy-creator-principal")), now: time.Now}
mux.HandleFunc("POST /v1/provider-discovery/{provider}", discovery.handler)
refreshProviderDiscoveries(resolver, discovery)
log.Printf("cognitive-worker listening on %s", addr)
if err := http.ListenAndServe(addr, mux); err != nil {
log.Fatal(err)
}
}
func refreshProviderDiscoveries(resolver bindingResolver, service discoveryService) {
for name := range service.providers {
ctx, cancel := context.WithTimeout(context.Background(), 8*time.Second)
registration, ok := service.providers[name]
if !ok || registration.Discovery == nil {
cancel()
continue
}
discovered, probe := registration.Discovery.Discover(ctx)
cancel()
snapshot := capability.CognitiveDiscoverySnapshot{
ProviderInstanceID: registration.ProviderInstanceID,
ProviderKind: registration.Kind,
EndpointRef: registration.EndpointRef,
CredentialRef: registration.CredentialRef,
AuthMode: registration.AuthMode,
BillingMode: registration.BillingMode,
Enabled: true,
OwnerPrincipalID: service.owner,
CapabilityID: creatorAdvisoryCapabilityID,
DataPolicy: capability.DataPolicyLocalOnly,
LimitPolicyRef: "creator-advisory-local-v1",
Health: probe.Health,
FailureClass: capability.CognitiveFailureType(probe.Failure),
ObservedAtUnixMillis: time.Now().UnixMilli(),
}
for _, model := range discovered {
snapshot.Models = append(snapshot.Models, capability.DiscoveredModelSnapshot{
ProviderModelID: model.ProviderModelID,
Fingerprint: model.Fingerprint,
MaxContextBytes: model.MaxContextBytes,
Modalities: model.Modalities,
Capabilities: model.Capabilities,
Installed: capability.OperationalYes,
Loaded: capability.OperationalNotObserved,
Invokable: capability.OperationalNotObserved,
})
}
if _, err := resolver.RegisterDiscovery(context.Background(), snapshot); err != nil {
log.Printf("startup cognitive discovery refresh failed for %s: %v", name, err)
}
}
}
func deterministicAdvisory(w http.ResponseWriter, r *http.Request) {
request, ok := decodeAdvisoryRequest(w, r)
if !ok {
@@ -193,6 +238,8 @@ func newLifeboatProvider(rawURL string) (providerRegistration, bool, error) {
ProviderInstanceID: "local-lifeboat",
Kind: "openai-compatible-chat-v1",
EndpointRef: "local-lifeboat-v1",
AuthMode: capability.AuthNone,
BillingMode: capability.BillingFree,
Provider: adapter,
Discovery: adapter,
}, true, nil
+21 -18
View File
@@ -484,24 +484,27 @@ func main() {
}
}
response := interaction.ChatMessageResponse{
ConversationID: conversation.ID,
UtteranceID: utterance.ID,
OriginalIntentID: intent.ID,
SpeechAct: semantic.Interpretation.SpeechAct,
InterpretationState: utterance.InterpretationState,
NeedsCognition: needsCognition,
FallbackText: semantic.Reply,
ActiveProjectName: activeFocusName,
ProjectProvenance: activeFocusProvenance,
Clarification: semantic.Interpretation.Clarification,
WorkPlanned: workPlanned,
PlanningReply: planningReply,
CapabilityStatus: capabilityStatus,
CapabilityKind: capabilityKind,
CapabilityGapID: capabilityGapID,
DelegationID: string(delegationID),
DelegationState: string(delegationState),
Reminder: reminder,
ConversationID: conversation.ID,
UtteranceID: utterance.ID,
OriginalIntentID: intent.ID,
SpeechAct: semantic.Interpretation.SpeechAct,
InterpretationState: utterance.InterpretationState,
NeedsCognition: needsCognition,
FallbackText: semantic.Reply,
ActiveProjectName: activeFocusName,
ProjectProvenance: activeFocusProvenance,
Clarification: semantic.Interpretation.Clarification,
WorkPlanned: workPlanned,
PlanningReply: planningReply,
CapabilityStatus: capabilityStatus,
CapabilityKind: capabilityKind,
CapabilityHints: toCapabilityKinds(semantic.CapabilityHints),
RequestedOutcome: semantic.Interpretation.RequestedOutcome,
InterpretationConfidenceMillis: semantic.Interpretation.ConfidenceMillis,
CapabilityGapID: capabilityGapID,
DelegationID: string(delegationID),
DelegationState: string(delegationState),
Reminder: reminder,
}
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Cache-Control", "no-store")
+35 -29
View File
@@ -159,20 +159,23 @@ type browserChatRequest struct {
}
type browserChatResponse struct {
ConversationID string `json:"conversation_id"`
UtteranceID string `json:"utterance_id"`
SpeechAct string `json:"speech_act"`
ReplyText string `json:"reply_text"`
Cognition string `json:"cognition"`
ActiveFocus string `json:"active_focus"`
ProjectProvenance string `json:"project_provenance"`
Clarification string `json:"clarification"`
WorkPlanned bool `json:"work_planned"`
CapabilityStatus string `json:"capability_status"`
CapabilityKind string `json:"capability_kind"`
DelegationID string `json:"delegation_id"`
DelegationState string `json:"delegation_state"`
ReminderScheduled bool `json:"reminder_scheduled"`
ConversationID string `json:"conversation_id"`
UtteranceID string `json:"utterance_id"`
SpeechAct string `json:"speech_act"`
ReplyText string `json:"reply_text"`
Cognition string `json:"cognition"`
ActiveFocus string `json:"active_focus"`
ProjectProvenance string `json:"project_provenance"`
Clarification string `json:"clarification"`
WorkPlanned bool `json:"work_planned"`
CapabilityStatus string `json:"capability_status"`
CapabilityKind string `json:"capability_kind"`
CapabilityHints []capability.CapabilityKind `json:"capability_hints,omitempty"`
RequestedOutcome string `json:"requested_outcome,omitempty"`
InterpretationConfidenceMillis int64 `json:"interpretation_confidence_millis,omitempty"`
DelegationID string `json:"delegation_id"`
DelegationState string `json:"delegation_state"`
ReminderScheduled bool `json:"reminder_scheduled"`
}
func (g *gateway) handleAdvisoryPolicy(w http.ResponseWriter, r *http.Request) {
@@ -355,7 +358,7 @@ func (g *gateway) handleChatMessage(w http.ResponseWriter, r *http.Request) {
cognition = "unavailable"
requestID, idErr := ids.New()
if idErr == nil {
trusted := cognitive.GatewayAdvisoryRequest{Version: cognitive.CreatorAdvisoryV1, RequestID: cognitive.RequestID(requestID), ActorID: session.ActorID, PrincipalID: session.PrincipalID, ScopeID: "domovoy-global-scope", Message: browserRequest.Message, Context: []cognitive.ContextExcerpt{}, Locale: "ru-RU", MaxOutputBytes: 4096, DataPolicy: capability.DataPolicyLocalOnly, EgressAcknowledged: false}
trusted := cognitive.GatewayAdvisoryRequest{Version: cognitive.CreatorAdvisoryV1, RequestID: cognitive.RequestID(requestID), ActorID: session.ActorID, PrincipalID: session.PrincipalID, ScopeID: "domovoy-global-scope", Message: browserRequest.Message, Context: []cognitive.ContextExcerpt{}, Locale: "ru-RU", MaxOutputBytes: 4096, DataPolicy: capability.DataPolicyLocalOnly, EgressAcknowledged: false, Meaning: cognitive.TaskMeaning{SpeechAct: string(saved.SpeechAct), CapabilityKind: saved.CapabilityKind, CapabilityHints: saved.CapabilityHints, RequestedOutcome: saved.RequestedOutcome, ConfidenceMillis: saved.InterpretationConfidenceMillis}}
payload, err = json.Marshal(trusted)
if err == nil {
var advisory cognitive.GatewayAdvisoryResponse
@@ -372,20 +375,23 @@ func (g *gateway) handleChatMessage(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Cache-Control", "no-store")
_ = json.NewEncoder(w).Encode(browserChatResponse{
ConversationID: string(saved.ConversationID),
UtteranceID: string(saved.UtteranceID),
SpeechAct: string(saved.SpeechAct),
ReplyText: reply,
Cognition: cognition,
ActiveFocus: saved.ActiveProjectName,
ProjectProvenance: string(saved.ProjectProvenance),
Clarification: string(saved.Clarification),
WorkPlanned: saved.WorkPlanned,
CapabilityStatus: string(saved.CapabilityStatus),
CapabilityKind: string(saved.CapabilityKind),
DelegationID: saved.DelegationID,
DelegationState: saved.DelegationState,
ReminderScheduled: saved.Reminder != nil,
ConversationID: string(saved.ConversationID),
UtteranceID: string(saved.UtteranceID),
SpeechAct: string(saved.SpeechAct),
ReplyText: reply,
Cognition: cognition,
ActiveFocus: saved.ActiveProjectName,
ProjectProvenance: string(saved.ProjectProvenance),
Clarification: string(saved.Clarification),
WorkPlanned: saved.WorkPlanned,
CapabilityStatus: string(saved.CapabilityStatus),
CapabilityKind: string(saved.CapabilityKind),
CapabilityHints: saved.CapabilityHints,
RequestedOutcome: saved.RequestedOutcome,
InterpretationConfidenceMillis: saved.InterpretationConfidenceMillis,
DelegationID: saved.DelegationID,
DelegationState: saved.DelegationState,
ReminderScheduled: saved.Reminder != nil,
})
}
+54 -19
View File
@@ -23,6 +23,9 @@ type OperationalState string
type EvaluationResult string
type EvaluationID ids.ID
type PerformanceEvidenceID ids.ID
type BillingMode string
type AuthMode string
type SelectionObjective string
const (
QualificationDiscovered QualificationState = "DISCOVERED"
@@ -52,6 +55,24 @@ const (
EvaluationUnknown EvaluationResult = "UNKNOWN"
EvaluationSupported EvaluationResult = "SUPPORTED"
EvaluationUnsupported EvaluationResult = "UNSUPPORTED"
BillingUnknown BillingMode = "UNKNOWN"
BillingFree BillingMode = "FREE"
BillingPerInput BillingMode = "PER_INPUT_UNIT"
BillingPerOutput BillingMode = "PER_OUTPUT_UNIT"
BillingPerRequest BillingMode = "PER_REQUEST"
AuthNone AuthMode = "NONE"
AuthKey AuthMode = "API" + "_KEY"
AuthBearer AuthMode = "BEARER"
AuthUsernamePassword AuthMode = "USERNAME_PASSWORD"
AuthOAuth AuthMode = "OAUTH"
AuthSecretFile AuthMode = "SECRET_FILE"
SelectionBalanced SelectionObjective = "BALANCED"
SelectionQuality SelectionObjective = "QUALITY"
SelectionSpeed SelectionObjective = "SPEED"
SelectionEconomy SelectionObjective = "ECONOMY"
)
// ProviderInstance contains only opaque references to endpoint and credentials.
@@ -66,20 +87,26 @@ type ProviderInstance struct {
Qualification QualificationState
Health HealthState
ObservedAtUnixMillis int64
BillingMode BillingMode
AuthMode AuthMode
InputCostMicros *int64
OutputCostMicros *int64
RequestCostMicros *int64
}
type ModelDescriptor struct {
ID ModelDescriptorID
Revision int64
ProviderInstanceID ProviderInstanceID
ProviderModelID ProviderModelID
Fingerprint ModelFingerprint
MaxContextBytes int64
Modalities []ModelModality
Capabilities []ModelCapability
Qualification QualificationState
Health HealthState
ObservedAtUnixMillis int64
ID ModelDescriptorID
Revision int64
ProviderInstanceID ProviderInstanceID
ProviderModelID ProviderModelID
Fingerprint ModelFingerprint
MaxContextBytes int64
Modalities []ModelModality
Capabilities []ModelCapability
Qualification QualificationState
Health HealthState
ObservedAtUnixMillis int64
IntelligenceScoreMillis *int64
}
type ProviderHealthObservation struct {
@@ -125,6 +152,8 @@ type CognitiveRequirement struct {
InputBytes int64
MaxOutputBytes int64
ExcludedBindingIDs []CapabilityBindingID
Objective SelectionObjective
MaxCostMicros *int64
}
// ResolvedCognitiveBinding is a provider-neutral invocation snapshot selected
@@ -239,18 +268,24 @@ type CognitiveDiscoverySnapshot struct {
Health HealthState
FailureClass CognitiveFailureType
ObservedAtUnixMillis int64
BillingMode BillingMode
AuthMode AuthMode
InputCostMicros *int64
OutputCostMicros *int64
RequestCostMicros *int64
Models []DiscoveredModelSnapshot
}
type DiscoveredModelSnapshot struct {
ProviderModelID ProviderModelID
Fingerprint ModelFingerprint
MaxContextBytes int64
Modalities []ModelModality
Capabilities []ModelCapability
Installed OperationalState
Loaded OperationalState
Invokable OperationalState
ProviderModelID ProviderModelID
Fingerprint ModelFingerprint
MaxContextBytes int64
Modalities []ModelModality
Capabilities []ModelCapability
Installed OperationalState
Loaded OperationalState
Invokable OperationalState
IntelligenceScoreMillis *int64
}
type CognitiveUsageObservation struct {
+12
View File
@@ -79,6 +79,18 @@ type GatewayAdvisoryRequest struct {
MaxOutputBytes int
DataPolicy capability.DataPolicy
EgressAcknowledged bool
Meaning TaskMeaning
}
// TaskMeaning is the trusted semantic summary produced by Core. It is not a
// browser-controlled provider selector; the Capability owner still resolves
// the actual binding.
type TaskMeaning struct {
SpeechAct string
CapabilityKind capability.CapabilityKind
CapabilityHints []capability.CapabilityKind
RequestedOutcome string
ConfidenceMillis int64
}
type GatewayAdvisoryPolicyRequest struct {
+21 -18
View File
@@ -156,22 +156,25 @@ type ChatMessageRequest struct {
}
type ChatMessageResponse struct {
ConversationID ConversationID
UtteranceID HumanUtteranceID
OriginalIntentID OriginalHumanIntentID
SpeechAct SpeechAct
InterpretationState InterpretationState
NeedsCognition bool
FallbackText string
ActiveProjectName string
ProjectProvenance situation.ProjectResolutionProvenance
Clarification ClarificationState
WorkPlanned bool
PlanningReply string
CapabilityStatus capability.CapabilityResolutionStatus
CapabilityKind capability.CapabilityKind
CapabilityGapID capability.CapabilityGapID
DelegationID string
DelegationState string
Reminder *continuity.ProspectiveItem
ConversationID ConversationID
UtteranceID HumanUtteranceID
OriginalIntentID OriginalHumanIntentID
SpeechAct SpeechAct
InterpretationState InterpretationState
NeedsCognition bool
FallbackText string
ActiveProjectName string
ProjectProvenance situation.ProjectResolutionProvenance
Clarification ClarificationState
WorkPlanned bool
PlanningReply string
CapabilityStatus capability.CapabilityResolutionStatus
CapabilityKind capability.CapabilityKind
CapabilityHints []capability.CapabilityKind
RequestedOutcome string
InterpretationConfidenceMillis int64
CapabilityGapID capability.CapabilityGapID
DelegationID string
DelegationState string
Reminder *continuity.ProspectiveItem
}
@@ -0,0 +1,26 @@
BEGIN;
SET ROLE capability_role;
ALTER TABLE capability.cognitive_provider_instances
ADD COLUMN IF NOT EXISTS billing_mode TEXT NOT NULL DEFAULT 'UNKNOWN',
ADD COLUMN IF NOT EXISTS input_cost_micros BIGINT,
ADD COLUMN IF NOT EXISTS output_cost_micros BIGINT,
ADD COLUMN IF NOT EXISTS request_cost_micros BIGINT;
ALTER TABLE capability.cognitive_provider_instances
ADD COLUMN IF NOT EXISTS auth_mode TEXT NOT NULL DEFAULT 'NONE';
ALTER TABLE capability.cognitive_provider_instances
DROP CONSTRAINT IF EXISTS cognitive_provider_instances_billing_mode_check,
ADD CONSTRAINT cognitive_provider_instances_billing_mode_check CHECK (billing_mode IN ('UNKNOWN','FREE','PER_INPUT_UNIT','PER_OUTPUT_UNIT','PER_REQUEST')),
DROP CONSTRAINT IF EXISTS cognitive_provider_instances_auth_mode_check,
ADD CONSTRAINT cognitive_provider_instances_auth_mode_check CHECK (auth_mode IN ('NONE','API_KEY','BEARER','USERNAME_PASSWORD','OAUTH','SECRET_FILE')),
DROP CONSTRAINT IF EXISTS cognitive_provider_instances_cost_check,
ADD CONSTRAINT cognitive_provider_instances_cost_check CHECK ((input_cost_micros IS NULL OR input_cost_micros >= 0) AND (output_cost_micros IS NULL OR output_cost_micros >= 0) AND (request_cost_micros IS NULL OR request_cost_micros >= 0));
ALTER TABLE capability.cognitive_model_descriptors
ADD COLUMN IF NOT EXISTS intelligence_score_millis BIGINT;
ALTER TABLE capability.cognitive_model_descriptors
DROP CONSTRAINT IF EXISTS cognitive_model_descriptors_intelligence_score_check,
ADD CONSTRAINT cognitive_model_descriptors_intelligence_score_check CHECK (intelligence_score_millis IS NULL OR (intelligence_score_millis >= 0 AND intelligence_score_millis <= 1000));
RESET ROLE;
COMMIT;
@@ -0,0 +1,70 @@
{
"task_id": "DEV-000084",
"task_revision": 1,
"architecture_revision": "DEV-000073-baseline",
"base_repo_revision": "0482e6ac14cd7625598a203dbdec9298b1bac04c",
"risk_tier": "C",
"intent": "Evolve the single-catalog cognitive orchestrator with an always-available built-in provider and task-aware selection across connected providers using capability, quality, latency, cost, and reliability evidence.",
"requirement_ids": [
"Built-in Domovoy cognition remains available without an external provider",
"Connected providers expose typed connection references without credential material",
"Provider selection considers task capability, quality, speed, cost, and reliability",
"Provider and model revisions remain replaceable as the catalog evolves"
],
"allowed_change_scope": {
"modules": ["capability", "cognitive-worker"],
"paths": [
"contracts/capability/cognitive_registry.go",
"contracts/cognitive/types.go",
"contracts/interaction/types.go",
"modules/capability/domain/cognitive_registry.go",
"modules/capability/domain/cognitive_registry_test.go",
"adapters/postgres/capability_repository.go",
"database/migrations/028_capability_cognitive_provider_profile.sql",
"cmd/cognitive-worker/main.go",
"cmd/cognitive-worker/gateway.go",
"cmd/cognitive-worker/gateway_registry_test.go",
"cmd/cognitive-worker/interpretation.go",
"cmd/cognitive-worker/interpretation_live_trace_test.go",
"cmd/cognitive-worker/discovery.go",
"cmd/creator-web/server.go",
"cmd/core-runtime/main.go",
"dev/tasks/DEV-000084-evolving-cognitive-provider-catalog.json"
]
},
"forbidden_change_scope": {
"paths": ["architecture/**", "security/**", "cmd/core-runtime/**", "cmd/creator-web/**", "deploy/**"]
},
"allowed_architecture_delta": {
"new_cross_module_dependencies": 0,
"new_canonical_owners": 0,
"new_privileges": 0,
"new_third_party_dependencies": 0,
"new_provider_adapters": 0,
"new_database_owner_roles": 0
},
"contracts": {
"consume": ["existing capability registry", "existing cognitive gateway"],
"may_change": ["versioned provider profile and task-aware selection fields"]
},
"semantic_owner": "capability",
"canonical_state": ["provider connection profile", "model suitability and performance evidence"],
"state_transitions": [
"discovered provider profile is validated before invocation",
"selection ranks eligible candidates without granting new authority",
"provider revision supersedes prior metadata without rewriting history"
],
"side_effects_and_privileges": ["No new privilege", "Credential material remains outside canonical registry"],
"persistence_and_migrations": ["One additive capability migration", "No cross-owner writes"],
"failure_retry_restart": ["Built-in provider remains available when registry or remote providers fail", "Provider failures are observed and excluded for the current attempt"],
"assumptions": ["V1 has one shared catalog and no user/group visibility", "Existing CredentialRef contract is retained", "Selection is advisory routing and does not authorize external actions"],
"acceptance_scenarios": [
"Built-in provider answers when no connected provider is invocable",
"Secret values never appear in provider registry responses or logs",
"Task requiring a capability excludes models without it",
"Quality, reliability, latency, and cost policy affect deterministic ranking",
"A failed primary provider falls back to another eligible provider"
],
"required_tests": ["go test ./modules/capability/domain", "go test ./cmd/cognitive-worker", "go test ./...", "go vet ./...", "devctl preflight", "devctl check-diff", "devctl check-architecture", "git diff --check"],
"terminal_gap_states": ["BLOCKED_BY_ARCHITECTURE_GAP", "BLOCKED_BY_SPEC_GAP", "BLOCKED_BY_MISSING_CAPABILITY", "BLOCKED_BY_CONFLICT"]
}
@@ -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)
}
}