generic model listing and runtime model switching

Signed-off-by: Marek Safarik <msafarik@redhat.com>

Author: Marek Safarik

cmd/client/main.go

@@ -53,14 +53,14 @@ func main() {
 		return
 	}
 
-	provider, model := createProvider()
+	providers, initialProvider, initialModel := createProviders()
 
 	cfg := agent.Config{ServerPath: serverPath}
-	if model != "" {
-		cfg.Model = model
+	if initialModel != "" {
+		cfg.Model = initialModel
 	}
 
-	agentInstance := agent.NewAgent(cfg, provider)
+	agentInstance := agent.NewAgent(cfg, initialProvider)
 
 	if err := agentInstance.Connect(ctx); err != nil {
 		log.Printf("Failed to connect to MCP server: %v", err)
@@ -74,7 +74,7 @@ func main() {
 		return
 	}
 
-	srv, err := web.NewServer(ctx, agentInstance)
+	srv, err := web.NewServer(ctx, agentInstance, providers)
 	if err != nil {
 		log.Printf("Failed to create web server: %v", err)
 		return
@@ -89,26 +89,35 @@ func main() {
 	}
 }
 
-// createProvider selects the LLM provider based on environment variables.
-// OLLAMA_URL or OLLAMA_MODEL → local Ollama (Anthropic-compatible API)
-// ANTHROPIC_API_KEY → Claude cloud API
-func createProvider() (agent.LLMProvider, string) {
+func createProviders() ([]agent.LLMProvider, agent.LLMProvider, string) {
 	ollamaURL := os.Getenv("OLLAMA_URL")
 	ollamaModel := os.Getenv("OLLAMA_MODEL")
+	apiKey := strings.TrimSpace(os.Getenv("ANTHROPIC_API_KEY"))
+
+	if ollamaURL == "" {
+		ollamaURL = defaultOllamaURL
+	}
+
+	var providers []agent.LLMProvider
 
-	if ollamaURL != "" || ollamaModel != "" {
-		if ollamaURL == "" {
-			ollamaURL = defaultOllamaURL
-		}
+	var claudeProvider *agent.AnthropicProvider
+	if apiKey != "" {
+		claudeProvider = agent.NewClaudeProvider(apiKey)
+		providers = append(providers, claudeProvider)
+	}
+
+	ollamaProvider := agent.NewOllamaProvider(ollamaURL)
+	providers = append(providers, ollamaProvider)
+
+	if ollamaModel != "" || os.Getenv("OLLAMA_URL") != "" {
 		log.Printf("Using Ollama provider at %s", ollamaURL)
-		return agent.NewOllamaProvider(ollamaURL), ollamaModel
+		return providers, ollamaProvider, ollamaModel
 	}
 
-	apiKey := strings.TrimSpace(os.Getenv("ANTHROPIC_API_KEY"))
-	if apiKey == "" {
+	if claudeProvider == nil {
 		log.Fatal("Set ANTHROPIC_API_KEY for Claude or OLLAMA_URL/OLLAMA_MODEL for local Ollama")
 	}
 
 	log.Printf("Using Claude provider")
-	return agent.NewClaudeProvider(apiKey), ""
+	return providers, claudeProvider, ""
 }

internal/agent/agent.go

@@ -228,3 +228,12 @@ func (a *Agent) Reset() {
 	a.messages = []Message{}
 	a.toolQueue = nil
 }
+
+func (a *Agent) SetModel(provider LLMProvider, model string) {
+	a.provider = provider
+	a.config.Model = model
+}
+
+func (a *Agent) GetModel() string {
+	return a.config.Model
+}

internal/agent/provider.go

@@ -8,8 +8,11 @@ import (
 
 // LLMProvider defines the interface for LLM backends (Adapter pattern).
 // Each provider converts generic Messages and MCP tools into its native format.
+// Implementing a new provider requires only a new provider_X.go file.
 type LLMProvider interface {
 	Chat(ctx context.Context, opts ChatOptions) (*LLMResponse, error)
+	ListModels(ctx context.Context) ([]ModelInfo, error)
+	Name() string
 }
 
 // ChatOptions contains all parameters needed for an LLM API call.

internal/agent/provider_anthropic.go

@@ -6,33 +6,21 @@ import (
 
 	"github.com/anthropics/anthropic-sdk-go"
 	"github.com/anthropics/anthropic-sdk-go/option"
+	"github.com/anthropics/anthropic-sdk-go/packages/param"
 	"github.com/modelcontextprotocol/go-sdk/mcp"
 )
 
-type AnthropicProvider struct {
+// anthropicBase contains the shared Chat implementation for all providers
+// that use the Anthropic-compatible API (Anthropic cloud, Ollama, etc.).
+type anthropicBase struct {
 	client anthropic.Client
 }
 
-func NewClaudeProvider(apiKey string) *AnthropicProvider {
-	return &AnthropicProvider{
-		client: anthropic.NewClient(option.WithAPIKey(apiKey)),
-	}
-}
-
-func NewOllamaProvider(baseURL string) *AnthropicProvider {
-	return &AnthropicProvider{
-		client: anthropic.NewClient(
-			option.WithBaseURL(baseURL),
-			option.WithAPIKey("ollama"),
-		),
-	}
-}
-
-func (p *AnthropicProvider) Chat(ctx context.Context, opts ChatOptions) (*LLMResponse, error) {
+func (b *anthropicBase) Chat(ctx context.Context, opts ChatOptions) (*LLMResponse, error) {
 	messages := convertMessagesToAnthropic(opts.Messages)
 	tools := convertToolsToAnthropic(opts.Tools)
 
-	response, err := p.client.Messages.New(ctx, anthropic.MessageNewParams{
+	response, err := b.client.Messages.New(ctx, anthropic.MessageNewParams{
 		Model:     anthropic.Model(opts.Model),
 		MaxTokens: opts.MaxTokens,
 		System:    []anthropic.TextBlockParam{{Type: "text", Text: opts.SystemPrompt}},
@@ -46,6 +34,40 @@ func (p *AnthropicProvider) Chat(ctx context.Context, opts ChatOptions) (*LLMRes
 	return parseAnthropicResponse(response), nil
 }
 
+type AnthropicProvider struct {
+	anthropicBase
+}
+
+func NewClaudeProvider(apiKey string) *AnthropicProvider {
+	return &AnthropicProvider{
+		anthropicBase: anthropicBase{
+			client: anthropic.NewClient(option.WithAPIKey(apiKey)),
+		},
+	}
+}
+
+func (p *AnthropicProvider) Name() string { return "anthropic" }
+
+func (p *AnthropicProvider) ListModels(ctx context.Context) ([]ModelInfo, error) {
+	page, err := p.client.Models.List(ctx, anthropic.ModelListParams{
+		Limit: param.NewOpt[int64](1000),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to list Anthropic models: %w", err)
+	}
+
+	models := make([]ModelInfo, 0, len(page.Data))
+	for _, m := range page.Data {
+		models = append(models, ModelInfo{
+			ID:          m.ID,
+			DisplayName: m.DisplayName,
+			Provider:    "anthropic",
+		})
+	}
+
+	return models, nil
+}
+
 func convertMessagesToAnthropic(messages []Message) []anthropic.MessageParam {
 	result := make([]anthropic.MessageParam, 0, len(messages))
 

internal/agent/provider_ollama.go

@@ -0,0 +1,76 @@
+package agent
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"time"
+
+	"github.com/anthropics/anthropic-sdk-go"
+	"github.com/anthropics/anthropic-sdk-go/option"
+)
+
+type OllamaProvider struct {
+	anthropicBase
+	baseURL string
+}
+
+func NewOllamaProvider(baseURL string) *OllamaProvider {
+	return &OllamaProvider{
+		anthropicBase: anthropicBase{
+			client: anthropic.NewClient(
+				option.WithBaseURL(baseURL),
+				option.WithAPIKey("ollama"),
+			),
+		},
+		baseURL: baseURL,
+	}
+}
+
+func (p *OllamaProvider) Name() string { return "ollama" }
+
+func (p *OllamaProvider) ListModels(ctx context.Context) ([]ModelInfo, error) {
+	httpClient := &http.Client{Timeout: 5 * time.Second}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet, p.baseURL+"/api/tags", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create Ollama request: %w", err)
+	}
+
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to reach Ollama at %s: %w", p.baseURL, err)
+	}
+	defer resp.Body.Close()
+
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read Ollama response: %w", err)
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("Ollama API returned status %d: %s", resp.StatusCode, string(body))
+	}
+
+	var tagsResp struct {
+		Models []struct {
+			Name string `json:"name"`
+		} `json:"models"`
+	}
+	if err := json.Unmarshal(body, &tagsResp); err != nil {
+		return nil, fmt.Errorf("failed to parse Ollama response: %w", err)
+	}
+
+	models := make([]ModelInfo, 0, len(tagsResp.Models))
+	for _, m := range tagsResp.Models {
+		models = append(models, ModelInfo{
+			ID:          m.Name,
+			DisplayName: m.Name,
+			Provider:    "ollama",
+		})
+	}
+
+	return models, nil
+}

internal/agent/types.go

@@ -26,3 +26,9 @@ type ToolResult struct {
 	Output  string
 	IsError bool
 }
+
+type ModelInfo struct {
+	ID          string `json:"id"`
+	DisplayName string `json:"display_name"`
+	Provider    string `json:"provider"`
+}

internal/web/server.go

@@ -21,6 +21,7 @@ var templatesFS embed.FS
 // Server represents the web server for the chat interface
 type Server struct {
 	agent     *agent.Agent
+	providers []agent.LLMProvider
 	templates *template.Template
 	eventChan chan SSEvent
 	ctx       context.Context
@@ -33,14 +34,15 @@ type SSEvent struct {
 }
 
 // NewServer creates a new web server instance
-func NewServer(ctx context.Context, ag *agent.Agent) (*Server, error) {
+func NewServer(ctx context.Context, ag *agent.Agent, providers []agent.LLMProvider) (*Server, error) {
 	tmpl, err := template.ParseFS(templatesFS, "templates/*.html")
 	if err != nil {
 		return nil, fmt.Errorf("failed to parse templates: %w", err)
 	}
 
 	return &Server{
 		agent:     ag,
+		providers: providers,
 		templates: tmpl,
 		eventChan: make(chan SSEvent, 100),
 		ctx:       ctx,
@@ -57,6 +59,9 @@ func (s *Server) Start(addr string) error {
 	mux.HandleFunc("POST /tool/deny", s.handleToolDeny)
 	mux.HandleFunc("GET /events", s.handleSSE)
 	mux.HandleFunc("POST /reset", s.handleReset)
+	mux.HandleFunc("GET /api/models", s.handleListModels)
+	mux.HandleFunc("GET /api/model", s.handleGetModel)
+	mux.HandleFunc("POST /api/model", s.handleSetModel)
 
 	server := &http.Server{
 		Addr:              addr,
@@ -260,6 +265,65 @@ func (s *Server) send(event SSEvent) {
 	}
 }
 
+func (s *Server) handleListModels(w http.ResponseWriter, r *http.Request) {
+	var allModels []agent.ModelInfo
+
+	for _, p := range s.providers {
+		models, err := p.ListModels(r.Context())
+		if err != nil {
+			log.Printf("[MODELS] Failed to list %s models: %v", p.Name(), err)
+			continue
+		}
+		allModels = append(allModels, models...)
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	if err := json.NewEncoder(w).Encode(allModels); err != nil {
+		log.Printf("[ERROR] Failed to encode models response: %v", err)
+	}
+}
+
+func (s *Server) handleGetModel(w http.ResponseWriter, r *http.Request) {
+	w.Header().Set("Content-Type", "application/json")
+	resp := map[string]string{"model": s.agent.GetModel()}
+	if err := json.NewEncoder(w).Encode(resp); err != nil {
+		log.Printf("[ERROR] Failed to encode model response: %v", err)
+	}
+}
+
+func (s *Server) handleSetModel(w http.ResponseWriter, r *http.Request) {
+	r.Body = http.MaxBytesReader(w, r.Body, 1<<20)
+
+	var req struct {
+		Provider string `json:"provider"`
+		Model    string `json:"model"`
+	}
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request body", http.StatusBadRequest)
+		return
+	}
+	if req.Model == "" {
+		http.Error(w, "Model is required", http.StatusBadRequest)
+		return
+	}
+
+	for _, p := range s.providers {
+		if p.Name() == req.Provider {
+			s.agent.SetModel(p, req.Model)
+			log.Printf("[MODEL] Switched to %s/%s", req.Provider, req.Model)
+
+			w.Header().Set("Content-Type", "application/json")
+			resp := map[string]string{"model": req.Model, "provider": req.Provider}
+			if err := json.NewEncoder(w).Encode(resp); err != nil {
+				log.Printf("[ERROR] Failed to encode set model response: %v", err)
+			}
+			return
+		}
+	}
+
+	http.Error(w, fmt.Sprintf("Unknown provider: %s", req.Provider), http.StatusBadRequest)
+}
+
 func (s *Server) renderMessage(role, content, toolID string, tool *agent.ToolRequest) string {
 	data := map[string]interface{}{
 		"Role":    role,