Files
archie/internal/app/archiegateway/chat_models.go
T

202 lines
6.2 KiB
Go

package archiegateway
import (
"context"
"fmt"
"slices"
"strings"
"sync"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/gateway"
"github.com/samcharles93/archie-core/internal/infrastructure/modelcatalog"
)
// 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
active map[org.OrgID]string
details map[string]gateway.ModelDetails
providerNames map[string]string
// orgAliases answers the aliases the principal ctx carries may use. Nil
// serves every caller the instance aliases.
orgAliases func(ctx context.Context) (map[string]string, error)
}
func newChatModelManager(aliases map[string]string) *chatModelManager {
m := &chatModelManager{active: make(map[org.OrgID]string), details: make(map[string]gateway.ModelDetails), providerNames: make(map[string]string)}
m.SetConfigured(aliases)
return m
}
// SetConfigured replaces the alias table after a live change to model-aliases.
// 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
m.keepActiveLocked()
}
// SetModelCatalog replaces the provider display names and per-model details
// the catalog publishes.
func (m *chatModelManager) SetModelCatalog(snapshot modelcatalog.Snapshot) {
m.mu.Lock()
defer m.mu.Unlock()
m.details = make(map[string]gateway.ModelDetails)
m.providerNames = make(map[string]string)
for _, provider := range snapshot.Providers {
m.providerNames[provider.ID] = provider.Name
for _, model := range provider.Models {
ref := provider.ID + "/" + model.ID
m.details[ref] = gateway.ModelDetails{
Ref: ref, Name: model.Name,
ContextWindow: model.ContextWindow, MaxOutputTokens: model.MaxOutputTokens,
Reasoning: model.Reasoning, Tools: true,
Attachment: model.Attachment, Structured: model.Structured,
InputModalities: slices.Clone(model.InputModalities),
}
}
}
m.keepActiveLocked()
}
// keepActiveLocked retains an alias or an available model across live updates.
func (m *chatModelManager) keepActiveLocked() {
selection := m.selectionLocked(org.DefaultOrgID)
if !slices.Contains(config.ChatAliases(m.aliases), selection) && !slices.Contains(chatModelRefs(m.aliases, m.details), selection) {
m.active[org.DefaultOrgID] = config.PurposeChat.DefaultAlias()
}
}
func (m *chatModelManager) ProviderDisplayName(provider string) string {
m.mu.RLock()
defer m.mu.RUnlock()
return m.providerNames[provider]
}
func (m *chatModelManager) ModelDetails(ref string) (gateway.ModelDetails, bool) {
m.mu.RLock()
defer m.mu.RUnlock()
details, ok := m.details[ref]
return details, ok
}
func (m *chatModelManager) selectionLocked(id org.OrgID) string {
if selection := m.active[id]; selection != "" {
return selection
}
return config.PurposeChat.DefaultAlias()
}
func (m *chatModelManager) ActiveAlias(ctx context.Context) string {
m.mu.RLock()
defer m.mu.RUnlock()
selection := m.selectionLocked(org.OrgFromContext(ctx))
if strings.Contains(selection, "/") {
return ""
}
return selection
}
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
}
m.mu.Lock()
defer m.mu.Unlock()
id := org.OrgFromContext(ctx)
if id == org.DefaultOrgID || m.orgAliases == nil {
aliases = m.aliases
}
if !slices.Contains(config.ChatAliases(aliases), selection) && !slices.Contains(m.refsLocked(id, aliases), selection) {
return fmt.Errorf("model or alias %q is not available", selection)
}
m.active[id] = selection
return nil
}
// aliasesFor is the alias table ctx's org resolves against: the instance's
// for the system org, the org's own answer otherwise.
func (m *chatModelManager) aliasesFor(ctx context.Context) (map[string]string, error) {
if m.orgAliases == nil || org.OrgFromContext(ctx) == org.DefaultOrgID {
m.mu.RLock()
defer m.mu.RUnlock()
return m.aliases, nil
}
return m.orgAliases(ctx)
}
// 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
}
m.mu.RLock()
defer m.mu.RUnlock()
id := org.OrgFromContext(ctx)
if id == org.DefaultOrgID || m.orgAliases == nil {
aliases = m.aliases
}
return m.refsLocked(id, aliases), nil
}
// 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
}
m.mu.RLock()
defer m.mu.RUnlock()
id := org.OrgFromContext(ctx)
if id == org.DefaultOrgID || m.orgAliases == nil {
aliases = m.aliases
}
selection := m.selectionLocked(id)
if strings.Contains(selection, "/") {
if !slices.Contains(m.refsLocked(id, aliases), selection) {
return "", fmt.Errorf("model %q is not available in this org", selection)
}
return selection, nil
}
return config.ResolveModel(aliases, selection, config.PurposeChat)
}
// refsLocked keeps tenant choices within their assigned aliases; the system
// org can also select from its credential-filtered provider catalog.
func (m *chatModelManager) refsLocked(id org.OrgID, aliases map[string]string) []string {
if id != org.DefaultOrgID {
return chatModelRefs(aliases, nil)
}
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
}