perf: provider config and unify error display

Author: voocel

cmd/codebot/main.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 
+	"github.com/voocel/codebot/internal/apperr"
 	"github.com/voocel/codebot/internal/bootstrap"
 	"github.com/voocel/codebot/internal/config"
 	"github.com/voocel/codebot/internal/ui"
@@ -40,14 +41,14 @@ func main() {
 		ApprovalMode: *modeFlag,
 	})
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "boot error: %v\n", err)
+		fmt.Fprintln(os.Stderr, formatBootError(err))
 		os.Exit(1)
 	}
 	defer rt.Close()
 
 	if printMode {
 		if err := ui.RunPrint(rt.Session, flag.Args(), *jsonFlag); err != nil {
-			fmt.Fprintf(os.Stderr, "error: %v\n", err)
+			fmt.Fprintln(os.Stderr, formatCLIError(err))
 			os.Exit(1)
 		}
 		return
@@ -58,7 +59,15 @@ func main() {
 		modelName = rt.Session.ModelName()
 	}
 	if err := ui.RunTUI(rt.Session, rt.Cwd, rt.GitBranch, modelName, version, rt.ApprovalEngine, rt.TaskRuntime, rt.MCPManager, rt.MCPServers, rt.PluginCatalog, rt.SkillCatalog, rt.EnvHint, rt.SessionStore, rt.PlanSlug, rt.PlanTitle, rt.PlanPhase, rt.PlanPreMode, rt.PlanAllowedCommands); err != nil {
-		fmt.Fprintf(os.Stderr, "error: %v\n", err)
+		fmt.Fprintln(os.Stderr, formatCLIError(err))
 		os.Exit(1)
 	}
 }
+
+func formatBootError(err error) string {
+	return apperr.Format(err, "boot error")
+}
+
+func formatCLIError(err error) string {
+	return apperr.Format(err, "error")
+}

internal/agent/session_runtime.go

