fix(config): add per-provider api_base storage to survive provider switches

fewtarius · fewtarius · commit a5a30cf44c19 · 2026-04-13T17:01:40.000-04:00
Problem: Custom api_base URLs were stored as a single global value. When
switching providers, set_provider() deleted api_base from user_set (correct
for the new provider's defaults), which meant the previous provider's custom
base URL was lost on save(). Switching from llama.cpp back to github_copilot
and then back would lose the llama.cpp custom endpoint entirely.

Solution: Added per-provider api_bases storage, mirroring the existing
api_keys pattern. Config now saves {"api_bases":{"llama.cpp":"http://..."}}
alongside {"api_keys":{"llama.cpp":"1234"}}. set_provider() saves the
outgoing provider's custom base before switching and loads the incoming
provider's stored base. All cross-provider routing paths in APIManager,
Models, and Config now check per-provider stored bases before falling back
to static provider defaults.

Changes:
- Config.pm: api_bases in DEFAULT_CONFIG, get/set_provider_base() methods,
  set_provider() preserves outgoing base and loads incoming, load() checks
  stored bases before provider defaults
- API/Config.pm: _set_base() stores per-provider, _set_provider() uses
  stored bases for session-only and global paths, display shows source
- APIManager.pm: both cross-provider routing paths check stored bases
- API/Models.pm: _fetch_provider_models() uses stored bases

Testing: All 4 files pass perl -c syntax checks"
diff --git a/lib/CLIO/Core/APIManager.pm b/lib/CLIO/Core/APIManager.pm
@@ -906,10 +906,15 @@ sub get_model_capabilities {
             # Same provider as currently configured - use user's api_base (may be overridden)
             $api_base = $self->{api_base};
         } else {
-            # Different provider - look up its default api_base
-            require CLIO::Providers;
-            my $provider_def = CLIO::Providers::get_provider($target_provider);
-            $api_base = $provider_def ? $provider_def->{api_base} : $self->{api_base};
+            # Different provider - check per-provider stored base, then provider default
+            my $stored_base = $self->{config} ? $self->{config}->get_provider_base($target_provider) : undef;
+            if ($stored_base) {
+                $api_base = $stored_base;
+            } else {
+                require CLIO::Providers;
+                my $provider_def = CLIO::Providers::get_provider($target_provider);
+                $api_base = $provider_def ? $provider_def->{api_base} : $self->{api_base};
+            }
         }
     } else {
         $api_base = $self->{api_base};
@@ -1513,9 +1518,15 @@ sub _prepare_endpoint_config {
         # Model specifies a different provider - resolve its config
         $endpoint_config = $self->_get_endpoint_config_for_provider($target_provider);
         
-        require CLIO::Providers;
-        my $provider_def = CLIO::Providers::get_provider($target_provider);
-        $endpoint = $provider_def ? $provider_def->{api_base} : $self->{api_base};
+        # Check per-provider stored base, then provider default
+        my $stored_base = $self->{config} ? $self->{config}->get_provider_base($target_provider) : undef;
+        if ($stored_base) {
+            $endpoint = $stored_base;
+        } else {
+            require CLIO::Providers;
+            my $provider_def = CLIO::Providers::get_provider($target_provider);
+            $endpoint = $provider_def ? $provider_def->{api_base} : $self->{api_base};
+        }
     } else {
         # Use current provider config
         $endpoint_config = $self->get_endpoint_config();
diff --git a/lib/CLIO/Core/Config.pm b/lib/CLIO/Core/Config.pm
@@ -44,6 +44,7 @@ use constant LOG_LEVEL => {
 use constant DEFAULT_CONFIG => {
     api_key => '',
     api_keys => {},  # Per-provider API keys: { google => 'AIza...', minimax => '...' }
+    api_bases => {},  # Per-provider API base URLs: { 'llama.cpp' => 'http://localhost:9090/...' }
     provider => 'github_copilot',  # Default provider
     editor => $ENV{EDITOR} || $ENV{VISUAL} || 'vim',  # Default editor
     log_level => 'WARNING',  # Default log level: ERROR, WARNING, INFO, DEBUG
@@ -170,8 +171,14 @@ sub load {
         if ($provider_config) {
             # Apply provider's api_base unless user explicitly set it
             unless ($self->{user_set}->{api_base}) {
-                # For GitHub Copilot, try to get user-specific API endpoint
-                if ($config{provider} eq 'github_copilot') {
+                # Check per-provider stored base URL first
+                my $api_bases = $config{api_bases} || {};
+                my $stored_base = $api_bases->{$config{provider}};
+                if ($stored_base) {
+                    $config{api_base} = $stored_base;
+                    log_debug('Config', "Using stored api_base for provider '$config{provider}': $config{api_base}");
+                } elsif ($config{provider} eq 'github_copilot') {
+                    # For GitHub Copilot, try to get user-specific API endpoint
                     my $user_api_base = $self->_get_copilot_user_api_endpoint();
                     if ($user_api_base) {
                         $config{api_base} = $user_api_base;
@@ -320,13 +327,31 @@ sub set_provider {
         return 0;
     }
     
+    # Save outgoing provider's custom api_base before switching
+    # If the user had set a custom api_base for the current provider,
+    # preserve it in per-provider storage so it survives the switch
+    my $old_provider = $self->get('provider');
+    if ($old_provider && $self->{user_set}->{api_base}) {
+        my $current_base = $self->{config}->{api_base};
+        if ($current_base) {
+            $self->set_provider_base($old_provider, $current_base);
+            log_debug('Config', "Saved custom api_base for outgoing provider '$old_provider'");
+        }
+    }
+    
     my $provider_config = get_provider($provider);
     
     # Set provider name (this IS user-set - they chose the provider)
     $self->set('provider', $provider, 1);  # Mark as user-set
     
-    # Apply provider defaults (these are NOT user-set - they come from provider definition)
-    $self->{config}->{api_base} = $provider_config->{api_base};
+    # Load the incoming provider's stored api_base, or fall back to provider default
+    my $provider_base = $self->get_provider_base($provider);
+    if ($provider_base) {
+        $self->{config}->{api_base} = $provider_base;
+        log_debug('Config', "Loaded custom api_base for provider '$provider' from api_bases");
+    } else {
+        $self->{config}->{api_base} = $provider_config->{api_base};
+    }
     
     # Store default model with provider prefix (e.g., "github_copilot/claude-haiku-4.5")
     my $default_model = $provider_config->{model};
@@ -353,7 +378,7 @@ sub set_provider {
     delete $self->{user_set}->{model};
     
     log_debug('Config', "Switched to provider: $provider");
-    log_debug('Config', "api_base: $provider_config->{api_base} (from provider)");
+    log_debug('Config', "api_base: " . $self->{config}->{api_base} . " (from " . ($provider_base ? "stored" : "provider") . ")");
     log_debug('Config', "model: $provider_config->{model} (from provider)");
     
     return 1;
@@ -433,6 +458,61 @@ sub list_provider_keys {
     return sort keys %$api_keys;
 }
 
+=head2 get_provider_base($provider)
+
+Get the API base URL for a specific provider from per-provider storage.
+
+Arguments:
+- $provider: Provider name (e.g., 'llama.cpp', 'sam')
+
+Returns: API base URL string or undef if not set
+
+=cut
+
+sub get_provider_base {
+    my ($self, $provider) = @_;
+    
+    return unless $provider;
+    
+    my $api_bases = $self->{config}->{api_bases} || {};
+    return $api_bases->{$provider};
+}
+
+=head2 set_provider_base($provider, $url)
+
+Set the API base URL for a specific provider.
+This stores the URL in per-provider storage and also sets it as current
+if the provider matches the current provider.
+
+Arguments:
+- $provider: Provider name (e.g., 'llama.cpp', 'sam')
+- $url: API base URL value
+
+Returns: 1 on success
+
+=cut
+
+sub set_provider_base {
+    my ($self, $provider, $url) = @_;
+    
+    # Initialize api_bases hash if needed
+    $self->{config}->{api_bases} //= {};
+    
+    # Store the base URL
+    $self->{config}->{api_bases}{$provider} = $url;
+    $self->{user_set}->{api_bases} = 1;
+    
+    # If this is the current provider, also set api_base
+    my $current_provider = $self->get('provider');
+    if ($current_provider && $current_provider eq $provider) {
+        $self->{config}->{api_base} = $url;
+    }
+    
+    log_debug('Config', "Stored API base for provider '$provider': $url");
+    
+    return 1;
+}
+
 =head2 get_model_alias($name)
 
 Get the model value for a given alias name. Returns undef if not found.
diff --git a/lib/CLIO/UI/Commands/API/Config.pm b/lib/CLIO/UI/Commands/API/Config.pm
@@ -249,6 +249,14 @@ sub _set_base {
         return;
     }
 
+    # Store per-provider when setting globally
+    unless ($session_only) {
+        my $current_provider = $self->{config}->get('provider');
+        if ($current_provider) {
+            $self->{config}->set_provider_base($current_provider, $value);
+        }
+    }
+
     $self->_set_api_setting('api_base', $value, $session_only);
     $self->display_system_message("API base set to: $value" . ($session_only ? " (session only)" : " (saved)"));
     $self->_get_auth_helper()->reinit_api_manager();
@@ -360,11 +368,12 @@ sub _set_provider {
             $state->{api_config} ||= {};
             $state->{api_config}{provider} = $value;
 
-            # Also load the provider's api_base and api_key into config
+            # Load the provider's api_base (per-provider stored or default) and api_key
             # so the session can actually use this provider
+            my $stored_base = $self->{config}->get_provider_base($value);
             my $provider_config = CLIO::Providers::get_provider($value);
             if ($provider_config) {
-                $state->{api_config}{api_base} = $provider_config->{api_base};
+                $state->{api_config}{api_base} = $stored_base || $provider_config->{api_base};
                 # Load per-provider API key
                 my $provider_key = $self->{config}->get_provider_key($value);
                 if ($provider_key) {
@@ -378,10 +387,12 @@ sub _set_provider {
     } else {
         if ($self->{config}->set_provider($value)) {
             my $config = $self->{config}->get_all();
+            my $has_stored_base = $self->{config}->get_provider_base($value);
+            my $base_source = $has_stored_base ? "stored" : "provider default";
 
             if ($self->{config}->save()) {
                 $self->display_system_message("Switched to provider: $value (saved)");
-                $self->display_system_message("  API Base: " . $config->{api_base} . " (from provider)");
+                $self->display_system_message("  API Base: " . $config->{api_base} . " (from $base_source)");
                 $self->display_system_message("  Model: " . $config->{model} . " (from provider)");
             } else {
                 $self->display_system_message("Switched to provider: $value (warning: failed to save)");
diff --git a/lib/CLIO/UI/Commands/API/Models.pm b/lib/CLIO/UI/Commands/API/Models.pm
@@ -210,7 +210,9 @@ sub _fetch_provider_models {
             { id => 'MiniMax-M2',             name => 'MiniMax M2',             description => 'Function calling, advanced reasoning (204.8k ctx, 131k out)' },
         ];
     } else {
-        my $api_base = $provider_def->{api_base} || '';
+        # Use per-provider stored base URL if available, otherwise provider default
+        my $stored_base = $self->{config}->get_provider_base($provider_name);
+        my $api_base = $stored_base || $provider_def->{api_base} || '';
 
         my $models_url;
         if ($api_base =~ m{openrouter\.ai}i) {
