fix(gateway): restore provider model selection in chat

Restore provider groups and concrete model references in chat snapshots. Permit catalog selections while retaining named aliases and tenant model restrictions. Show the active model in /profile without requiring a task identity.

Refs: archie-core-mvek6
This commit is contained in:
sam committed 2026-10-14 21:03:30 +11:00
1 parent 66b22f4833
commit 5b9ff6fa47
4 files changed
+218 -39

No files matched your search

+74 -20
View File
@@ -4,6 +4,7 @@ import (
"context"
"fmt"
"slices"
"strings"
"sync"
"github.com/samcharles93/archie-core/internal/config"
@@ -12,9 +13,9 @@ import (
"github.com/samcharles93/archie-core/internal/infrastructure/modelcatalog"
)
// chatModelManager owns the process-local model alias selected for
// interactive chat. Switching it does not rewrite configuration or affect
// workflow steps.
// chatModelManager owns the model selection for interactive chat. Named
// aliases remain defaults; choosing a catalog model does not rewrite them
// or affect workflow steps.
type chatModelManager struct {
mu sync.RWMutex
aliases map[string]string
@@ -33,15 +34,12 @@ func newChatModelManager(aliases map[string]string) *chatModelManager {
}
// SetConfigured replaces the alias table after a live change to model-aliases.
// The active alias survives when it still exists; otherwise chat returns to
// the default alias.
// An available selection survives; otherwise chat returns to the default alias.
func (m *chatModelManager) SetConfigured(aliases map[string]string) {
m.mu.Lock()
defer m.mu.Unlock()
m.aliases = aliases
if !slices.Contains(config.ChatAliases(aliases), m.active) {
m.active = config.PurposeChat.DefaultAlias()
}
m.keepActiveLocked()
}
// SetModelCatalog replaces the provider display names and per-model details
@@ -64,6 +62,14 @@ func (m *chatModelManager) SetModelCatalog(snapshot modelcatalog.Snapshot) {
}
}
}
m.keepActiveLocked()
}
// keepActiveLocked retains an alias or an available model across live updates.
func (m *chatModelManager) keepActiveLocked() {
if !slices.Contains(config.ChatAliases(m.aliases), m.active) && !slices.Contains(chatModelRefs(m.aliases, m.details), m.active) {
m.active = config.PurposeChat.DefaultAlias()
}
}
func (m *chatModelManager) ProviderDisplayName(provider string) string {
@@ -79,16 +85,19 @@ func (m *chatModelManager) ModelDetails(ref string) (gateway.ModelDetails, bool)
return details, ok
}
// Models returns the aliases chat may switch between.
// Models returns the configured and catalog model references chat may select.
func (m *chatModelManager) Models() []string {
m.mu.RLock()
defer m.mu.RUnlock()
return config.ChatAliases(m.aliases)
return chatModelRefs(m.aliases, m.details)
}
func (m *chatModelManager) ActiveAlias() string {
m.mu.RLock()
defer m.mu.RUnlock()
if strings.Contains(m.active, "/") {
return ""
}
return m.active
}
@@ -96,20 +105,27 @@ func (m *chatModelManager) ActiveAlias() string {
func (m *chatModelManager) ActiveModel() string {
m.mu.RLock()
defer m.mu.RUnlock()
if strings.Contains(m.active, "/") {
return m.active
}
ref, _ := config.ResolveModel(m.aliases, m.active, config.PurposeChat)
return ref
}
func (m *chatModelManager) SetActiveModel(ctx context.Context, alias string) error {
func (m *chatModelManager) SetActiveModel(ctx context.Context, selection string) error {
if err := ctx.Err(); err != nil {
return err
}
aliases, err := m.aliasesFor(ctx)
if err != nil {
return err
}
if !slices.Contains(config.ChatAliases(aliases), selection) && !slices.Contains(m.modelRefsFor(ctx, aliases), selection) {
return fmt.Errorf("model or alias %q is not available", selection)
}
m.mu.Lock()
defer m.mu.Unlock()
if !slices.Contains(config.ChatAliases(m.aliases), alias) {
return fmt.Errorf("model alias %q is not configured", alias)
}
m.active = alias
m.active = selection
return nil
}
@@ -124,21 +140,59 @@ func (m *chatModelManager) aliasesFor(ctx context.Context) (map[string]string, e
return m.orgAliases(ctx)
}
// ModelsFor returns the aliases ctx's org may switch between.
// ModelsFor returns the model references ctx's org may select.
func (m *chatModelManager) ModelsFor(ctx context.Context) ([]string, error) {
aliases, err := m.aliasesFor(ctx)
if err != nil {
return nil, err
}
return config.ChatAliases(aliases), nil
return m.modelRefsFor(ctx, aliases), nil
}
// ModelFor resolves the active alias in ctx's org. An org that cannot use it
// gets an error, never another model.
// ModelFor resolves the current selection in the caller's org. A direct
// selection is checked again so revoked models stop serving turns.
func (m *chatModelManager) ModelFor(ctx context.Context) (string, error) {
aliases, err := m.aliasesFor(ctx)
if err != nil {
return "", err
}
return config.ResolveModel(aliases, m.ActiveAlias(), config.PurposeChat)
m.mu.RLock()
selection := m.active
m.mu.RUnlock()
if strings.Contains(selection, "/") {
if !slices.Contains(m.modelRefsFor(ctx, aliases), selection) {
return "", fmt.Errorf("model %q is not available in this org", selection)
}
return selection, nil
}
return config.ResolveModel(aliases, selection, config.PurposeChat)
}
// modelRefsFor keeps tenant choices within their assigned aliases; the
// system org can also choose from its credential-filtered provider catalog.
func (m *chatModelManager) modelRefsFor(ctx context.Context, aliases map[string]string) []string {
if org.OrgFromContext(ctx) != org.DefaultOrgID {
return chatModelRefs(aliases, nil)
}
m.mu.RLock()
defer m.mu.RUnlock()
return chatModelRefs(aliases, m.details)
}
func chatModelRefs(aliases map[string]string, catalog map[string]gateway.ModelDetails) []string {
refs := make(map[string]struct{}, len(catalog)+len(aliases))
for ref := range catalog {
refs[ref] = struct{}{}
}
for _, alias := range config.ChatAliases(aliases) {
if ref := strings.TrimSpace(aliases[alias]); ref != "" {
refs[ref] = struct{}{}
}
}
out := make([]string, 0, len(refs))
for ref := range refs {
out = append(out, ref)
}
slices.Sort(out)
return out
}
@@ -0,0 +1,101 @@
package archiegateway
import (
"context"
"slices"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/gateway"
"github.com/samcharles93/archie-core/internal/infrastructure/modelcatalog"
)
type modelSelectionSessions struct{ gateway.SessionStore }
func (modelSelectionSessions) List(context.Context) ([]gateway.SessionContext, error) {
return nil, nil
}
func TestChatModelSelection(t *testing.T) {
for _, tc := range []struct {
name string
org org.OrgID
selection string
want string
denied bool
}{
{"catalog model", org.DefaultOrgID, "openai/new", "openai/new", false},
{"configured alias", org.DefaultOrgID, "fast", "openai/small", false},
{"unknown model", org.DefaultOrgID, "openai/unknown", "openai/old", true},
{"org model", "tenant", "anthropic/sonnet", "anthropic/sonnet", false},
{"org alias", "tenant", "tenant-chat", "anthropic/sonnet", false},
{"other org model", "tenant", "openai/new", "anthropic/sonnet", true},
{"other org alias", "tenant", "fast", "anthropic/sonnet", true},
} {
t.Run(tc.name, func(t *testing.T) {
manager := newChatModelManager(map[string]string{"default": "openai/old", "fast": "openai/small"})
manager.SetModelCatalog(modelcatalog.Snapshot{Providers: []modelcatalog.Provider{
{ID: "openai", Models: []modelcatalog.Model{{ID: "old"}, {ID: "small"}, {ID: "new"}}},
{ID: "anthropic", Models: []modelcatalog.Model{{ID: "sonnet"}}},
}})
manager.orgAliases = func(context.Context) (map[string]string, error) {
return map[string]string{"default": "anthropic/sonnet", "tenant-chat": "anthropic/sonnet"}, nil
}
ctx := org.WithOrg(t.Context(), tc.org)
router := gateway.NewRouter(nil, nil, "telegram")
router.Models = manager
reply, err := router.Route(ctx, gateway.Inbound{Message: messaging.Message{Text: "/model " + tc.selection}})
if err != nil {
t.Fatal(err)
}
if denied := strings.HasPrefix(reply, "Cannot switch"); denied != tc.denied {
t.Fatalf("reply = %q, denied = %v", reply, tc.denied)
}
got, err := manager.ModelFor(ctx)
if err != nil || got != tc.want {
t.Fatalf("runtime model = %q, %v; want %q", got, err, tc.want)
}
adapter := &gateway.LocalChatAdapter{Router: router, Sessions: modelSelectionSessions{}, Models: manager}
snapshot, err := adapter.Snapshot(ctx)
if err != nil {
t.Fatal(err)
}
provider, _, _ := strings.Cut(tc.want, "/")
if snapshot.ActiveModel != tc.want || snapshot.ActiveProvider != provider || !slices.Contains(snapshot.ModelsByProvider[provider], tc.want) || !slices.Contains(snapshot.Providers, provider) {
t.Fatalf("selector lost model/provider: %+v", snapshot)
}
if tc.org != org.DefaultOrgID && slices.Contains(snapshot.Models, "openai/new") {
t.Fatal("selector exposed another org's model")
}
profile, err := router.Route(ctx, gateway.Inbound{Message: messaging.Message{Text: "/profile"}})
if err != nil || !strings.Contains(profile, tc.want) {
t.Fatalf("profile without task identity = %q, %v", profile, err)
}
})
}
}
func TestChatModelPickerAfterOrgChange(t *testing.T) {
manager := newChatModelManager(map[string]string{"default": "openai/old"})
manager.SetModelCatalog(modelcatalog.Snapshot{Providers: []modelcatalog.Provider{{ID: "openai", Models: []modelcatalog.Model{{ID: "new"}}}}})
manager.orgAliases = func(context.Context) (map[string]string, error) {
return map[string]string{"default": "anthropic/sonnet"}, nil
}
if err := manager.SetActiveModel(t.Context(), "openai/new"); err != nil {
t.Fatal(err)
}
ctx := org.WithOrg(t.Context(), "tenant")
if _, err := manager.ModelFor(ctx); err == nil {
t.Fatal("a tenant could execute the system org's model")
}
adapter := &gateway.LocalChatAdapter{Router: gateway.NewRouter(nil, nil, "telegram"), Sessions: modelSelectionSessions{}, Models: manager}
snapshot, err := adapter.Snapshot(ctx)
if err != nil {
t.Fatal(err)
}
if snapshot.ActiveModel != "" || !slices.Contains(snapshot.ModelsByProvider["anthropic"], "anthropic/sonnet") {
t.Fatalf("picker cannot recover from revoked model: %+v", snapshot)
}
}
+18 -1
View File
@@ -52,8 +52,25 @@ func (a *LocalChatAdapter) Snapshot(ctx context.Context) (ChatSnapshot, error) {
return ChatSnapshot{}, err
}
}
s.ActiveModel = a.Models.ActiveAlias()
s.ActiveModel = a.Models.ActiveModel()
if manager, ok := a.Models.(OrgModelManager); ok {
// Keep the picker available when a previous selection was revoked.
s.ActiveModel, _ = manager.ModelFor(ctx)
}
}
s.ActiveProvider, _, _ = strings.Cut(s.ActiveModel, "/")
for _, model := range s.Models {
provider, _, ok := strings.Cut(model, "/")
if !ok {
continue
}
s.ModelsByProvider[provider] = append(s.ModelsByProvider[provider], model)
}
for provider := range s.ModelsByProvider {
s.Providers = append(s.Providers, provider)
}
slices.Sort(s.Providers)
if a.Personas != nil {
s.Personas = slices.Clone(a.Personas.List())
for _, session := range sessions {
+25 -18
View File
@@ -55,19 +55,17 @@ type LLMStreamResponder func(ctx context.Context, in Inbound, stream TurnStream)
// runtime provider catalog. When nil on a Router, /model returns a
// "not configured" message.
type ModelManager interface {
// Models returns the model aliases chat may switch between.
// Models returns the model references chat may switch between.
Models() []string
// ActiveAlias returns the active model alias.
// ActiveAlias returns the selected alias, or empty for a direct model choice.
ActiveAlias() string
// ActiveModel returns the active alias's "provider/model" ref, or ""
// when the alias is not configured.
// ActiveModel returns the selected "provider/model" reference.
ActiveModel() string
// SetActiveModel switches the active alias. Returns an error if the
// alias is unknown.
// SetActiveModel selects an available model reference or a named alias.
SetActiveModel(ctx context.Context, alias string) error
}
// OrgModelManager is the optional org-aware extension: the aliases and the
// OrgModelManager is the optional org-aware extension: the choices and the
// active model for the org of the principal ctx carries.
type OrgModelManager interface {
ModelManager
@@ -354,7 +352,7 @@ func (r *Router) dispatchLocal(ctx context.Context, msg messaging.Message, platf
reply, err := r.handleWhoami()
return reply, true, err
case "/profile":
reply, err := r.handleProfile()
reply, err := r.handleProfile(ctx)
return reply, true, err
}
return r.dispatchLocalMisc(ctx, msg, platform, cmd, rest)
@@ -494,11 +492,11 @@ func (r *Router) handleModel(ctx context.Context, arg string) (string, error) {
return fmt.Sprintf("Cannot list models: %v", err), nil
}
if len(models) == 0 {
return "No model aliases configured.\nUsage: /model <alias>", nil
return "No models configured.\nUsage: /model <alias|provider/model>", nil
}
var b strings.Builder
b.WriteString("Usage: /model <alias>\nAvailable models:\n")
active := r.Models.ActiveAlias()
b.WriteString("Usage: /model <alias|provider/model>\nAvailable models:\n")
active := r.Models.ActiveModel()
for _, m := range models {
if m == active {
fmt.Fprintf(&b, " %s (active)\n", m)
@@ -514,7 +512,7 @@ func (r *Router) handleModel(ctx context.Context, arg string) (string, error) {
return fmt.Sprintf("Active model set to %s.", arg), nil
}
// chatModels lists the aliases the caller's org may switch between.
// chatModels lists the model references the caller's org may switch between.
func (r *Router) chatModels(ctx context.Context) ([]string, error) {
if manager, ok := r.Models.(OrgModelManager); ok {
return manager.ModelsFor(ctx)
@@ -908,14 +906,23 @@ func (r *Router) handleWhoami() (string, error) {
return b.String(), nil
}
func (r *Router) handleProfile() (string, error) {
if r.Identity == "" {
return "Profile is not configured (no identity set).", nil
}
func (r *Router) handleProfile(ctx context.Context) (string, error) {
var b strings.Builder
fmt.Fprintf(&b, "Identity: %s\n", r.Identity)
identity := r.Identity
if identity == "" {
identity = "not configured"
}
fmt.Fprintf(&b, "Identity: %s\n", identity)
if r.Models != nil {
fmt.Fprintf(&b, "Model: %s\n", r.Models.ActiveModel())
model := r.Models.ActiveModel()
if manager, ok := r.Models.(OrgModelManager); ok {
var err error
model, err = manager.ModelFor(ctx)
if err != nil {
return "", err
}
}
fmt.Fprintf(&b, "Model: %s\n", model)
}
return strings.TrimSpace(b.String()), nil
}