refactor(provider): tighten a handful of helpers

Five small simplifications, no behaviour change. All touched functions remain at 100% line coverage and overall package coverage nudges from 96.9% to 98.2%.

  * mergeCloneOptions: apply every Opt to a single ModelOptions accumulator and read the final effective MaxTokens / NoThinking once, instead of allocating a fresh tempOpts per option and re-checking inside the loop. Later-opt-wins semantics are now an obvious property of the accumulator rather than a property of "the last loop iteration that set the field".

  * resolveEffectiveProvider: replace the if/else fallback to "openai" with cmp.Or(cfg.Provider, "openai").

  * isOpenAICompatibleProvider: drop the default: arm so that the alias fallthrough sits at function scope, removing one indentation level and a redundant return false.

  * resolveProviderType: drop the cfg.ProviderOpts != nil guard. Reading from a nil map is well-defined and yields the zero value, which the existing type-assertion already handles.

  * mergeFromProviderConfig: reuse setProviderOptIfAbsent for the ProviderOpts merge loop instead of inlining the lazy-init + has-key dance, which already exists in that helper.

Assisted-By: docker-agent

Author: dgageot

pkg/model/provider/clone.go

@@ -42,20 +42,19 @@ func mergeCloneOptions(cfg base.Config, opts []options.Opt) (latest.ModelConfig,
 	baseOpts := options.FromModelOptions(cfg.ModelOptions)
 	mergedOpts := append(baseOpts, opts...)
 
-	// Apply max_tokens override if present in options
-	// We need to apply it to the ModelConfig itself since that's what providers use
-	// Only update MaxTokens if an option explicitly sets it (non-zero value)
-	modelConfig := cfg.ModelConfig
+	// Apply every option to a single accumulator so we can read the final
+	// effective values directly. "Later opt wins" semantics fall out naturally.
+	var merged options.ModelOptions
 	for _, opt := range mergedOpts {
-		tempOpts := &options.ModelOptions{}
-		opt(tempOpts)
-		if mt := tempOpts.MaxTokens(); mt != 0 {
-			modelConfig.MaxTokens = &mt
-		}
-		if tempOpts.NoThinking() {
-			modelConfig.ThinkingBudget = nil
-		}
+		opt(&merged)
 	}
 
+	modelConfig := cfg.ModelConfig
+	if mt := merged.MaxTokens(); mt != 0 {
+		modelConfig.MaxTokens = &mt
+	}
+	if merged.NoThinking() {
+		modelConfig.ThinkingBudget = nil
+	}
 	return modelConfig, mergedOpts
 }

pkg/model/provider/defaults.go

@@ -1,6 +1,7 @@
 package provider
 
 import (
+	"cmp"
 	"log/slog"
 	"maps"
 	"strings"
@@ -14,11 +15,10 @@ import (
 
 // resolveProviderType determines the effective API type for a config.
 // Priority: ProviderOpts["api_type"] > built-in alias > provider name.
+// Reading from a nil ProviderOpts map is safe and yields the zero value.
 func resolveProviderType(cfg *latest.ModelConfig) string {
-	if cfg.ProviderOpts != nil {
-		if apiType, ok := cfg.ProviderOpts["api_type"].(string); ok && apiType != "" {
-			return apiType
-		}
+	if apiType, ok := cfg.ProviderOpts["api_type"].(string); ok && apiType != "" {
+		return apiType
 	}
 	if alias, exists := LookupAlias(cfg.Provider); exists && alias.APIType != "" {
 		return alias.APIType
@@ -29,24 +29,18 @@ func resolveProviderType(cfg *latest.ModelConfig) string {
 // resolveEffectiveProvider returns the effective provider type for a ProviderConfig.
 // If Provider is explicitly set, returns that. Otherwise returns "openai" (backward compat).
 func resolveEffectiveProvider(cfg latest.ProviderConfig) string {
-	if cfg.Provider != "" {
-		return cfg.Provider
-	}
-	return "openai"
+	return cmp.Or(cfg.Provider, "openai")
 }
 
 // isOpenAICompatibleProvider returns true if the provider type uses the OpenAI API protocol.
 func isOpenAICompatibleProvider(providerType string) bool {
 	switch providerType {
 	case "openai", "openai_chatcompletions", "openai_responses":
 		return true
-	default:
-		// Check if it's an alias that maps to openai
-		if alias, exists := LookupAlias(providerType); exists {
-			return alias.APIType == "openai"
-		}
-		return false
 	}
+	// Otherwise, the type is OpenAI-compatible iff it's an alias that maps to OpenAI.
+	alias, exists := LookupAlias(providerType)
+	return exists && alias.APIType == "openai"
 }
 
 // ---------------------------------------------------------------------------
@@ -114,12 +108,7 @@ func mergeFromProviderConfig(dst *latest.ModelConfig, src latest.ProviderConfig)
 
 	// Merge provider_opts from provider config (model opts take precedence).
 	for k, v := range src.ProviderOpts {
-		if dst.ProviderOpts == nil {
-			dst.ProviderOpts = make(map[string]any)
-		}
-		if _, has := dst.ProviderOpts[k]; !has {
-			dst.ProviderOpts[k] = v
-		}
+		setProviderOptIfAbsent(dst, k, v)
 	}
 
 	// Set api_type in ProviderOpts if not already set.