A self-improving RLM agent for coding workflows and long-running autonomous tasks.
Rust
honor configured print-mode model defaults (#3532)
ktf21686798062
diff --git a/crates/pa-cli/src/print_model_tests.rs b/crates/pa-cli/src/print_model_tests.rsnew file mode 100644index 0000000000..21788188c1--- /dev/null+++ b/crates/pa-cli/src/print_model_tests.rs@@ -0,0 +1,230 @@+use super::select_model;+use crate::mode::RuntimeConfig;+use pa_core::auth::{AuthStorage, AuthStorageData, NoOAuth};+use pa_core::models::ModelRegistry;+use pa_core::session::SessionContext;+use pa_types::ai::{UserContent, UserMessage};+use pa_types::session::AgentMessage;+use serde_json::json;+use std::sync::Arc;++fn fixture(settings: &serde_json::Value) -> (tempfile::TempDir, RuntimeConfig, ModelRegistry) {+ let dir = tempfile::tempdir().unwrap();+ let config = RuntimeConfig {+ cwd: dir.path().join("project"),+ agent_dir: dir.path().join("agent"),+ ..Default::default()+ };+ std::fs::create_dir_all(&config.cwd).unwrap();+ std::fs::create_dir_all(&config.agent_dir).unwrap();+ std::fs::write(config.agent_dir.join("settings.json"), settings.to_string()).unwrap();+ let path = config.agent_dir.join("models.json");+ std::fs::write(&path, json!({"providers": {+ "my-gateway": {"baseUrl": "http://127.0.0.1:9/v1", "apiKey": "synthetic-only",+ "api": "openai-completions", "compat": {"thinkingFormat":"zai", "zaiToolStream":true}, "models": [{"id": "my-group/my-model"}, {"id": "other"}]},+ "other-gateway": {"baseUrl": "http://127.0.0.1:9/v1", "apiKey": "synthetic-only",+ "api": "openai-completions", "models": [{"id": "other"}]}+ }}).to_string()).unwrap();+ let auth = AuthStorage::in_memory_without_env(&AuthStorageData::default(), Arc::new(NoOAuth));+ let registry = ModelRegistry::create(auth, path);+ (dir, config, registry)+}++#[tokio::test]+async fn print_model_uses_saved_gateway_and_full_model_metadata() {+ for id in ["my-group/my-model", "my-gateway/my-group/my-model"] {+ let (_dir, config, mut registry) = fixture(&json!({+ "defaultProvider":"my-gateway", "defaultModel":id+ }));+ let expected = registry+ .get_all()+ .iter()+ .find(|m| m.provider == "my-gateway" && m.id == "my-group/my-model")+ .unwrap()+ .clone();+ assert_eq!(+ select_model(&mut registry, &config, None).await.unwrap(),+ expected+ );+ }+}++#[tokio::test]+async fn print_model_explicit_and_partial_flags_override_defaults() {+ for (provider, model, expected) in [+ (+ Some("other-gateway"),+ Some("other"),+ ("other-gateway", "other"),+ ),+ (+ None,+ Some("other-gateway/other"),+ ("other-gateway", "other"),+ ),+ (+ Some("my-gateway"),+ None,+ ("my-gateway", "my-group/my-model"),+ ),+ (Some("other-gateway"), None, ("other-gateway", "other")),+ ] {+ let (_dir, mut config, mut registry) =+ fixture(&json!({"defaultProvider":"my-gateway", "defaultModel":"my-group/my-model"}));+ config.provider = provider.map(str::to_string);+ config.model = model.map(str::to_string);+ let selected = select_model(&mut registry, &config, None).await.unwrap();+ assert_eq!((selected.provider.as_str(), selected.id.as_str()), expected);+ }+}++#[tokio::test]+async fn print_model_invalid_saved_or_explicit_selection_fails_locally() {+ for settings in [+ json!({"defaultProvider":"missing", "defaultModel":"missing"}),+ json!({"defaultProvider":"my-gateway", "defaultModel":"missing"}),+ ] {+ let (_dir, config, mut registry) = fixture(&settings);+ assert!(select_model(&mut registry, &config, None).await.is_err());+ }+ let (_dir, mut config, mut registry) = fixture(&json!({}));+ config.provider = Some("missing".into());+ assert!(select_model(&mut registry, &config, None).await.is_err());+}++#[tokio::test]+async fn print_model_without_configured_auth_does_not_select_a_bundled_fixture() {+ let dir = tempfile::tempdir().unwrap();+ let auth = AuthStorage::in_memory_without_env(&AuthStorageData::default(), Arc::new(NoOAuth));+ let mut registry = ModelRegistry::create(auth, dir.path().join("models.json"));+ let config = RuntimeConfig {+ cwd: dir.path().into(),+ agent_dir: dir.path().into(),+ ..Default::default()+ };+ assert!(select_model(&mut registry, &config, None).await.is_err());+}++#[tokio::test]+async fn print_model_only_flag_preserves_catalog_resolution_without_saved_provider() {+ let (_dir, mut config, mut registry) =+ fixture(&json!({"defaultProvider":"my-gateway", "defaultModel":"my-group/my-model"}));+ config.model = Some("other".into());+ let available = registry+ .get_available()+ .into_iter()+ .cloned()+ .collect::<Vec<_>>();+ let expected = pa_core::models::resolve_cli_model(None, "other", &available)+ .model+ .unwrap();+ assert_eq!(+ select_model(&mut registry, &config, None).await.unwrap(),+ expected+ );+}++#[tokio::test]+async fn print_model_saved_private_id_cannot_reuse_another_private_route() {+ let (_dir, config, _) = fixture(&json!({+ "defaultProvider":"prime-inference", "defaultModel":"internal/not-authorized"+ }));+ let models_path = config.agent_dir.join("models.json");+ std::fs::write(&models_path, json!({"providers": {"prime-inference": {+ "baseUrl":"http://127.0.0.1:9/v1", "api":"openai-completions", "apiKey":"synthetic-only",+ "models":[{"id":"internal/authorized-fixture"}]+ }}}).to_string()).unwrap();+ let auth = AuthStorage::in_memory_without_env(&AuthStorageData::default(), Arc::new(NoOAuth));+ let mut registry = ModelRegistry::create(auth, models_path);+ assert!(registry+ .get_available()+ .iter()+ .any(|m| m.id == "internal/authorized-fixture"));+ assert!(select_model(&mut registry, &config, None).await.is_err());+}++#[tokio::test]+async fn print_model_unauthenticated_default_does_not_switch_to_another_gateway() {+ let (_dir, config, mut registry) = fixture(&json!({}));+ let unauthenticated_model = registry+ .get_all()+ .iter()+ .find(|model| model.provider == "anthropic")+ .unwrap()+ .clone();+ std::fs::write(+ config.agent_dir.join("settings.json"),+ json!({+ "defaultProvider": unauthenticated_model.provider,+ "defaultModel": unauthenticated_model.id,+ })+ .to_string(),+ )+ .unwrap();+ assert!(registry+ .get_available()+ .iter()+ .any(|m| m.provider == "other-gateway"));+ assert!(select_model(&mut registry, &config, None).await.is_err());+}++/// One open session's active context: a message plus, when given, the+/// session's saved model.+fn session_context(model: Option<(&str, &str)>) -> SessionContext {+ SessionContext {+ messages: vec![AgentMessage::User(UserMessage {+ content: UserContent::Text("resume me".into()),+ timestamp: 0,+ rest: pa_types::JsonMap::new(),+ })],+ thinking_level: "off".into(),+ service_tier: None,+ model: model.map(|(provider, id)| (provider.to_string(), id.to_string())),+ }+}++#[tokio::test]+async fn print_model_resumes_the_session_model_over_a_stale_saved_default() {+ let (_dir, config, mut registry) = fixture(&json!({+ "defaultProvider": "my-gateway", "defaultModel": "missing"+ }));+ let context = session_context(Some(("my-gateway", "my-group/my-model")));+ let expected = registry+ .get_all()+ .iter()+ .find(|model| model.provider == "my-gateway" && model.id == "my-group/my-model")+ .cloned()+ .unwrap();+ assert_eq!(+ select_model(&mut registry, &config, Some(&context))+ .await+ .unwrap(),+ expected+ );+}++#[tokio::test]+async fn print_model_explicit_flag_wins_over_the_session_model() {+ let (_dir, mut config, mut registry) = fixture(&json!({+ "defaultProvider": "my-gateway", "defaultModel": "my-group/my-model"+ }));+ config.model = Some("other-gateway/other".into());+ let context = session_context(Some(("my-gateway", "other")));+ let selected = select_model(&mut registry, &config, Some(&context))+ .await+ .unwrap();+ assert_eq!(+ (selected.provider.as_str(), selected.id.as_str()),+ ("other-gateway", "other")+ );+}++#[tokio::test]+async fn print_model_provider_only_settings_default_does_not_scope() {+ let (_dir, config, mut registry) = fixture(&json!({"defaultProvider": "other-gateway"}));+ let selected = select_model(&mut registry, &config, None).await.unwrap();+ assert_eq!(+ (selected.provider.as_str(), selected.id.as_str()),+ ("my-gateway", "my-group/my-model")+ );+}diff --git a/crates/pa-cli/src/print_runtime.rs b/crates/pa-cli/src/print_runtime.rsindex edc95c28e4..55a7a98249 100644--- a/crates/pa-cli/src/print_runtime.rs+++ b/crates/pa-cli/src/print_runtime.rs@@ -582,11 +582,14 @@ pub(crate) async fn build_headless_engine_with(return Err("a scripted child builds through the faux builder".to_string());}},- HeadlessEmbedding::Root { .. } | HeadlessEmbedding::Rpc => select_model(- &mut registry,- config.provider.as_deref(),- config.model.as_deref(),- )?,+ HeadlessEmbedding::Root { .. } | HeadlessEmbedding::Rpc => {+ // The opened session's active context joins the selection (TS+ // `createAgentSession`); `--no-session` selects from no session.+ let session = session_manager+ .as_ref()+ .map(pa_core::session::manager::SessionManager::active_context);+ select_model(&mut registry, config, session.as_ref()).await?+ }};// Resolve request auth once: the stored team / `PRIME_TEAM_ID` reach the wire through these// headers (children resolve against the same catalog the spawn used).@@ -1012,28 +1015,81 @@ async fn session_header_json(Some(serde_json::Value::Object(object).to_string())}-fn select_model(+async fn select_model(registry: &mut pa_core::models::ModelRegistry,- provider: Option<&str>,- model: Option<&str>,+ config: &crate::mode::RuntimeConfig,+ session: Option<&pa_core::session::SessionContext>,) -> Result<Model, String> {- let available: Vec<Model> = registry.get_available().into_iter().cloned().collect();- let Some(model_name) = model else {- let all: Vec<Model> = registry.get_all().to_vec();- if let Some(default) = pa_core::models::find_preferred_default_model(&available) {- return Ok(default.clone());+ // Explicit selectors retain the CLI resolver's provider inference and do+ // not inherit an unrelated saved provider.+ if let Some(model_name) = config.model.as_deref() {+ let available: Vec<Model> = registry.get_available().into_iter().cloned().collect();+ let resolved =+ pa_core::models::resolve_cli_model(config.provider.as_deref(), model_name, &available);+ if let Some(error) = resolved.error {+ return Err(error);}- return all.first().cloned().ok_or_else(|| {- "No models available. Check your installation or add models to models.json.".to_string()- });- };- let resolved = pa_core::models::resolve_cli_model(provider, model_name, &available);- if let Some(error) = resolved.error {- return Err(error);+ return resolved+ .model+ .ok_or_else(|| "No matching model found.".to_string());+ }+ // A resumed session with messages restores its own model before the+ // defaults chain (TS `createAgentSession`), through the daemon restore's+ // bounded catalog-readiness wait; a miss falls through on the record.+ if let Some((provider, model_id)) = session+ .filter(|context| !context.messages.is_empty())+ .and_then(|context| context.model.as_ref())+ {+ if let Some(model) = pa_core::models::find_session_model_with_readiness_wait(+ registry,+ provider,+ model_id,+ pa_core::models::SESSION_MODEL_RESTORE_READINESS_TIMEOUT_MS,+ )+ .await+ {+ return Ok(model);+ }+ eprintln!("Could not restore model {provider}/{model_id}");+ }+ // A missed restore's readiness window may have refreshed the catalog, so+ // the defaults chain resolves against the refreshed view.+ let settings = pa_core::settings::SettingsManager::create(&config.cwd, &config.agent_dir);+ let available: Vec<Model> = registry.get_available().into_iter().cloned().collect();+ let saved_provider = settings.get_default_provider();+ let flag_provider = config.provider.as_deref();+ let saved_model = settings.get_default_model().filter(|_| {+ flag_provider.is_none_or(|provider| {+ saved_provider.is_some_and(|saved| provider.eq_ignore_ascii_case(saved))+ })+ });+ if let Some(saved_model) = saved_model {+ // Saved IDs must exist in the authenticated catalog. Do not synthesize+ // a fallback model, especially an unauthorized private Prime model.+ // The lookup is scoped like TS findInitialModel's saved default: the+ // flag, when given, has already matched the saved provider above.+ let scope = flag_provider.or(saved_provider);+ return available.iter().find(|model| {+ scope.is_none_or(|provider| model.provider.eq_ignore_ascii_case(provider))+ && (model.id.eq_ignore_ascii_case(saved_model)+ || format!("{}/{}", model.provider, model.id).eq_ignore_ascii_case(saved_model))+ }).cloned().ok_or_else(|| format!("Configured default model \"{saved_model}\" is unavailable. Check settings.json, models.json, and provider authentication."));}- resolved- .model- .ok_or_else(|| "No matching model found.".to_string())+ // A settings defaultProvider without a defaultModel does not scope the+ // no-flag choice (TS reads the two keys together); only the flag does.+ let candidates: Vec<Model> = available+ .into_iter()+ .filter(|model| {+ flag_provider.is_none_or(|provider| model.provider.eq_ignore_ascii_case(provider))+ })+ .collect();+ pa_core::models::find_preferred_default_model(&candidates)+ .or_else(|| candidates.first())+ .cloned()+ .ok_or_else(|| match flag_provider {+ Some(provider) => format!("No available models for provider \"{provider}\". Check models.json and provider authentication."),+ None => "No authenticated models available. Configure a provider or select a model explicitly.".to_string(),+ })}/// Resolve the session thinking level: the CLI flag, then the settings@@ -1960,3 +2016,7 @@ mod tests {);}}++#[cfg(test)]+#[path = "print_model_tests.rs"]+mod print_model_tests;