feat: dynamic model switching — /model <name> for any configured provider

- Router refactored to use providers map[string]Provider
- /model list shows all available models
- /model <name> switches to any configured model (validated)
- /model reset clears override back to auto-routing
- Added qwen_122b (qwen3.5-122b-a10b) and qwen_max (qwen3-max)
- Routing roles (multimodal, reasoner) now configurable in config.yaml

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Alexey Panfilov

cmd/agent/main.go

@@ -35,38 +35,69 @@ func main() {
 		os.Exit(1)
 	}
 
-	// Init LLM providers
+	// Build providers map — all named LLM providers available for routing and /model switching.
+	providers := make(map[string]llm.Provider)
+
+	addProvider := func(key string, p llm.Provider, e error) {
+		if e != nil {
+			logger.Warn("failed to init LLM provider", "key", key, "err", e)
+			return
+		}
+		providers[key] = p
+	}
+
+	// Primary (required)
 	primary, err := llm.NewDeepSeek(cfg.Models.Default)
 	if err != nil {
 		logger.Error("failed to init primary LLM", "err", err)
 		os.Exit(1)
 	}
+	providers[cfg.Routing.Default] = primary
 
-	var fallback llm.Provider
+	// Optional providers
+	if cfg.Models.Reasoner.APIKey != "" {
+		p, e := llm.NewDeepSeek(cfg.Models.Reasoner)
+		addProvider("reasoner", p, e)
+	}
 	if cfg.Models.FlashLite.APIKey != "" {
-		fallback, err = llm.NewGemini(cfg.Models.FlashLite)
-		if err != nil {
-			logger.Warn("failed to init fallback LLM", "err", err)
-		}
+		p, e := llm.NewGemini(cfg.Models.FlashLite)
+		addProvider("flash_lite", p, e)
 	}
