provider URLs

Author: jaberjaber23

crates/openfang-api/src/routes.rs

@@ -4842,6 +4842,7 @@ pub async fn list_providers(State(state): State<Arc<AppState>>) -> impl IntoResp
             "model_count": p.model_count,
             "key_required": p.key_required,
             "api_key_env": p.api_key_env,
+            "base_url": p.base_url,
         });
 
         // For local providers, add reachability info via health probe
@@ -5899,6 +5900,122 @@ pub async fn test_provider(
     }
 }
 
+/// PUT /api/providers/{name}/url — Set a custom base URL for a provider.
+pub async fn set_provider_url(
+    State(state): State<Arc<AppState>>,
+    Path(name): Path<String>,
+    Json(body): Json<serde_json::Value>,
+) -> impl IntoResponse {
+    // Validate provider exists
+    let provider_exists = {
+        let catalog = state
+            .kernel
+            .model_catalog
+            .read()
+            .unwrap_or_else(|e| e.into_inner());
+        catalog.get_provider(&name).is_some()
+    };
+    if !provider_exists {
+        return (
+            StatusCode::NOT_FOUND,
+            Json(serde_json::json!({"error": format!("Unknown provider '{}'", name)})),
+        );
+    }
+
+    let base_url = match body["base_url"].as_str() {
+        Some(u) if !u.trim().is_empty() => u.trim().to_string(),
+        _ => {
+            return (
+                StatusCode::BAD_REQUEST,
+                Json(serde_json::json!({"error": "Missing or empty 'base_url' field"})),
+            );
+        }
+    };
+
+    // Validate URL scheme
+    if !base_url.starts_with("http://") && !base_url.starts_with("https://") {
+        return (
+            StatusCode::BAD_REQUEST,
+            Json(serde_json::json!({"error": "base_url must start with http:// or https://"})),
+        );
+    }
+
+    // Update catalog in memory
+    {
+        let mut catalog = state
+            .kernel
+            .model_catalog
+            .write()
+            .unwrap_or_else(|e| e.into_inner());
+        catalog.set_provider_url(&name, &base_url);
+    }
+
+    // Persist to config.toml [provider_urls] section
+    let config_path = state.kernel.config.home_dir.join("config.toml");
+    if let Err(e) = upsert_provider_url(&config_path, &name, &base_url) {
+        return (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            Json(serde_json::json!({"error": format!("Failed to save config: {e}")})),
+        );
+    }
+
+    // Probe reachability at the new URL
+    let probe =
+        openfang_runtime::provider_health::probe_provider(&name, &base_url).await;
+
+    (
+        StatusCode::OK,
+        Json(serde_json::json!({
+            "status": "saved",
+            "provider": name,
+            "base_url": base_url,
+            "reachable": probe.reachable,
+            "latency_ms": probe.latency_ms,
+        })),
+    )
+}
+
+/// Upsert a provider URL in the `[provider_urls]` section of config.toml.
+fn upsert_provider_url(
+    config_path: &std::path::Path,
+    provider: &str,
+    url: &str,
+) -> Result<(), Box<dyn std::error::Error>> {
+    let content = if config_path.exists() {
+        std::fs::read_to_string(config_path)?
+    } else {
+        String::new()
+    };
+
+    let mut doc: toml::Value = if content.trim().is_empty() {
+        toml::Value::Table(toml::map::Map::new())
+    } else {
+        toml::from_str(&content)?
+    };
+
+    let root = doc.as_table_mut().ok_or("Config is not a TOML table")?;
+
+    if !root.contains_key("provider_urls") {
+        root.insert(
+            "provider_urls".to_string(),
+            toml::Value::Table(toml::map::Map::new()),
+        );
+    }
+    let urls_table = root
+        .get_mut("provider_urls")
+        .and_then(|v| v.as_table_mut())
+        .ok_or("provider_urls is not a table")?;
+
+    urls_table.insert(provider.to_string(), toml::Value::String(url.to_string()));
+
+    if let Some(parent) = config_path.parent() {
+        std::fs::create_dir_all(parent)?;
+    }
+
+    std::fs::write(config_path, toml::to_string_pretty(&doc)?)?;
+    Ok(())
+}
+
 /// POST /api/skills/create — Create a local prompt-only skill.
 pub async fn create_skill(
     State(state): State<Arc<AppState>>,

crates/openfang-api/src/server.rs

@@ -460,6 +460,10 @@ pub async fn build_router(
             "/api/providers/{name}/test",
             axum::routing::post(routes::test_provider),
         )
+        .route(
+            "/api/providers/{name}/url",
+            axum::routing::put(routes::set_provider_url),
+        )
         .route(
             "/api/skills/create",
             axum::routing::post(routes::create_skill),

crates/openfang-api/static/index_body.html

@@ -2886,6 +2886,19 @@ <h4>LLM Providers</h4>
                   <template x-if="!p.api_key_env || p.key_required === false">
                     <div class="text-xs mt-2" style="color:var(--success)" x-show="p.auth_status !== 'configured' && p.auth_status !== 'not_set' && p.auth_status !== 'missing'">No API key needed &mdash; runs locally or is free</div>
                   </template>
+                  <!-- Base URL editor for local providers -->
+                  <template x-if="p.is_local">
+                    <div class="mt-3" style="border-top:1px solid var(--border);padding-top:8px">
+                      <div class="text-xs text-dim mb-1">Base URL</div>
+                      <div class="key-input-group">
+                        <input type="text" :placeholder="'http://localhost:...'" x-model="providerUrlInputs[p.id]" style="font-size:12px">
+                        <button class="btn btn-primary btn-sm" @click="saveProviderUrl(p)" :disabled="providerUrlSaving[p.id]">
+                          <span x-show="!providerUrlSaving[p.id]">Save</span>
+                          <span x-show="providerUrlSaving[p.id]" class="spinner" style="width:10px;height:10px;border-width:2px"></span>
+                        </button>
+                      </div>
+                    </div>
+                  </template>
                 </div>
               </template>
             </div>

crates/openfang-api/static/js/pages/settings.js

@@ -15,6 +15,8 @@ function settingsPage() {
     modelProviderFilter: '',
     modelTierFilter: '',
     providerKeyInputs: {},
+    providerUrlInputs: {},
+    providerUrlSaving: {},
     providerTesting: {},
     providerTestResults: {},
     loading: true,
@@ -208,6 +210,12 @@ function settingsPage() {
       try {
         var data = await OpenFangAPI.get('/api/providers');
         this.providers = data.providers || [];
+        for (var i = 0; i < this.providers.length; i++) {
+          var p = this.providers[i];
+          if (p.is_local && p.base_url && !this.providerUrlInputs[p.id]) {
+            this.providerUrlInputs[p.id] = p.base_url;
+          }
+        }
       } catch(e) { this.providers = []; }
     },
 
@@ -378,6 +386,28 @@ function settingsPage() {
       this.providerTesting[provider.id] = false;
     },
 
+    async saveProviderUrl(provider) {
+      var url = this.providerUrlInputs[provider.id];
+      if (!url || !url.trim()) { OpenFangToast.error('Please enter a base URL'); return; }
+      url = url.trim();
+      if (url.indexOf('http://') !== 0 && url.indexOf('https://') !== 0) {
+        OpenFangToast.error('URL must start with http:// or https://'); return;
+      }
+      this.providerUrlSaving[provider.id] = true;
+      try {
+        var result = await OpenFangAPI.put('/api/providers/' + encodeURIComponent(provider.id) + '/url', { base_url: url });
+        if (result.reachable) {
+          OpenFangToast.success(provider.display_name + ' URL saved &mdash; reachable (' + (result.latency_ms || '?') + 'ms)');
+        } else {
+          OpenFangToast.warning(provider.display_name + ' URL saved but not reachable');
+        }
+        await this.loadProviders();
+      } catch(e) {
+        OpenFangToast.error('Failed to save URL: ' + e.message);
+      }
+      this.providerUrlSaving[provider.id] = false;
+    },
+
     // -- Security methods --
     async loadSecurity() {
       this.secLoading = true;

crates/openfang-kernel/src/config_reload.rs

@@ -41,6 +41,8 @@ pub enum HotAction {
     ReloadA2aConfig,
     /// Fallback provider chain changed.
     ReloadFallbackProviders,
+    /// Provider base URL overrides changed.
+    ReloadProviderUrls,
 }
 
 // ---------------------------------------------------------------------------
@@ -235,6 +237,10 @@ pub fn build_reload_plan(old: &KernelConfig, new: &KernelConfig) -> ReloadPlan {
         plan.hot_actions.push(HotAction::ReloadFallbackProviders);
     }
 
+    if field_changed(&old.provider_urls, &new.provider_urls) {
+        plan.hot_actions.push(HotAction::ReloadProviderUrls);
+    }
+
     // ----- No-op fields -----
 
     if old.log_level != new.log_level {
@@ -461,6 +467,17 @@ mod tests {
         assert!(plan.hot_actions.contains(&HotAction::ReloadExtensions));
     }
 
+    #[test]
+    fn test_provider_urls_hot_reload() {
+        let a = default_cfg();
+        let mut b = default_cfg();
+        b.provider_urls
+            .insert("ollama".to_string(), "http://10.0.0.5:11434/v1".to_string());
+        let plan = build_reload_plan(&a, &b);
+        assert!(!plan.restart_required);
+        assert!(plan.hot_actions.contains(&HotAction::ReloadProviderUrls));
+    }
+
     // -----------------------------------------------------------------------
     // Mixed changes
     // -----------------------------------------------------------------------

crates/openfang-kernel/src/kernel.rs

@@ -590,9 +590,16 @@ impl OpenFangKernel {
             info!("RBAC enabled with {} users", auth.user_count());
         }
 
-        // Initialize model catalog and detect provider auth
+        // Initialize model catalog, detect provider auth, and apply URL overrides
         let mut model_catalog = openfang_runtime::model_catalog::ModelCatalog::new();
         model_catalog.detect_auth();
+        if !config.provider_urls.is_empty() {
+            model_catalog.apply_url_overrides(&config.provider_urls);
+            info!(
+                "applied {} provider URL override(s)",
+                config.provider_urls.len()
+            );
+        }
         let available_count = model_catalog.available_models().len();
         let total_count = model_catalog.list_models().len();
         let local_count = model_catalog
@@ -2762,6 +2769,14 @@ impl OpenFangKernel {
                     self.cron_scheduler
                         .set_max_total_jobs(new_config.max_cron_jobs);
                 }
+                HotAction::ReloadProviderUrls => {
+                    info!("Hot-reload: applying provider URL overrides");
+                    let mut catalog = self
+                        .model_catalog
+                        .write()
+                        .unwrap_or_else(|e| e.into_inner());
+                    catalog.apply_url_overrides(&new_config.provider_urls);
+                }
                 _ => {
                     // Other hot actions (channels, web, browser, extensions, etc.)
                     // are logged but not applied here — they require subsystem-specific