Skip to content

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.rs
new file mode 100644
index 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.rs
index 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;