feat(webui): support realtime provider/fallback routing with persistence

Author: czyt

pkg/agent/agent.go

@@ -3,6 +3,7 @@ package agent
 import (
 	"context"
 	"fmt"
+	"strings"
 	"time"
 
 	"go.uber.org/zap"
@@ -123,22 +124,39 @@ func (a *Agent) RegisterSkillTool(skillsManager *skills.Manager) {
 // Chat processes a user message and returns the agent's response.
 // It handles tool calls and iterates until the agent produces a final response.
 func (a *Agent) Chat(ctx context.Context, sess SessionInterface, userMessage string) (string, error) {
-	return a.chatWithModel(ctx, sess, userMessage, a.config.Agents.Defaults.Model)
+	return a.chatWithProviderModel(ctx, sess, userMessage, "", a.config.Agents.Defaults.Model, nil)
 }
 
 // ChatWithModel processes a message using a specific model override.
 func (a *Agent) ChatWithModel(ctx context.Context, sess SessionInterface, userMessage, model string) (string, error) {
-	return a.chatWithModel(ctx, sess, userMessage, model)
+	return a.chatWithProviderModel(ctx, sess, userMessage, "", model, nil)
 }
 
-func (a *Agent) chatWithModel(ctx context.Context, sess SessionInterface, userMessage, model string) (string, error) {
+// ChatWithProviderModel processes a message using provider/model overrides.
+func (a *Agent) ChatWithProviderModel(ctx context.Context, sess SessionInterface, userMessage, provider, model string) (string, error) {
+	return a.chatWithProviderModel(ctx, sess, userMessage, provider, model, nil)
+}
+
+// ChatWithProviderModelAndFallback processes a message using provider/model/fallback overrides.
+func (a *Agent) ChatWithProviderModelAndFallback(ctx context.Context, sess SessionInterface, userMessage, provider, model string, fallback []string) (string, error) {
+	return a.chatWithProviderModel(ctx, sess, userMessage, provider, model, fallback)
+}
+
+func (a *Agent) chatWithProviderModel(ctx context.Context, sess SessionInterface, userMessage, provider, model string, fallback []string) (string, error) {
 	a.logger.Info("Processing chat message",
 		zap.String("message", truncate(userMessage, 100)),
 	)
 	if model == "" {
 		model = a.config.Agents.Defaults.Model
 	}
 
+	providerOrder, err := a.buildProviderOrder(provider, fallback)
+	if err != nil {
+		return "", err
+	}
+	primaryProvider := providerOrder[0]
+	clientCache := make(map[string]*providers.Client)
+
 	// Build initial messages with session history
 	history := sess.GetMessages() // Get messages from session
 	messages := a.context.BuildMessages(history, userMessage)
@@ -176,13 +194,15 @@ func (a *Agent) chatWithModel(ctx context.Context, sess SessionInterface, userMe
 			}
 		}
 
-		// Call LLM
-		resp, err := a.client.Chat(ctx, req)
+		// Call LLM with provider fallback.
+		resp, providerUsed, modelUsed, err := a.callLLMWithFallback(ctx, req, primaryProvider, providerOrder, model, clientCache)
 		if err != nil {
 			return "", fmt.Errorf("LLM call failed: %w", err)
 		}
 
 		a.logger.Debug("LLM response",
+			zap.String("provider", providerUsed),
+			zap.String("model", modelUsed),
 			zap.String("content", truncate(resp.Content, 100)),
 			zap.Int("tool_calls", len(resp.ToolCalls)),
 			zap.String("finish_reason", resp.FinishReason),
@@ -236,6 +256,159 @@ func (a *Agent) chatWithModel(ctx context.Context, sess SessionInterface, userMe
 	return "", fmt.Errorf("max iterations (%d) reached without final response", a.maxIterations)
 }
 
+func (a *Agent) newClientForProvider(providerName, model string) (*providers.Client, error) {
+	providerCfg := a.config.GetProviderConfig(providerName)
+	if providerCfg == nil {
+		return nil, fmt.Errorf("provider not found: %s", providerName)
+	}
+
+	providerKind := strings.TrimSpace(providerCfg.ProviderKind)
+	if providerKind == "" {
+		providerKind = providerName
+	}
+
+	client, err := providers.NewClient(providerKind, &providers.RelayInfo{
+		ProviderName: providerName,
+		APIKey:       providerCfg.APIKey,
+		APIBase:      providerCfg.APIBase,
+		Model:        model,
+		Proxy:        providerCfg.Proxy,
+		Timeout:      providerCfg.GetTimeout(),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("create provider client for %s: %w", providerName, err)
+	}
+
+	return client, nil
+}
+
+func (a *Agent) buildProviderOrder(provider string, fallback []string) ([]string, error) {
+	primary := strings.TrimSpace(provider)
+	if primary == "" {
+		primary = strings.TrimSpace(a.config.Agents.Defaults.Provider)
+	}
+
+	fallbackOrder := fallback
+	if len(fallbackOrder) == 0 {
+		fallbackOrder = a.config.Agents.Defaults.Fallback
+	}
+
+	seen := make(map[string]struct{})
+	order := make([]string, 0, 1+len(fallbackOrder))
+
+	addProvider := func(name string) {
+		trimmed := strings.TrimSpace(name)
+		if trimmed == "" {
+			return
+		}
+		if _, ok := seen[trimmed]; ok {
+			return
+		}
+		seen[trimmed] = struct{}{}
+		order = append(order, trimmed)
+	}
+
+	addProvider(primary)
+	for _, name := range fallbackOrder {
+		addProvider(name)
+	}
+
+	if len(order) == 0 && len(a.config.Providers) > 0 {
+		addProvider(a.config.Providers[0].Name)
+	}
+
+	if len(order) == 0 {
+		return nil, fmt.Errorf("no providers configured")
+	}
+
+	return order, nil
+}
+
+func (a *Agent) callLLMWithFallback(
+	ctx context.Context,
+	req *providers.UnifiedRequest,
+	primaryProvider string,
+	providerOrder []string,
+	requestedModel string,
+	clientCache map[string]*providers.Client,
+) (*providers.UnifiedResponse, string, string, error) {
+	var lastErr error
+
+	for _, providerName := range providerOrder {
+		model := a.resolveModelForProvider(providerName, primaryProvider, requestedModel)
+
+		client, err := a.getProviderClient(providerName, model, clientCache)
+		if err != nil {
+			lastErr = err
+			a.logger.Warn("Provider unavailable", zap.String("provider", providerName), zap.Error(err))
+			continue
+		}
+
+		reqCopy := *req
+		reqCopy.Model = model
+
+		resp, err := client.Chat(ctx, &reqCopy)
+		if err != nil {
+			lastErr = err
+			a.logger.Warn("Provider request failed", zap.String("provider", providerName), zap.String("model", model), zap.Error(err))
+			continue
+		}
+
+		return resp, providerName, model, nil
+	}
+
+	if lastErr == nil {
+		lastErr = fmt.Errorf("no provider attempt made")
+	}
+	return nil, "", "", lastErr
+}
+
+func (a *Agent) getProviderClient(providerName, model string, cache map[string]*providers.Client) (*providers.Client, error) {
+	key := providerName + "::" + model
+	if client, ok := cache[key]; ok {
+		return client, nil
+	}
+
+	client, err := a.newClientForProvider(providerName, model)
+	if err != nil {
+		return nil, err
+	}
+	cache[key] = client
+	return client, nil
+}
+
+func (a *Agent) resolveModelForProvider(providerName, primaryProvider, requestedModel string) string {
+	model := strings.TrimSpace(requestedModel)
+	if model == "" {
+		model = strings.TrimSpace(a.config.Agents.Defaults.Model)
+	}
+	if providerName == primaryProvider {
+		return model
+	}
+
+	providerCfg := a.config.GetProviderConfig(providerName)
+	if providerCfg == nil {
+		return model
+	}
+
+	// If this provider declares no model list, keep caller's model.
+	if len(providerCfg.Models) == 0 {
+		return model
+	}
+
+	for _, candidate := range providerCfg.Models {
+		if strings.TrimSpace(candidate) == model {
+			return model
+		}
+	}
+
+	if fallbackModel := strings.TrimSpace(providerCfg.GetDefaultModel()); fallbackModel != "" {
+		return fallbackModel
+	}
+
+	return model
+}
+
 // executeToolCall executes a single tool call with approval checking.
 func (a *Agent) executeToolCall(ctx context.Context, toolCall providers.UnifiedToolCall) (string, error) {
 	a.logger.Info("Executing tool",

pkg/agent/agent_test.go

@@ -0,0 +1,80 @@
+package agent
+
+import (
+	"reflect"
+	"testing"
+
+	"nekobot/pkg/config"
+)
+
+func TestBuildProviderOrder_UsesOverrideAndFallback(t *testing.T) {
+	cfg := config.DefaultConfig()
+	cfg.Agents.Defaults.Provider = "anthropic"
+	cfg.Agents.Defaults.Fallback = []string{"openai", "ollama"}
+	cfg.Providers = []config.ProviderProfile{
+		{Name: "anthropic", ProviderKind: "anthropic"},
+		{Name: "openai", ProviderKind: "openai"},
+		{Name: "ollama", ProviderKind: "openai"},
+	}
+
+	ag := &Agent{config: cfg}
+
+	got, err := ag.buildProviderOrder("openai", []string{"ollama", "openai", "anthropic"})
+	if err != nil {
+		t.Fatalf("buildProviderOrder failed: %v", err)
+	}
+
+	want := []string{"openai", "ollama", "anthropic"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("expected provider order %v, got %v", want, got)
+	}
+}
+
+func TestBuildProviderOrder_UsesConfigDefaultsWhenRequestFallbackEmpty(t *testing.T) {
+	cfg := config.DefaultConfig()
+	cfg.Agents.Defaults.Provider = "anthropic"
+	cfg.Agents.Defaults.Fallback = []string{"openai"}
+	cfg.Providers = []config.ProviderProfile{
+		{Name: "anthropic", ProviderKind: "anthropic"},
+		{Name: "openai", ProviderKind: "openai"},
+	}
+
+	ag := &Agent{config: cfg}
+
+	got, err := ag.buildProviderOrder("", nil)
+	if err != nil {
+		t.Fatalf("buildProviderOrder failed: %v", err)
+	}
+
+	want := []string{"anthropic", "openai"}
+	if !reflect.DeepEqual(got, want) {
+		t.Fatalf("expected provider order %v, got %v", want, got)
+	}
+}
+
+func TestResolveModelForProvider_FallsBackToProviderDefaultModel(t *testing.T) {
+	cfg := config.DefaultConfig()
+	cfg.Agents.Defaults.Model = "claude-sonnet-4-5-20250929"
+	cfg.Providers = []config.ProviderProfile{
+		{
+			Name:         "anthropic",
+			ProviderKind: "anthropic",
+			Models:       []string{"claude-sonnet-4-5-20250929"},
+			DefaultModel: "claude-sonnet-4-5-20250929",
+		},
+		{
+			Name:         "openai",
+			ProviderKind: "openai",
+			Models:       []string{"gpt-4o-mini"},
+			DefaultModel: "gpt-4o-mini",
+		},
+	}
+
+	ag := &Agent{config: cfg}
+
+	got := ag.resolveModelForProvider("openai", "anthropic", "claude-sonnet-4-5-20250929")
+	want := "gpt-4o-mini"
+	if got != want {
+		t.Fatalf("expected model %q, got %q", want, got)
+	}
+}