An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.
Rust
fix: wire persisted provider configuration into runtime
DaBear98750ff6004665d
diff --git a/rust/crates/api/src/client.rs b/rust/crates/api/src/client.rsindex 538c7fbd..6e5e7889 100644--- a/rust/crates/api/src/client.rs+++ b/rust/crates/api/src/client.rs@@ -13,7 +13,130 @@ pub enum ProviderClient {OpenAi(OpenAiCompatClient),}+/// Provider selected explicitly by persisted/runtime configuration.+///+/// This is intentionally separate from `ProviderKind`: DashScope speaks the+/// OpenAI-compatible wire protocol but remains a distinct configured provider.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum ProviderConfigKind {+ Anthropic,+ Xai,+ OpenAi,+ DashScope,+}++/// Explicit provider configuration supplied by the runtime layer.+///+/// This keeps the API crate independent of runtime configuration types.+/// Credentials are redacted from Debug output.+#[derive(Clone)]+pub struct ProviderConfig {+ pub kind: ProviderConfigKind,+ pub model: String,+ pub api_key: Option<String>,+ pub base_url: Option<String>,+}++impl std::fmt::Debug for ProviderConfig {+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ f.debug_struct("ProviderConfig")+ .field("kind", &self.kind)+ .field("model", &self.model)+ .field("api_key", &self.api_key.as_ref().map(|_| "<redacted>"))+ .field("base_url", &self.base_url)+ .finish()+ }+}++fn read_env_non_empty(key: &str) -> Option<String> {+ std::env::var(key)+ .ok()+ .filter(|value| !value.trim().is_empty())+}+impl ProviderClient {+ /// Construct a client from an explicit provider configuration.+ ///+ /// The persisted provider kind is authoritative for provider selection,+ /// while environment credentials and base URLs retain precedence over+ /// persisted values.+ pub fn from_config(config: &ProviderConfig) -> Result<Self, ApiError> {+ match config.kind {+ ProviderConfigKind::Anthropic => {+ let api_key = read_env_non_empty("ANTHROPIC_API_KEY")+ .or_else(|| config.api_key.clone())+ .ok_or_else(|| {+ ApiError::missing_credentials(+ "Anthropic",+ &["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"],+ )+ })?;++ let mut client = AnthropicClient::new(api_key);+ let base_url = read_env_non_empty("ANTHROPIC_BASE_URL")+ .or_else(|| config.base_url.clone())+ .unwrap_or_else(anthropic::read_base_url);+ client = client.with_base_url(base_url);+ Ok(Self::Anthropic(client))+ }+ ProviderConfigKind::Xai => {+ let compat = OpenAiCompatConfig::xai();+ let api_key =+ read_env_non_empty(compat.api_key_env).or_else(|| config.api_key.clone());++ let mut client = match api_key {+ Some(api_key) => OpenAiCompatClient::new(api_key, compat),+ None => OpenAiCompatClient::from_env(compat)?,+ };++ let base_url = read_env_non_empty(compat.base_url_env)+ .or_else(|| config.base_url.clone())+ .unwrap_or_else(|| compat.default_base_url.to_string());+ client = client.with_base_url(base_url);++ Ok(Self::Xai(client))+ }+ ProviderConfigKind::OpenAi | ProviderConfigKind::DashScope => {+ let compat = match config.kind {+ ProviderConfigKind::OpenAi => OpenAiCompatConfig::openai(),+ ProviderConfigKind::DashScope => OpenAiCompatConfig::dashscope(),+ _ => unreachable!("non-OpenAI provider reached compatibility path"),+ };++ if config.kind == ProviderConfigKind::OpenAi+ && read_env_non_empty("OLLAMA_HOST").is_some()+ && config.api_key.is_none()+ && config.base_url.is_none()+ {+ return Ok(Self::OpenAi(+ openai_compat::OpenAiCompatClient::from_ollama_env()+ .expect("from_ollama_env always returns Some"),+ ));+ }++ let api_key =+ read_env_non_empty(compat.api_key_env).or_else(|| config.api_key.clone());+ let persisted_base_url = config.base_url.clone();+ let mut client = match api_key {+ Some(api_key) => OpenAiCompatClient::new(api_key, compat),+ None if config.kind == ProviderConfigKind::OpenAi+ && persisted_base_url+ .as_deref()+ .is_some_and(openai_compat::is_local_openai_compatible_base_url) =>+ {+ OpenAiCompatClient::new("local-dev-token", compat)+ }+ None => OpenAiCompatClient::from_env(compat)?,+ };+ let base_url = read_env_non_empty(compat.base_url_env)+ .or(persisted_base_url)+ .unwrap_or_else(|| compat.default_base_url.to_string());+ client = client.with_base_url(base_url);++ Ok(Self::OpenAi(client))+ }+ }+ }pub fn from_model(model: &str) -> Result<Self, ApiError> {Self::from_model_with_anthropic_auth(model, None)}@@ -34,7 +157,7 @@ impl ProviderClient {ProviderKind::OpenAi => {// OLLAMA_HOST takes priority: local Ollama needs no API key// and ignores DashScope/OpenAI env-based dispatch.- if std::env::var_os("OLLAMA_HOST").is_some() {+ if read_env_non_empty("OLLAMA_HOST").is_some() {Ok(Self::OpenAi(openai_compat::OpenAiCompatClient::from_ollama_env().expect("from_ollama_env always returns Some"),@@ -155,7 +278,7 @@ pub fn read_xai_base_url() -> String {mod tests {use std::sync::{Mutex, OnceLock};- use super::ProviderClient;+ use super::{ProviderClient, ProviderConfig, ProviderConfigKind};use crate::providers::{detect_provider_kind, resolve_model_alias, ProviderKind};/// Serializes every test in this module that mutates process-wide@@ -213,6 +336,73 @@ mod tests {}}+ #[test]+ fn persisted_provider_kind_overrides_model_provider_detection() {+ let _lock = env_lock();+ let _anthropic = EnvVarGuard::set("ANTHROPIC_API_KEY", Some("test-anthropic-key"));+ let _xai = EnvVarGuard::set("XAI_API_KEY", Some("test-xai-key"));++ let config = ProviderConfig {+ kind: ProviderConfigKind::Xai,+ model: "claude-sonnet-4-6".to_string(),+ api_key: None,+ base_url: None,+ };++ match ProviderClient::from_config(&config).expect("explicit xAI config should succeed") {+ ProviderClient::Xai(client) => {+ assert!(client.base_url().contains("api.x.ai"));+ }+ other => panic!("Expected explicit xAI provider, got: {other:?}"),+ }+ }++ #[test]+ fn persisted_dashscope_kind_overrides_qwen_model_routing() {+ let _lock = env_lock();+ let _dashscope = EnvVarGuard::set("DASHSCOPE_API_KEY", Some("test-dashscope-key"));+ let _openai = EnvVarGuard::set("OPENAI_API_KEY", Some("test-openai-key"));++ let config = ProviderConfig {+ kind: ProviderConfigKind::DashScope,+ model: "gpt-5".to_string(),+ api_key: None,+ base_url: None,+ };++ match ProviderClient::from_config(&config)+ .expect("explicit DashScope config should succeed")+ {+ ProviderClient::OpenAi(client) => {+ assert!(client.base_url().contains("dashscope.aliyuncs.com"));+ }+ other => panic!("Expected explicit DashScope provider, got: {other:?}"),+ }+ }++ #[test]+ fn persisted_openai_kind_does_not_become_dashscope_from_model() {+ let _lock = env_lock();+ let _openai = EnvVarGuard::set("OPENAI_API_KEY", Some("test-openai-key"));+ let _dashscope = EnvVarGuard::set("DASHSCOPE_API_KEY", Some("test-dashscope-key"));+ let _openai_base_url = EnvVarGuard::set("OPENAI_BASE_URL", None);++ let config = ProviderConfig {+ kind: ProviderConfigKind::OpenAi,+ model: "qwen-plus".to_string(),+ api_key: None,+ base_url: None,+ };++ match ProviderClient::from_config(&config).expect("explicit OpenAI config should succeed") {+ ProviderClient::OpenAi(client) => {+ assert!(client.base_url().contains("api.openai.com"));+ assert!(!client.base_url().contains("dashscope.aliyuncs.com"));+ }+ other => panic!("Expected explicit OpenAI provider, got: {other:?}"),+ }+ }+#[test]fn dashscope_model_uses_dashscope_config_not_openai() {// Regression: qwen-plus was being routed to OpenAiCompatConfig::openai()diff --git a/rust/crates/api/src/lib.rs b/rust/crates/api/src/lib.rsindex 9fdfbce9..e03d78ee 100644--- a/rust/crates/api/src/lib.rs+++ b/rust/crates/api/src/lib.rs@@ -1,4 +1,5 @@mod client;+mod error;mod http_client;mod prompt_cache;@@ -8,7 +9,8 @@ mod types;pub use client::{oauth_token_is_expired, read_base_url, read_xai_base_url, resolve_saved_oauth_token,- resolve_startup_auth_source, MessageStream, OAuthTokenSet, ProviderClient,+ resolve_startup_auth_source, MessageStream, OAuthTokenSet, ProviderClient, ProviderConfig,+ ProviderConfigKind,};pub use error::ApiError;pub use http_client::{diff --git a/rust/crates/runtime/src/config.rs b/rust/crates/runtime/src/config.rsindex 3fefec81..fe95bf2b 100644--- a/rust/crates/runtime/src/config.rs+++ b/rust/crates/runtime/src/config.rs@@ -205,6 +205,11 @@ pub struct RuntimeProviderConfig {}impl RuntimeProviderConfig {+ #[must_use]+ pub fn is_configured(&self) -> bool {+ self.kind.is_some()+ }+#[must_use]pub fn kind(&self) -> Option<&str> {self.kind.as_deref()@@ -2658,6 +2663,42 @@ mod tests {std::env::temp_dir().join(format!("runtime-config-{pid}-{nanos}-{seq}"))}+ #[test]+ fn loads_persisted_provider_configuration_from_settings() {+ let root = temp_dir();+ let cwd = root.join("project");+ let home = root.join("home").join(".claw");+ fs::create_dir_all(&home).expect("home config dir");+ fs::create_dir_all(&cwd).expect("project dir");++ fs::write(+ home.join("settings.json"),+ r#"{+ "provider": {+ "kind": "dashscope",+ "apiKey": "persisted-test-key",+ "baseUrl": "https://dashscope.example/v1",+ "model": "qwen-plus"+ }+ }"#,+ )+ .expect("write settings");++ let loaded = ConfigLoader::new(&cwd, &home)+ .load()+ .expect("provider configuration should load");++ let provider = loaded.provider();++ assert_eq!(provider.kind(), Some("dashscope"));+ assert_eq!(provider.api_key(), Some("persisted-test-key"));+ assert_eq!(provider.base_url(), Some("https://dashscope.example/v1"));+ assert_eq!(provider.model(), Some("qwen-plus"));+ assert!(provider.is_configured());++ fs::remove_dir_all(root).expect("cleanup temp dir");+ }+#[test]fn rejects_non_object_settings_files() {let root = temp_dir();diff --git a/rust/crates/rusty-claude-cli/src/main.rs b/rust/crates/rusty-claude-cli/src/main.rsindex 6eac45b7..b5b47ff3 100644--- a/rust/crates/rusty-claude-cli/src/main.rs+++ b/rust/crates/rusty-claude-cli/src/main.rs@@ -12584,6 +12584,7 @@ fn build_runtime_with_plugin_state(plugin_registry.initialize()?;let policy = permission_policy(permission_mode, &feature_config, &tool_registry).map_err(std::io::Error::other)?;+ let provider_config = provider_config_from_runtime(feature_config.provider())?;let mut runtime = ConversationRuntime::new_with_features(session,AnthropicRuntimeClient::new(@@ -12595,6 +12596,7 @@ fn build_runtime_with_plugin_state(allowed_tools.clone(),tool_registry.clone(),progress_reporter,+ provider_config,)?,CliToolExecutor::new(allowed_tools.clone(),@@ -12767,10 +12769,85 @@ impl<W: Write> Write for TailTrackingWriter<'_, W> {// NOTE: Despite the historical name `AnthropicRuntimeClient`, this struct// now holds an `ApiProviderClient` which dispatches to Anthropic, xAI,-// OpenAI, or DashScope at construction time based on-// `detect_provider_kind(&model)`. The struct name is kept to avoid-// churning `BuiltRuntime` and every Deref/DerefMut site that references-// it. See ROADMAP #29 for the provider-dispatch routing fix.+// OpenAI, or DashScope at construction time. Explicit persisted provider+// configuration takes precedence; model-based provider detection remains+// the fallback when no provider configuration is present. The struct name+// is kept to avoid churning `BuiltRuntime` and every Deref/DerefMut site+// that references it.++fn provider_config_from_runtime(+ provider: &runtime::RuntimeProviderConfig,+) -> Result<Option<api::ProviderConfig>, Box<dyn std::error::Error>> {+ let Some(kind) = provider.kind() else {+ return Ok(None);+ };++ let kind = match kind.trim().to_ascii_lowercase().as_str() {+ "anthropic" => api::ProviderConfigKind::Anthropic,+ "xai" => api::ProviderConfigKind::Xai,+ "openai" => api::ProviderConfigKind::OpenAi,+ "dashscope" => api::ProviderConfigKind::DashScope,+ other => {+ return Err(format!(+ "invalid provider configuration: unsupported provider kind `{other}`"+ )+ .into());+ }+ };++ Ok(Some(api::ProviderConfig {+ kind,+ model: provider.model().unwrap_or_default().to_string(),+ api_key: provider.api_key().map(str::to_string),+ base_url: provider.base_url().map(str::to_string),+ }))+}++fn explicit_provider_kind_for_model(+ model: &str,+ persisted_model: &str,+) -> Option<api::ProviderConfigKind> {+ let resolved_model = api::resolve_model_alias(model);+ let persisted_resolved = api::resolve_model_alias(persisted_model);++ if resolved_model.eq_ignore_ascii_case(&persisted_resolved) {+ return None;+ }++ let namespace = model+ .trim()+ .split_once('/')+ .map(|(namespace, _)| namespace.to_ascii_lowercase());++ match namespace.as_deref() {+ Some("anthropic") => Some(api::ProviderConfigKind::Anthropic),+ Some("xai") => Some(api::ProviderConfigKind::Xai),+ Some("openai") | Some("local") => Some(api::ProviderConfigKind::OpenAi),+ Some("dashscope") | Some("qwen") | Some("kimi") => Some(api::ProviderConfigKind::DashScope),+ _ => {+ let lower = resolved_model.to_ascii_lowercase();+ if lower.starts_with("qwen/")+ || lower.starts_with("qwen-")+ || lower.starts_with("kimi/")+ || lower.starts_with("kimi-")+ {+ Some(api::ProviderConfigKind::DashScope)+ } else if lower.starts_with("grok/") || lower.starts_with("grok-") {+ Some(api::ProviderConfigKind::Xai)+ } else if lower.starts_with("claude") || lower.starts_with("anthropic/") {+ Some(api::ProviderConfigKind::Anthropic)+ } else if lower.starts_with("openai/")+ || lower.starts_with("gpt-")+ || lower.starts_with("local/")+ {+ Some(api::ProviderConfigKind::OpenAi)+ } else {+ None+ }+ }+ }+}+struct AnthropicRuntimeClient {runtime: tokio::runtime::Runtime,client: ApiProviderClient,@@ -12795,47 +12872,65 @@ impl AnthropicRuntimeClient {allowed_tools: Option<AllowedToolSet>,tool_registry: GlobalToolRegistry,progress_reporter: Option<InternalPromptProgressReporter>,+ provider_config: Option<api::ProviderConfig>,) -> Result<Self, Box<dyn std::error::Error>> {- // Dispatch to the correct provider at construction time.- // `ApiProviderClient` (exposed by the api crate as- // `ProviderClient`) is an enum over Anthropic / xAI / OpenAI- // variants, where xAI and OpenAI both use the OpenAI-compat- // wire format under the hood. We consult- // `detect_provider_kind(&resolved_model)` so model-name prefix- // routing (`openai/`, `gpt-`, `grok`, `qwen/`) wins over- // env-var presence.- //- // For Anthropic we build the client directly instead of going- // through `ApiProviderClient::from_model_with_anthropic_auth`- // so we can explicitly apply `api::read_base_url()` — that- // reads `ANTHROPIC_BASE_URL` and is required for the local- // mock-server test harness- // (`crates/rusty-claude-cli/tests/compact_output.rs`) to point- // claw at its fake Anthropic endpoint. We also attach a- // session-scoped prompt cache on the Anthropic path; the- // prompt cache is Anthropic-only so non-Anthropic variants- // skip it.+ // Explicit persisted provider configuration takes precedence.+ // When absent, preserve the existing model-based provider detection.let resolved_model = api::resolve_model_alias(&model);- let client = match detect_provider_kind(&resolved_model) {- ProviderKind::Anthropic => {- let auth = resolve_cli_auth_source()?;- let inner = AnthropicClient::from_auth(auth)- .with_base_url(api::read_base_url())- .with_prompt_cache(PromptCache::new(session_id));- ApiProviderClient::Anthropic(inner)- }- ProviderKind::Xai | ProviderKind::OpenAi => {- // The api crate's `ProviderClient::from_model_with_anthropic_auth`- // with `None` for the anthropic auth routes via- // `detect_provider_kind` and builds an- // `OpenAiCompatClient::from_env` with the matching- // `OpenAiCompatConfig` (openai / xai / dashscope).- // That reads the correct API-key env var and BASE_URL- // override internally, so this one call covers OpenAI,- // OpenRouter, xAI, DashScope, Ollama, and any other- // OpenAI-compat endpoint users configure via- // `OPENAI_BASE_URL` / `XAI_BASE_URL` / `DASHSCOPE_BASE_URL`.- ApiProviderClient::from_model_with_anthropic_auth(&resolved_model, None)?+ let provider_config = provider_config.map(|config| {+ if let Some(kind) = explicit_provider_kind_for_model(&model, config.model.as_str()) {+ api::ProviderConfig {+ kind,+ model: resolved_model.clone(),+ ..config+ }+ } else {+ config+ }+ });+ let client = if let Some(config) = provider_config {+ match config.kind {+ api::ProviderConfigKind::Anthropic => {+ let auth = match resolve_cli_auth_source() {+ Ok(auth) => auth,+ Err(_) => {+ config+ .api_key+ .clone()+ .map(AuthSource::ApiKey)+ .ok_or_else(|| {+ api::ApiError::missing_credentials(+ "Anthropic",+ &["ANTHROPIC_API_KEY", "ANTHROPIC_AUTH_TOKEN"],+ )+ })?+ }+ };+ let mut inner = AnthropicClient::from_auth(auth);+ let base_url = std::env::var("ANTHROPIC_BASE_URL")+ .ok()+ .filter(|value| !value.trim().is_empty())+ .or_else(|| config.base_url.clone())+ .unwrap_or_else(api::read_base_url);+ inner = inner.with_base_url(base_url);+ ApiProviderClient::Anthropic(+ inner.with_prompt_cache(PromptCache::new(session_id)),+ )+ }+ _ => ApiProviderClient::from_config(&config)?,+ }+ } else {+ match detect_provider_kind(&resolved_model) {+ ProviderKind::Anthropic => {+ let auth = resolve_cli_auth_source()?;+ let inner = AnthropicClient::from_auth(auth)+ .with_base_url(api::read_base_url())+ .with_prompt_cache(PromptCache::new(session_id));+ ApiProviderClient::Anthropic(inner)+ }+ ProviderKind::Xai | ProviderKind::OpenAi => {+ ApiProviderClient::from_model_with_anthropic_auth(&resolved_model, None)?+ }}};Ok(Self {@@ -19432,6 +19527,117 @@ UU conflicted.rs",let _ = fs::remove_dir_all(source_root);}+ #[test]+ fn explicit_model_provider_hint_overrides_persisted_provider_kind() {+ let config = api::ProviderConfig {+ kind: api::ProviderConfigKind::DashScope,+ model: "qwen-plus".to_string(),+ api_key: Some("persisted-test-key".to_string()),+ base_url: None,+ };++ assert_eq!(+ super::explicit_provider_kind_for_model("openai/gpt-5", &config.model),+ Some(api::ProviderConfigKind::OpenAi)+ );+ assert_eq!(+ super::explicit_provider_kind_for_model("qwen-plus", &config.model),+ None,+ "matching persisted model must keep the persisted provider kind"+ );+ }++ #[test]+ fn explicit_model_provider_hint_controls_runtime_provider_dispatch() {+ let config = api::ProviderConfig {+ kind: api::ProviderConfigKind::DashScope,+ model: "qwen-plus".to_string(),+ api_key: Some("persisted-test-key".to_string()),+ base_url: None,+ };++ let runtime = super::AnthropicRuntimeClient::new(+ "provider-resolution-explicit-model-test",+ "openai/gpt-5".to_string(),+ false,+ false,+ None,+ GlobalToolRegistry::builtin(),+ None,+ Some(config),+ )+ .expect("runtime client should construct from explicit model provider hint");++ match runtime.client {+ api::ProviderClient::OpenAi(client) => {+ assert!(client.base_url().contains("api.openai.com"));+ assert!(!client.base_url().contains("dashscope.aliyuncs.com"));+ }+ other => panic!(+ "explicit OpenAI model prefix must override persisted DashScope configuration, got {other:?}"+ ),+ }+ }++ #[test]+ fn persisted_provider_configuration_controls_runtime_provider_dispatch() {+ let config_home = temp_dir();+ let workspace = temp_dir();+ fs::create_dir_all(&config_home).expect("config home");+ fs::create_dir_all(&workspace).expect("workspace");++ fs::write(+ config_home.join("settings.json"),+ r#"{+ "provider": {+ "kind": "dashscope",+ "apiKey": "persisted-test-key",+ "baseUrl": "https://dashscope.example/v1",+ "model": "qwen-plus"+ },+ "model": "qwen-plus"+ }"#,+ )+ .expect("write provider settings");++ let loader = ConfigLoader::new(&workspace, &config_home);+ let runtime_config = loader.load().expect("runtime config should load");+ let state = build_runtime_plugin_state_with_loader(&workspace, &loader, &runtime_config)+ .expect("runtime plugin state should load");++ let provider_config = super::provider_config_from_runtime(state.feature_config.provider())+ .expect("provider configuration should adapt")+ .expect("persisted provider configuration should be present");++ assert_eq!(+ provider_config.kind,+ api::ProviderConfigKind::DashScope,+ "persisted provider kind must survive the runtime configuration boundary"+ );++ let runtime = super::AnthropicRuntimeClient::new(+ "provider-resolution-test",+ "qwen-plus".to_string(),+ false,+ false,+ None,+ GlobalToolRegistry::builtin(),+ None,+ Some(provider_config),+ )+ .expect("runtime client should construct from persisted provider configuration");++ match runtime.client {+ api::ProviderClient::OpenAi(_) => {}+ other => panic!(+ "persisted DashScope configuration must dispatch to the OpenAI-compatible client, got {other:?}"+ ),+ }++ let _ = fs::remove_dir_all(config_home);+ let _ = fs::remove_dir_all(workspace);+ }+#[test]#[allow(clippy::too_many_lines)]fn build_runtime_plugin_state_discovers_mcp_tools_and_surfaces_pending_servers() {