-
-	var reasoner llm.Provider
-	if cfg.Models.Reasoner.APIKey != "" {
-		reasoner, err = llm.NewDeepSeek(cfg.Models.Reasoner)
-		if err != nil {
-			logger.Warn("failed to init reasoner LLM", "err", err)
-		}
+	if cfg.Models.Multimodal.APIKey != "" {
+		p, e := llm.NewGeminiMultimodal(cfg.Models.Multimodal)
+		addProvider("multimodal", p, e)
+	}
+	if cfg.Models.QwenFlash.APIKey != "" {
+		p, e := llm.NewQwen(cfg.Models.QwenFlash)
+		addProvider("qwen_flash", p, e)
+	}
+	if cfg.Models.Qwen122b.APIKey != "" {
+		p, e := llm.NewQwen(cfg.Models.Qwen122b)
+		addProvider("qwen_122b", p, e)
+	}
+	if cfg.Models.QwenMax.APIKey != "" {
+		p, e := llm.NewQwen(cfg.Models.QwenMax)
+		addProvider("qwen_max", p, e)
 	}
 
-	var multimodal llm.Provider
-	if cfg.Models.Multimodal.APIKey != "" {
-		multimodal, err = llm.NewGeminiMultimodal(cfg.Models.Multimodal)
-		if err != nil {
-			logger.Warn("failed to init multimodal LLM", "err", err)
-		}
+	// Default role keys if not specified
+	multimodalKey := cfg.Routing.Multimodal
+	if multimodalKey == "" {
+		multimodalKey = "multimodal"
+	}
+	reasonerKey := cfg.Routing.Reasoner
+	if reasonerKey == "" {
+		reasonerKey = "reasoner"
 	}
 
-	router := llm.NewRouter(primary, fallback, reasoner, multimodal, cfg.Routing.ClassifierMinLength)
+	router := llm.NewRouter(providers, llm.RouterConfig{
+		Primary:          cfg.Routing.Default,
+		Fallback:         cfg.Routing.Fallback,
+		Multimodal:       multimodalKey,
+		Reasoner:         reasonerKey,
+		Classifier:       cfg.Routing.Classifier,
+		ClassifierMinLen: cfg.Routing.ClassifierMinLength,
+	})
 
 	// Init store (SQLite if data dir exists, otherwise memory)
 	var s store.Store
@@ -118,7 +149,7 @@ func main() {
 	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
 	defer stop()
 
-	logger.Info("agent started", "model", router.Name(), "mcp_servers", len(mcpServers))
+	logger.Info("agent started", "model", router.Name(), "providers", len(providers), "mcp_servers", len(mcpServers))
 	handler.Start(ctx)
 	logger.Info("agent stopped")
 }

config/config.yaml

@@ -33,11 +33,30 @@ models:
     provider: gemini
     model: gemini-embedding-001
     api_key: ${GEMINI_API_KEY}
+  qwen_flash:
+    provider: qwen
+    model: qwen3.5-flash
+    api_key: ${QWEN_API_KEY}
+    max_tokens: 1
+    base_url: https://dashscope-intl.aliyuncs.com/compatible-mode/v1
+  qwen_122b:
+    provider: qwen
+    model: qwen3.5-122b-a10b
+    api_key: ${QWEN_API_KEY}
+    max_tokens: 4096
+    base_url: https://dashscope-intl.aliyuncs.com/compatible-mode/v1
+  qwen_max:
+    provider: qwen
+    model: qwen3-max
+    api_key: ${QWEN_API_KEY}
+    max_tokens: 8192
+    base_url: https://dashscope-intl.aliyuncs.com/compatible-mode/v1
 
 routing:
   default: default
   fallback: flash_lite
   compaction_model: default
+  classifier: qwen_flash
   classifier_min_length: 100
 
 tool_filter:

internal/agent/agent.go

@@ -104,8 +104,8 @@ func (a *Agent) Compact(ctx context.Context, chatID int64) error {
 	return a.compacter.Compact(ctx, chatID, a.store)
 }
 
-func (a *Agent) SetModel(override string) {
-	a.router.SetOverride(override)
+func (a *Agent) SetModel(override string) error {
+	return a.router.SetOverride(override)
 }
 
 func (a *Agent) ModelName() string {
@@ -116,6 +116,10 @@ func (a *Agent) ModelOverride() string {
 	return a.router.GetOverride()
 }
 
+func (a *Agent) ListModels() []string {
+	return a.router.ProviderNames()
+}
+
 type ToolInfo struct {
 	Name       string
 	ServerName string

internal/config/config.go

@@ -46,11 +46,17 @@ type ModelsConfig struct {
 	FlashLite  ModelConfig `yaml:"flash_lite"`
 	Multimodal ModelConfig `yaml:"multimodal"`
 	Embedding  ModelConfig `yaml:"embedding"`
+	QwenFlash  ModelConfig `yaml:"qwen_flash"`
+	Qwen122b   ModelConfig `yaml:"qwen_122b"`
+	QwenMax    ModelConfig `yaml:"qwen_max"`
 }
 
 type RoutingConfig struct {
 	Default             string `yaml:"default"`
 	Fallback            string `yaml:"fallback"`
+	Multimodal          string `yaml:"multimodal"`
+	Reasoner            string `yaml:"reasoner"`
+	Classifier          string `yaml:"classifier"`            // model for reasoning classifier; empty = use primary
 	CompactionModel     string `yaml:"compaction_model"`
 	ClassifierMinLength int    `yaml:"classifier_min_length"` // 0 = disabled
 }

internal/llm/qwen.go

@@ -0,0 +1,7 @@
+package llm
+
+import "telegram-agent/internal/config"
+
+func NewQwen(cfg config.ModelConfig) (*openAICompatProvider, error) {
+	return newOpenAICompat(cfg, "", "qwen")
+}

internal/llm/router.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"log/slog"
+	"sort"
 	"strings"
 	"sync"
 
@@ -12,97 +13,144 @@ import (
 
 const classifierPrompt = `Does this message require deep step-by-step reasoning, mathematical proof, or complex multi-step analysis? Reply with only 'yes' or 'no'.`
 
+// RouterConfig holds the keys into the providers map for special roles.
+type RouterConfig struct {
+	Primary          string
+	Fallback         string
+	Multimodal       string
+	Reasoner         string
+	Classifier       string // provider used for reasoning classification; falls back to Primary if empty
+	ClassifierMinLen int    // min rune length to run classifier; 0 = disabled
+}
+
 // Router selects the appropriate LLM provider based on context.
-// Primary → Fallback on 5xx/network error.
-// Reasoner → selected by LLM classifier or explicit /model command.
-// Multimodal → selected when message contains image parts.
+// All providers are stored by name; special roles reference names from RouterConfig.
 type Router struct {
-	primary    Provider
-	fallback   Provider // used if primary is unavailable
-	reasoner   Provider // used for complex reasoning
-	multimodal Provider // used when message contains images
-
-	classifierMinLen int // min message length to run classifier; 0 = disabled
+	providers map[string]Provider
+	cfg       RouterConfig
 
 	mu       sync.RWMutex
-	override string // "reasoner" or "" (primary)
+	override string // set via SetOverride; any key in providers, or "" for auto
 
-	OnFallback func(from, to string) // optional: called when fallback is triggered
-
-	logger *slog.Logger
+	OnFallback func(from, to string)
+	logger     *slog.Logger
 }
 
-func NewRouter(primary, fallback, reasoner, multimodal Provider, classifierMinLen int) *Router {
+func NewRouter(providers map[string]Provider, cfg RouterConfig) *Router {
 	return &Router{
-		primary:          primary,
-		fallback:         fallback,
-		reasoner:         reasoner,
-		multimodal:       multimodal,
-		classifierMinLen: classifierMinLen,
-		logger:           slog.Default(),
+		providers: providers,
+		cfg:       cfg,
+		logger:    slog.Default(),
 	}
 }
 
 func (r *Router) Chat(ctx context.Context, messages []Message, systemPrompt string, tools []Tool) (Response, error) {
 	provider := r.pick(ctx, messages)
 
 	resp, err := provider.Chat(ctx, messages, systemPrompt, tools)
-	if err != nil && r.fallback != nil && provider != r.fallback && isUnavailable(err) {
-		if r.OnFallback != nil {
-			r.OnFallback(provider.Name(), r.fallback.Name())
+	if err != nil && isUnavailable(err) {
+		if fallback := r.get(r.cfg.Fallback); fallback != nil && fallback != provider {
+			if r.OnFallback != nil {
+				r.OnFallback(provider.Name(), fallback.Name())
+			}
+			resp, err = fallback.Chat(ctx, messages, systemPrompt, tools)
 		}
-		resp, err = r.fallback.Chat(ctx, messages, systemPrompt, tools)
 	}
 	return resp, err
 }
 
+// Name returns the name of the currently active provider (respecting override).
 func (r *Router) Name() string {
 	return r.pick(context.Background(), nil).Name()
 }
 
-func (r *Router) SetOverride(model string) {
+// SetOverride sets a named model override. Pass "" to clear. Returns error if name is unknown.
+func (r *Router) SetOverride(name string) error {
+	if name != "" {
+		if _, ok := r.providers[name]; !ok {
+			return errors.New("unknown model: " + name)
+		}
+	}
 	r.mu.Lock()
-	defer r.mu.Unlock()
-	r.override = model
+	r.override = name
+	r.mu.Unlock()
+	return nil
 }
 
+// GetOverride returns the current override name (empty = auto).
 func (r *Router) GetOverride() string {
 	r.mu.RLock()
 	defer r.mu.RUnlock()
 	return r.override
 }
 
+// ProviderNames returns sorted list of all available provider names.
+func (r *Router) ProviderNames() []string {
+	names := make([]string, 0, len(r.providers))
+	for k := range r.providers {
+		names = append(names, k)
+	}
+	sort.Strings(names)
+	return names
+}
+
 func (r *Router) pick(ctx context.Context, messages []Message) Provider {
+	// Multimodal takes priority — only vision-capable models support image parts
+	if p := r.get(r.cfg.Multimodal); p != nil && hasMultimodalContent(messages) {
+		return p
+	}
+
 	r.mu.RLock()
 	override := r.override
 	r.mu.RUnlock()
 
-	// Multimodal takes priority — DeepSeek doesn't support vision
-	if r.multimodal != nil && hasMultimodalContent(messages) {
-		return r.multimodal
-	}
-
-	if override == "reasoner" && r.reasoner != nil {
-		return r.reasoner
+	if override != "" {
+		if p := r.get(override); p != nil {
+			return p
+		}
 	}
 
 	// Classifier-based routing to reasoner
-	if r.reasoner != nil && r.classifierMinLen > 0 {
-		if text := lastUserText(messages); len([]rune(text)) >= r.classifierMinLen {
-			if r.classify(ctx, text) {
-				return r.reasoner
+	if r.cfg.ClassifierMinLen > 0 {
+		if p := r.get(r.cfg.Reasoner); p != nil {
+			if text := lastUserText(messages); len([]rune(text)) >= r.cfg.ClassifierMinLen {
+				if r.classify(ctx, text) {
+					return p
+				}
 			}
 		}
 	}
 
-	return r.primary
+	if p := r.get(r.cfg.Primary); p != nil {
+		return p
+	}
+	// Should never happen if config is valid
+	for _, p := range r.providers {
+		return p
+	}
+	return nil
+}
+
+func (r *Router) get(key string) Provider {
+	if key == "" {
+		return nil
+	}
+	return r.providers[key]
 }
 
-// classify calls the primary LLM with a minimal prompt to determine
-// if the message requires deep reasoning. Returns false on any error.
+// classify calls the classifier provider (or primary) to determine if the message
+// requires deep reasoning. Returns false on any error.
 func (r *Router) classify(ctx context.Context, text string) bool {
+	classifierKey := r.cfg.Classifier
+	if classifierKey == "" {
+		classifierKey = r.cfg.Primary
+	}
+	provider := r.get(classifierKey)
+	if provider == nil {
+		return false
+	}
 	msgs := []Message{{Role: "user", Content: text}}
-	resp, err := r.primary.Chat(ctx, msgs, classifierPrompt, nil)
+	resp, err := provider.Chat(ctx, msgs, classifierPrompt, nil)
 	if err != nil {
 		r.logger.Warn("classifier call failed, using primary", "err", err)
 		return false