Azimkin/svibe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add support for multiple providers of same type

Browse Source 
Features:
- Multiple OpenAI instances (e.g., OpenAI + local AI proxy)
- Multiple Ollama instances (e.g., local + remote)
- API key not required if at least one provider works without it
- Provider instances can have optional names for reference

Config format (TOML arrays):
[[providers.openai]]
name = "openai-main"
api_key = "sk-..."
base_url = "https://api.openai.com/v1"

[[providers.openai]]
name = "local-ai"
base_url = "http://localhost:8080/v1"

[[providers.ollama]]
name = "local"
base_url = "http://localhost:11434"

[[providers.ollama]]
name = "remote"
base_url = "http://192.168.1.100:11434"
bearer_token = "token"

Changes:
- config/types.rs: Changed providers from Option<T> to Vec<T>
- config/loader.rs: Updated merge logic for provider arrays
- providers/registry.rs: Register all provider instances, skip those without API keys if alternatives exist

Co-authored-by: Qwen-Coder <qwen-coder@alibabacloud.com>
This commit is contained in:
azimkin
2026-03-19 14:27:39 +01:00
parent d4cebe21c7
commit b66d474cd3
3 changed files with 108 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
src/config/loader.rs
View File

@@ -1,6 +1,5 @@
use super::{Config, ConfigError, Result, OpenAiConfig, OllamaConfig, AgentConfig, AgentModels};
use super::types::{default_openai_base_url, default_openai_model, default_ollama_base_url, default_ollama_model};
use std::collections::HashMap;
use std::path::{Path, PathBuf};
/// Configuration loader
@@ -138,17 +137,20 @@ fn find_local_config() -> Option<PathBuf> {
/// Merge environment variables into config
impl Config {
fn merge_env(&mut self) {
// OpenAI API key from environment
if let Some(ref mut openai) = self.providers.openai {
// OpenAI API key from environment (applies to first instance without key)
for openai in &mut self.providers.openai {
if openai.api_key.is_none() {
openai.api_key = std::env::var("OPENAI_API_KEY").ok();
if let Ok(key) = std::env::var("OPENAI_API_KEY") {
openai.api_key = Some(key);
break; // Only apply to first one
}
}
}
// Ollama base URL from environment
if let Some(ref mut ollama) = self.providers.ollama {
// Ollama base URL from environment (applies to all instances)
for ollama in &mut self.providers.ollama {
if let Ok(url) = std::env::var("OLLAMA_HOST") {
if !url.is_empty() {
if !url.is_empty() && ollama.base_url == default_ollama_base_url() {
ollama.base_url = url;
}
}
@@ -157,10 +159,16 @@ impl Config {
/// Merge another config into this one (other overrides self)
fn merge(&mut self, other: Config) {
// Merge providers
if let Some(other_openai) = other.providers.openai {
if let Some(ref mut self_openai) = self.providers.openai {
// Merge OpenAI configs
// Merge OpenAI providers (extend list)
for other_openai in other.providers.openai {
// Check if we should merge with existing or add new
let existing = self.providers.openai.iter_mut().find(|p| {
p.name == other_openai.name ||
(p.name.is_none() && other_openai.name.is_none())
});
if let Some(self_openai) = existing {
// Merge with existing provider
if other_openai.api_key.is_some() {
self_openai.api_key = other_openai.api_key;
}
@@ -171,13 +179,20 @@ impl Config {
self_openai.default_model = other_openai.default_model;
}
} else {
self.providers.openai = Some(other_openai);
// Add as new provider
self.providers.openai.push(other_openai);
}
}
if let Some(other_ollama) = other.providers.ollama {
if let Some(ref mut self_ollama) = self.providers.ollama {
// Merge Ollama configs
// Merge Ollama providers (extend list)
for other_ollama in other.providers.ollama {
let existing = self.providers.ollama.iter_mut().find(|p| {
p.name == other_ollama.name ||
(p.name.is_none() && other_ollama.name.is_none())
});
if let Some(self_ollama) = existing {
// Merge with existing provider
if other_ollama.base_url != default_ollama_base_url() {
self_ollama.base_url = other_ollama.base_url;
}
@@ -194,7 +209,8 @@ impl Config {
self_ollama.password = other_ollama.password;
}
} else {
self.providers.ollama = Some(other_ollama);
// Add as new provider
self.providers.ollama.push(other_ollama);
}
}
@@ -249,13 +265,17 @@ fn default_agent_config() -> AgentConfig {
pub fn create_default_config() -> Result<Config> {
let mut config = Config::default();
config.providers.openai = Some(OpenAiConfig {
api_key: None, // User must set this
// Add default OpenAI provider
config.providers.openai.push(OpenAiConfig {
name: Some("default".to_string()),
api_key: None, // User must set this or use env var
base_url: default_openai_base_url(),
default_model: default_openai_model(),
});
config.providers.ollama = Some(OllamaConfig {
// Add default Ollama provider
config.providers.ollama.push(OllamaConfig {
name: Some("default".to_string()),
base_url: default_ollama_base_url(),
default_model: default_ollama_model(),
bearer_token: None,

22
src/config/types.rs
View File

@@ -28,18 +28,22 @@ fn default_agent() -> String {
/// Provider configurations
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct ProvidersConfig {
/// OpenAI provider config
/// OpenAI provider instances (can have multiple)
#[serde(default)]
pub openai: Option<OpenAiConfig>,
pub openai: Vec<OpenAiConfig>,
/// Ollama provider config
/// Ollama provider instances (can have multiple)
#[serde(default)]
pub ollama: Option<OllamaConfig>,
pub ollama: Vec<OllamaConfig>,
}
/// OpenAI configuration
/// Named OpenAI configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OpenAiConfig {
/// Name for this provider instance (optional, for reference)
#[serde(default)]
pub name: Option<String>,
/// API key (can also be set via OPENAI_API_KEY env var)
pub api_key: Option<String>,
@@ -63,6 +67,7 @@ pub fn default_openai_model() -> String {
impl Default for OpenAiConfig {
fn default() -> Self {
Self {
name: None,
api_key: None,
base_url: default_openai_base_url(),
default_model: default_openai_model(),
@@ -70,9 +75,13 @@ impl Default for OpenAiConfig {
}
}
/// Ollama configuration
/// Named Ollama configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OllamaConfig {
/// Name for this provider instance (optional, for reference)
#[serde(default)]
pub name: Option<String>,
/// Base URL
#[serde(default = "default_ollama_base_url")]
pub base_url: String,
@@ -105,6 +114,7 @@ pub fn default_ollama_model() -> String {
impl Default for OllamaConfig {
fn default() -> Self {
Self {
name: None,
base_url: default_ollama_base_url(),
default_model: default_ollama_model(),
bearer_token: None,

71
src/providers/registry.rs
View File

@@ -16,27 +16,50 @@ impl ProviderRegistry {
}
/// Create a registry from configuration
/// Does not require API key if at least one provider is configured
pub fn from_config(config: &Config) -> Result<Self> {
let mut registry = Self::new();
let mut has_any_provider = false;
// Register OpenAI provider if configured
if let Some(ref openai_config) = config.providers.openai {
// Register all OpenAI provider instances
for (i, openai_config) in config.providers.openai.iter().enumerate() {
let name = openai_config
.name
.clone()
.unwrap_or_else(|| format!("openai-{}", i + 1));
let registry_name = if i == 0 { "openai".to_string() } else { name.clone() };
// Get API key from config or environment
let api_key = openai_config
.api_key
.clone()
.ok_or_else(|| ProviderError::AuthError("OpenAI API key not configured".to_string()))?;
.or_else(|| std::env::var("OPENAI_API_KEY").ok());
let provider = OpenAiProvider::new(
&openai_config.base_url,
&api_key,
&openai_config.default_model,
);
registry.register("openai", Arc::new(provider));
if let Some(key) = api_key {
let provider = OpenAiProvider::new(
&openai_config.base_url,
&key,
&openai_config.default_model,
);
registry.register(&registry_name, Arc::new(provider));
has_any_provider = true;
} else if config.providers.ollama.is_empty() {
// Only error if no other providers are available
return Err(ProviderError::AuthError(
"OpenAI API key not configured. Set api_key in config or OPENAI_API_KEY env var, or configure Ollama provider.".to_string()
));
}
// If no API key but Ollama is available, just skip this OpenAI instance
}
// Register Ollama provider if configured
if let Some(ref ollama_config) = config.providers.ollama {
// Register all Ollama provider instances
for (i, ollama_config) in config.providers.ollama.iter().enumerate() {
let name = ollama_config
.name
.clone()
.unwrap_or_else(|| format!("ollama-{}", i + 1));
let registry_name = if i == 0 { "ollama".to_string() } else { name.clone() };
let mut provider = OllamaProvider::new(
&ollama_config.base_url,
&ollama_config.default_model,
@@ -45,12 +68,19 @@ impl ProviderRegistry {
// Apply authentication
if let Some(ref token) = ollama_config.bearer_token {
provider = provider.with_bearer_token(token);
} else if let (Some(ref username), Some(ref password)) =
} else if let (Some(ref username), Some(ref password)) =
(&ollama_config.username, &ollama_config.password) {
provider = provider.with_basic_auth(username, password);
}
registry.register("ollama", Arc::new(provider));
registry.register(&registry_name, Arc::new(provider));
has_any_provider = true;
}
if !has_any_provider && config.providers.openai.is_empty() && config.providers.ollama.is_empty() {
return Err(ProviderError::AuthError(
"No providers configured. Add at least one OpenAI or Ollama provider.".to_string()
));
}
Ok(registry)
@@ -80,11 +110,11 @@ impl ProviderRegistry {
Ok((provider, model_name.to_string()))
} else {
// Try to find a provider that has this model as default
// For now, default to openai if available
if let Some(provider) = self.get("openai") {
// Prefer Ollama for local-first
if let Some(provider) = self.get("ollama") {
return Ok((provider, model_spec.to_string()));
}
if let Some(provider) = self.get("ollama") {
if let Some(provider) = self.get("openai") {
return Ok((provider, model_spec.to_string()));
}
Err(ProviderError::UnknownProvider(
@@ -109,6 +139,11 @@ impl ProviderRegistry {
results
}
/// Check if any provider is available
pub fn has_providers(&self) -> bool {
!self.providers.is_empty()
}
}
impl Default for ProviderRegistry {
@@ -124,7 +159,7 @@ mod tests {
#[test]
fn test_resolve_provider_format() {
let registry = ProviderRegistry::new();
// Test parsing format
assert_eq!(
"openai/gpt-4".split_once('/'),