@@ -378,8 +378,12 @@ func (s *Session) resolveModelOverride(pattern string) (string, string, agentcor
 
 	if strings.Contains(pattern, "/") {
 		if prov, model, ok := strings.Cut(pattern, "/"); ok {
+			provType, err := s.providerType(prov)
+			if err != nil {
+				return "", "", nil, err
+			}
 			apiKey, baseURL := s.resolveCredentials(prov)
-			chatModel, err := s.createModel(s.providerType(prov), model, apiKey, baseURL)
+			chatModel, err := s.createModel(provType, model, apiKey, baseURL)
 			if err == nil {
 				return prov, model, chatModel, nil
 			}
@@ -401,12 +405,20 @@ func (s *Session) resolveModelOverride(pattern string) (string, string, agentcor
 	switch len(matches) {
 	case 1:
 		m := matches[0]
+		provType, err := s.providerType(m.provider)
+		if err != nil {
+			return "", "", nil, err
+		}
 		apiKey, baseURL := s.resolveCredentials(m.provider)
-		chatModel, err := s.createModel(s.providerType(m.provider), m.model, apiKey, baseURL)
+		chatModel, err := s.createModel(provType, m.model, apiKey, baseURL)
 		return m.provider, m.model, chatModel, err
 	case 0:
+		provType, err := s.providerType(curProv)
+		if err != nil {
+			return "", "", nil, err
+		}
 		apiKey, baseURL := s.resolveCredentials(curProv)
-		chatModel, err := s.createModel(s.providerType(curProv), pattern, apiKey, baseURL)
+		chatModel, err := s.createModel(provType, pattern, apiKey, baseURL)
 		if err != nil {
 			return "", "", nil, err
 		}
@@ -437,7 +449,10 @@ func (s *Session) reclampThinkingTemporary() {
 }
 
 func (s *Session) SetModel(prov, model string) error {
-	provType := s.providerType(prov)
+	provType, err := s.providerType(prov)
+	if err != nil {
+		return err
+	}
 	apiKey, baseURL := s.resolveCredentials(prov)
 	s.mu.Lock()
 	store := s.store
@@ -500,17 +515,14 @@ func (s *Session) SetModel(prov, model string) error {
 }
 
 // providerType returns the protocol type for a provider key.
-func (s *Session) providerType(prov string) string {
+func (s *Session) providerType(prov string) (string, error) {
 	s.mu.Lock()
 	pc, ok := s.providers[prov]
 	s.mu.Unlock()
 	if ok {
 		return pc.ProviderType(prov)
 	}
-	if t, ok := config.KnownProviderTypes[prov]; ok {
-		return t
-	}
-	return "openai"
+	return config.ResolveProviderType(prov, "")
 }
 
 func (s *Session) ResolveAndSetModel(pattern string) (string, error) {
@@ -583,13 +595,20 @@ func (s *Session) updateContextFromRegistry(providerKey, modelID string) {
 		return
 	}
 	// Try provider-qualified lookup using the protocol type.
-	provType := s.providerType(providerKey)
-	entry, _, err := s.registry.Resolve(provType + "/" + modelID)
-	if err != nil {
-		// Fallback to bare model ID for custom providers.
-		entry, _, err = s.registry.Resolve(modelID)
+	provType, err := s.providerType(providerKey)
+	if err == nil {
+		entry, _, err := s.registry.Resolve(provType + "/" + modelID)
+		if err == nil && entry.ContextWindow > 0 {
+			s.agent.SetContextWindow(entry.ContextWindow)
+			s.mu.Lock()
+			s.settings.ContextWindow = entry.ContextWindow
+			s.mu.Unlock()
+			return
+		}
 	}
+	entry, _, err := s.registry.Resolve(modelID)
 	if err != nil || entry.ContextWindow <= 0 {
+		// Fallback to bare model ID for custom providers.
 		return
 	}
 	s.agent.SetContextWindow(entry.ContextWindow)
@@ -756,7 +775,10 @@ func (s *Session) SwitchSession(id string) error {
 
 	var restoredModel agentcore.ChatModel
 	if snapshot.Model != "" || snapshot.Provider != "" {
-		targetType := s.providerType(targetProvider)
+		targetType, err := s.providerType(targetProvider)
+		if err != nil {
+			return err
+		}
 		restoredModel, err = s.createModel(targetType, targetModel, targetKey, targetBase)
 		if err != nil {
 			return fmt.Errorf("restore model %s/%s: %w", targetProvider, targetModel, err)

internal/apperr/errors.go

@@ -0,0 +1,68 @@
+package apperr
+
+import (
+	"errors"
+	"fmt"
+)
+
+// UserError exposes a concise user-facing message while preserving the full
+// wrapped error for logging and debugging.
+type UserError interface {
+	error
+	DisplayMessage() string
+}
+
+type Error struct {
+	Display string
+	Err     error
+}
+
+func (e *Error) Error() string {
+	if e == nil {
+		return ""
+	}
+	if e.Err == nil {
+		return e.Display
+	}
+	return e.Display + ": " + e.Err.Error()
+}
+
+func (e *Error) Unwrap() error {
+	if e == nil {
+		return nil
+	}
+	return e.Err
+}
+
+func (e *Error) DisplayMessage() string {
+	if e == nil {
+		return ""
+	}
+	return e.Display
+}
+
+func New(display string) error {
+	return &Error{Display: display}
+}
+
+func Newf(format string, args ...any) error {
+	return &Error{Display: fmt.Sprintf(format, args...)}
+}
+
+func Wrap(display string, err error) error {
+	return &Error{Display: display, Err: err}
+}
+
+func Format(err error, fallbackPrefix string) string {
+	if err == nil {
+		return ""
+	}
+	var display UserError
+	if errors.As(err, &display) {
+		return display.DisplayMessage()
+	}
+	if fallbackPrefix == "" {
+		return err.Error()
+	}
+	return fallbackPrefix + ": " + err.Error()
+}

internal/bootstrap/assemble_session.go

@@ -78,11 +78,9 @@ func resolveActiveModel(input *resolvedInput) (config.Resolved, string, agentcor
 	}
 
 	activeAPIKey, activeBaseURL := input.settings.ProviderCredentials(activeProvider)
-	provType := "openai"
-	if pc, ok := input.settings.Providers[activeProvider]; ok {
-		provType = pc.ProviderType(activeProvider)
-	} else if t, ok := config.KnownProviderTypes[activeProvider]; ok {
-		provType = t
+	provType, err := config.ResolveConfiguredProviderType(input.settings.Providers, activeProvider)
+	if err != nil {
+		return config.Resolved{}, "", nil, err
 	}
 	chatModel, err := input.modelFactory(provType, activeModel, activeAPIKey, activeBaseURL)
 	if err != nil {

internal/bootstrap/boot_test.go

@@ -103,3 +103,32 @@ func TestResolveInputEnvProviderDoesNotCreateSettingsFile(t *testing.T) {
 		t.Fatalf("project settings file should not be created, stat err = %v", err)
 	}
 }
+
+func TestBootCustomProviderRequiresExplicitType(t *testing.T) {
+	t.Setenv("HOME", t.TempDir())
+
+	cwd := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(cwd, ".codebot"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	data := `{
+  "provider": "myproxy",
+  "model": "gpt-4o-mini",
+  "providers": {
+    "myproxy": {
+      "api_key": "test-key"
+    }
+  }
+}`
+	if err := os.WriteFile(filepath.Join(cwd, ".codebot", "settings.json"), []byte(data), 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := Boot(Options{Cwd: cwd, NonTTYMode: true})
+	if err == nil {
+		t.Fatal("expected boot error for custom provider without type")
+	}
+	if err.Error() != `configuration error: providers.myproxy.type is required for custom providers` {
+		t.Fatalf("unexpected error: %v", err)
+	}
+}

internal/bootstrap/input.go

@@ -11,6 +11,7 @@ import (
 	"strings"
 
 	"github.com/voocel/codebot/internal/agent"
+	"github.com/voocel/codebot/internal/apperr"
 	"github.com/voocel/codebot/internal/approval"
 	"github.com/voocel/codebot/internal/config"
 	"github.com/voocel/codebot/internal/provider"
@@ -97,7 +98,7 @@ func ensureProviderSetup(cwd string, settings config.Resolved, nonTTY bool) (con
 		if hasConfiguredProviderCredentials(settings, settings.Provider) {
 			return settings, "", nil
 		}
-		return settings, "", fmt.Errorf("configuration error: settings.provider=%q is missing or not configured in settings.json", settings.Provider)
+		return settings, "", apperr.Newf("configuration error: settings.provider=%q is missing or not configured in settings.json", settings.Provider)
 	}
 
 	apiKey, _ := settings.ProviderCredentials(settings.Provider)

internal/bootstrap/subagents.go

@@ -33,9 +33,11 @@ func buildSubAgentTool(deps subAgentDeps) *agentcore.SubAgentTool {
 	if deps.SmallModel != "" && deps.CreateModel != nil {
 		prov := deps.Provider
 		apiKey, baseURL := resolveFromProviders(deps.Providers, prov)
-		provType := resolveProviderType(deps.Providers, prov)
-		if m, err := deps.CreateModel(provType, deps.SmallModel, apiKey, baseURL); err == nil {
-			exploreModel = m
+		provType, err := resolveProviderType(deps.Providers, prov)
+		if err == nil {
+			if m, err := deps.CreateModel(provType, deps.SmallModel, apiKey, baseURL); err == nil {
+				exploreModel = m
+			}
 		}
 	}
 
@@ -100,7 +102,10 @@ func buildSubAgentTool(deps subAgentDeps) *agentcore.SubAgentTool {
 				}
 			}
 			apiKey, baseURL := resolveFromProviders(providers, prov)
-			provType := resolveProviderType(providers, prov)
+			provType, err := resolveProviderType(providers, prov)
+			if err != nil {
+				return nil, err
+			}
 			return factory(provType, name, apiKey, baseURL)
 		})
 	}
@@ -137,14 +142,8 @@ func resolveFromProviders(providers map[string]config.ProviderConfig, prov strin
 }
 
 // resolveProviderType returns the protocol type for a provider key.
-func resolveProviderType(providers map[string]config.ProviderConfig, prov string) string {
-	if pc, ok := providers[prov]; ok {
-		return pc.ProviderType(prov)
-	}
-	if t, ok := config.KnownProviderTypes[prov]; ok {
-		return t
-	}
-	return "openai"
+func resolveProviderType(providers map[string]config.ProviderConfig, prov string) (string, error) {
+	return config.ResolveConfiguredProviderType(providers, prov)
 }
 
 // readOnlyTools constructs a read-only tool set for explore/plan sub-agents.

internal/config/settings.go

@@ -7,6 +7,9 @@ import (
 	"path/filepath"
 	"regexp"
 	"strings"
+
+	"github.com/voocel/codebot/internal/apperr"
+	"github.com/voocel/codebot/internal/provider"
 )
 
 // ConfigDir is the project-level config directory name.
@@ -22,24 +25,42 @@ var KnownProviderTypes = map[string]string{
 
 // ProviderConfig holds credentials and model configuration for a single provider.
 type ProviderConfig struct {
-	Type       string   `json:"type,omitempty"` // protocol: openai/anthropic/gemini; inferred from name if empty
+	Type       string   `json:"type,omitempty"` // LiteLLM provider type: openai/anthropic/gemini/openrouter; required for custom providers
 	APIKey     string   `json:"api_key,omitempty"`
 	BaseURL    string   `json:"base_url,omitempty"`
 	Models     []string `json:"models,omitempty"`      // available model list for this provider
 	SmallModel string   `json:"small_model,omitempty"` // lightweight model for sub-agents
 }
 
-// ProviderType returns the protocol type for this provider.
-// Uses explicit Type field first, then infers from the provider name,
-// defaulting to "openai" for unknown providers.
-func (pc ProviderConfig) ProviderType(name string) string {
-	if pc.Type != "" {
-		return pc.Type
+// ProviderType resolves the protocol type for this provider.
+// Built-in providers infer their type from the provider name.
+// Custom providers must declare providers.<name>.type explicitly.
+func (pc ProviderConfig) ProviderType(name string) (string, error) {
+	return ResolveProviderType(name, pc.Type)
+}
+
+// ResolveProviderType resolves a provider's protocol type.
+// The type value maps directly to the underlying LiteLLM provider name.
+func ResolveProviderType(name, explicitType string) (string, error) {
+	provType := strings.ToLower(strings.TrimSpace(explicitType))
+	if provType != "" {
+		if provider.IsSupportedType(provType) {
+			return provType, nil
+		}
+		return "", apperr.Newf("configuration error: providers.%s.type=%q is unsupported", name, explicitType)
 	}
 	if t, ok := KnownProviderTypes[name]; ok {
-		return t
+		return t, nil
+	}
+	return "", apperr.Newf("configuration error: providers.%s.type is required for custom providers", name)
+}
+
+// ResolveConfiguredProviderType resolves the protocol type for a configured provider.
+func ResolveConfiguredProviderType(providers map[string]ProviderConfig, name string) (string, error) {
+	if pc, ok := providers[name]; ok {
+		return pc.ProviderType(name)
 	}
-	return "openai"
+	return ResolveProviderType(name, "")
 }
 
 // HookEntry describes a single hook.
@@ -481,7 +502,7 @@ func loadSettingsFileStrict(path string) (Settings, error) {
 		return s, err
 	}
 	if err := json.Unmarshal(data, &s); err != nil {
-		return s, fmt.Errorf("malformed %s: %w", path, err)
+		return s, apperr.Wrap("configuration error: malformed settings.json", fmt.Errorf("%s: %w", path, err))
 	}
 	return s, nil
 }