mirror of
https://github.com/l0ng-ai/openidea.git
synced 2026-11-18 16:08:55 +00:00
fix(agents): discover per-model effort settings before the first prompt (#3807)
ACP discovery learned effort settings only for the session's default model, so picking another model before its first prompt lost the effort control. The shared catalog now discovers a selected model's missing settings in a short-lived ACP session (session/set_config_option, no prompt), tells unknown settings apart from verified no-effort models, shows loading, discards stale discoveries during rapid model changes, and keeps per-model failures and cooldowns separate. Idle-task model switches use the same discovery and keep the previous controls when it fails. Discovery errors keep their cause. Closes #3789 Co-authored-by: Mr0Bread <55754540+Mr0Bread@users.noreply.github.com>
This commit is contained in:
@@ -14,20 +14,21 @@ use std::collections::BTreeMap;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
const CONFIG_UPDATE_TIMEOUT: Duration = if cfg!(test) { Duration::from_millis(100) } else { Duration::from_secs(5) };
|
||||
const DISCOVER_TIMEOUT: Duration = if cfg!(test) { Duration::from_secs(3) } else { Duration::from_secs(120) };
|
||||
|
||||
/// Opens `session/new`, reads `configOptions`, and records the `thought_level` choices of the
|
||||
/// session's model: they describe that model only, and other models may offer different ones.
|
||||
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec) -> Result<Discovered, String> {
|
||||
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec, model: Option<&str>) -> Result<Discovered, String> {
|
||||
let prefer_stored = crate::provider::prefer_stored_copilot_auth();
|
||||
match run_once(shared, spec, prefer_stored).await {
|
||||
match run_once(shared, spec, prefer_stored, model).await {
|
||||
Err(err)
|
||||
if !prefer_stored
|
||||
&& crate::provider::is_copilot_provider(&spec.id)
|
||||
&& crate::provider::has_unconfigured_copilot_ambient_token(&spec.env)
|
||||
&& super::auth_required(0, &err) =>
|
||||
{
|
||||
let retry = run_once(shared, spec, true).await;
|
||||
let retry = run_once(shared, spec, true, model).await;
|
||||
if retry.is_ok() {
|
||||
crate::provider::mark_prefer_stored_copilot_auth();
|
||||
}
|
||||
@@ -37,7 +38,12 @@ pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec) -> Result<Dis
|
||||
}
|
||||
}
|
||||
|
||||
async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool) -> Result<Discovered, String> {
|
||||
async fn run_once(
|
||||
shared: &Arc<Shared>,
|
||||
spec: &ProviderSpec,
|
||||
strip_ambient: bool,
|
||||
selected_model: Option<&str>,
|
||||
) -> Result<Discovered, String> {
|
||||
let root = shared.paths.project_root.clone();
|
||||
let launch = spec.clone();
|
||||
let launch = tokio::task::spawn_blocking({
|
||||
@@ -47,28 +53,63 @@ async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
let cwd = dunce::canonicalize(&root).unwrap_or(root);
|
||||
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), commands: Mutex::new(None) });
|
||||
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() });
|
||||
let client = Dialect::wrap(updates.clone());
|
||||
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(|_| {});
|
||||
let peer = (shared.connector)(&launch, &cwd, client.clone(), on_stderr)
|
||||
.map_err(|e| format!("Couldn't start {} (`{}`): {e}", launch.name, launch.command))?;
|
||||
.map_err(|e| format!("Couldn't start {} for model discovery: {e}", launch.name))?;
|
||||
let _stop = crate::catalogs::KillPeer(peer.clone());
|
||||
let conn = Conn::new(peer.clone(), client);
|
||||
let work = async {
|
||||
conn.initialize(&client_info()).await.map_err(|e| e.to_string())?;
|
||||
conn.initialize(&client_info()).await.map_err(discovery_error)?;
|
||||
let cwd_s = cwd.to_string_lossy().into_owned();
|
||||
// No project MCP during discovery: Cursor can spend a long time spawning servers.
|
||||
let new: Value = conn
|
||||
.request("session/new", json!({ "cwd": cwd_s, "mcpServers": [] }), None)
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
.map_err(discovery_error)?;
|
||||
let mut options = config::options_of(&new);
|
||||
config::add_client_options(&launch.id, &mut options);
|
||||
let model = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.clone());
|
||||
let levels = match (model, levels_for_model_from_slice(&options)) {
|
||||
(Some(model), Some(effort)) => BTreeMap::from([(model, effort)]),
|
||||
_ => BTreeMap::new(),
|
||||
};
|
||||
let model_option = options.iter().find(|o| o.category.as_deref() == Some("model"));
|
||||
let mut levels = BTreeMap::new();
|
||||
if new.get("configOptions").is_some_and(Value::is_array)
|
||||
&& let Some(model) = model_option.and_then(|o| o.current.as_ref())
|
||||
{
|
||||
levels.insert(model.clone(), levels_for_model_from_slice(&options));
|
||||
}
|
||||
if let Some(selected) = selected_model
|
||||
&& let Some(option) = model_option.filter(|o| o.values.iter().any(|v| v.value == selected))
|
||||
&& !levels.contains_key(selected)
|
||||
{
|
||||
let session =
|
||||
new.get("sessionId").and_then(Value::as_str).ok_or("The agent did not return a session ID")?;
|
||||
let (method, mut params) = config::set_request(option, selected);
|
||||
params["sessionId"] = json!(session);
|
||||
updates.config.lock().session = Some(session.to_owned());
|
||||
let response: Value = conn.request(method, params, None).await.map_err(discovery_error)?;
|
||||
let settings = if let Some(settings) = selected_settings(&response, selected) {
|
||||
settings
|
||||
} else {
|
||||
tokio::time::timeout(CONFIG_UPDATE_TIMEOUT, async {
|
||||
loop {
|
||||
let notified = updates.changed.notified();
|
||||
if let Some(settings) = updates
|
||||
.config
|
||||
.lock()
|
||||
.options
|
||||
.as_ref()
|
||||
.and_then(|options| selected_settings(options, selected))
|
||||
{
|
||||
return settings;
|
||||
}
|
||||
notified.await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.map_err(|_| "The agent did not report settings for the selected model".to_owned())?
|
||||
};
|
||||
levels.insert(selected.to_owned(), levels_for_model_from_slice(&settings));
|
||||
}
|
||||
let commands = updates
|
||||
.commands
|
||||
.lock()
|
||||
@@ -88,16 +129,38 @@ async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool
|
||||
struct DiscoveryUpdates {
|
||||
provider: String,
|
||||
commands: Mutex<Option<Vec<crate::AgentCommand>>>,
|
||||
config: Mutex<DiscoveryConfig>,
|
||||
changed: tokio::sync::Notify,
|
||||
}
|
||||
|
||||
#[derive(Default)]
|
||||
struct DiscoveryConfig {
|
||||
session: Option<String>,
|
||||
options: Option<Value>,
|
||||
}
|
||||
|
||||
impl ide_jsonrpc::Handler for DiscoveryUpdates {
|
||||
fn on_notification(&self, method: &str, params: Value) {
|
||||
if method == "session/update"
|
||||
&& let Some(update) = params.get("update")
|
||||
&& update["sessionUpdate"] == "available_commands_update"
|
||||
{
|
||||
// Commands are protocol data, not stderr (which may contain credentials).
|
||||
*self.commands.lock() = Some(config::commands_of(update, &self.provider));
|
||||
if method != "session/update" {
|
||||
return;
|
||||
}
|
||||
let Some(update) = params.get("update") else { return };
|
||||
match update["sessionUpdate"].as_str() {
|
||||
Some("available_commands_update") => {
|
||||
// Commands are protocol data, not stderr (which may contain credentials).
|
||||
*self.commands.lock() = Some(config::commands_of(update, &self.provider));
|
||||
}
|
||||
Some("config_option_update") => {
|
||||
let mut config = self.config.lock();
|
||||
if config.session.as_deref() == params.get("sessionId").and_then(Value::as_str)
|
||||
&& config.session.is_some()
|
||||
&& update.get("configOptions").is_some_and(Value::is_array)
|
||||
{
|
||||
config.options = Some(update.clone());
|
||||
self.changed.notify_one();
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -106,8 +169,24 @@ impl ide_jsonrpc::Handler for DiscoveryUpdates {
|
||||
}
|
||||
}
|
||||
|
||||
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<AgentConfigOption>> {
|
||||
let levels: Vec<_> = options
|
||||
fn discovery_error(error: ide_jsonrpc::RpcError) -> String {
|
||||
match error {
|
||||
ide_jsonrpc::RpcError::Server { code, message, .. } if super::auth_required(code, &message) => {
|
||||
"Sign in required: the agent could not authenticate model discovery".into()
|
||||
}
|
||||
other => format!("The agent could not complete model discovery: {other}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn selected_settings(response: &Value, model: &str) -> Option<Vec<AgentConfigOption>> {
|
||||
response.get("configOptions")?.as_array()?;
|
||||
let options = config::options_of(response);
|
||||
let current = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.as_deref());
|
||||
current.is_none_or(|current| current == model).then_some(options)
|
||||
}
|
||||
|
||||
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Vec<AgentConfigOption> {
|
||||
options
|
||||
.iter()
|
||||
.filter(|o| config::is_per_model_option(o))
|
||||
.cloned()
|
||||
@@ -121,6 +200,5 @@ fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<Agen
|
||||
}
|
||||
o
|
||||
})
|
||||
.collect();
|
||||
(!levels.is_empty()).then_some(levels)
|
||||
.collect()
|
||||
}
|
||||
|
||||
@@ -45,9 +45,18 @@ struct Entry {
|
||||
error: Option<String>,
|
||||
flight: Option<watch::Receiver<bool>>,
|
||||
abort: Option<tokio::task::AbortHandle>,
|
||||
flight_model: Option<String>,
|
||||
requested_model: Option<String>,
|
||||
model_failures: HashMap<String, ModelFailure>,
|
||||
catalog: Option<CatalogData>,
|
||||
}
|
||||
|
||||
struct ModelFailure {
|
||||
completed: Instant,
|
||||
retry_at_ms: f64,
|
||||
error: String,
|
||||
}
|
||||
|
||||
#[derive(Clone, Default, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub(crate) struct CatalogData {
|
||||
@@ -204,6 +213,24 @@ impl AgentCatalogs {
|
||||
.unwrap_or_else(|| Self::fallback(shared, provider))
|
||||
}
|
||||
|
||||
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
|
||||
let state = self.state.lock();
|
||||
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
|
||||
{
|
||||
return catalog.thought_levels.get(model).cloned();
|
||||
}
|
||||
drop(state);
|
||||
let cache = shared.known.lock();
|
||||
let known = cache.get(provider)?;
|
||||
known
|
||||
.catalogs
|
||||
.get(&shared.root_key())
|
||||
.map(|saved| &saved.catalog.thought_levels)
|
||||
.unwrap_or(&known.thought_levels)
|
||||
.get(model)
|
||||
.cloned()
|
||||
}
|
||||
|
||||
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
|
||||
let key = Self::key(shared, provider);
|
||||
let mut state = self.state.lock();
|
||||
@@ -214,16 +241,27 @@ impl AgentCatalogs {
|
||||
|
||||
fn snapshot(&self, shared: &Shared, provider: &str, entry: &Entry) -> AgentModelCatalog {
|
||||
let catalog = entry.catalog.clone().unwrap_or_else(|| Self::fallback(shared, provider));
|
||||
let model_failure = entry.requested_model.as_ref().and_then(|model| entry.model_failures.get(model));
|
||||
let unknown_model = entry
|
||||
.requested_model
|
||||
.as_deref()
|
||||
.is_some_and(|model| catalog.lists(model) && !catalog.thought_levels.contains_key(model));
|
||||
AgentModelCatalog {
|
||||
provider: provider.to_owned(),
|
||||
config: shared.config_for_new_task(catalog.config, provider),
|
||||
thought_levels: catalog.thought_levels,
|
||||
refreshing: entry.flight.is_some(),
|
||||
refreshed_at_ms: catalog.refreshed_at_ms,
|
||||
retry_at_ms: entry
|
||||
.retry_at_ms
|
||||
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN)),
|
||||
error: entry.error.clone(),
|
||||
retry_at_ms: model_failure
|
||||
.filter(|failure| self.now().duration_since(failure.completed) < COOLDOWN)
|
||||
.map(|failure| failure.retry_at_ms)
|
||||
.or_else(|| {
|
||||
(!unknown_model)
|
||||
.then_some(entry.retry_at_ms)
|
||||
.flatten()
|
||||
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN))
|
||||
}),
|
||||
error: model_failure.map(|failure| failure.error.clone()).or_else(|| entry.error.clone()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -233,6 +271,7 @@ impl AgentCatalogs {
|
||||
shared: &Arc<Shared>,
|
||||
spec: provider::ProviderSpec,
|
||||
force: bool,
|
||||
model: Option<&str>,
|
||||
) -> (AgentModelCatalog, Option<watch::Receiver<bool>>) {
|
||||
let key = Self::key(shared, &spec.id);
|
||||
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
|
||||
@@ -264,6 +303,7 @@ impl AgentCatalogs {
|
||||
let mut catalog = saved.catalog;
|
||||
if !matching {
|
||||
catalog.refreshed_at_ms = None;
|
||||
catalog.thought_levels.clear();
|
||||
}
|
||||
catalog
|
||||
});
|
||||
@@ -279,31 +319,73 @@ impl AgentCatalogs {
|
||||
error: None,
|
||||
flight: None,
|
||||
abort: None,
|
||||
flight_model: None,
|
||||
requested_model: None,
|
||||
model_failures: HashMap::new(),
|
||||
},
|
||||
);
|
||||
}
|
||||
let fallback =
|
||||
state.entries.get(&key).filter(|entry| entry.catalog.is_none()).map(|_| Self::fallback(shared, &spec.id));
|
||||
state.generation += 1;
|
||||
let generation = state.generation;
|
||||
let entry = state.entries.get_mut(&key).expect("catalog entry");
|
||||
let cooling = entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN);
|
||||
let catalog = entry.catalog.as_ref().or(fallback.as_ref()).expect("cached catalog");
|
||||
let fresh = entry.successful.is_some_and(|at| now.duration_since(at) < FRESH_FOR);
|
||||
let target = model
|
||||
.filter(|model| {
|
||||
(catalog.lists(model) && !catalog.thought_levels.contains_key(*model))
|
||||
|| (!fresh && catalog.model_option().is_none())
|
||||
})
|
||||
.map(str::to_owned);
|
||||
if model.is_some() && entry.requested_model.as_deref() != model {
|
||||
entry.requested_model = model.map(str::to_owned);
|
||||
}
|
||||
let superseded = model.is_some()
|
||||
&& entry.flight.is_some()
|
||||
&& (entry.flight_model.is_some() || target.is_some())
|
||||
&& entry.flight_model.as_deref() != target.as_deref();
|
||||
if superseded {
|
||||
if let Some(abort) = entry.abort.take() {
|
||||
abort.abort();
|
||||
}
|
||||
entry.flight = None;
|
||||
entry.generation = generation;
|
||||
entry.flight_model = None;
|
||||
}
|
||||
let cooling = match target.as_ref() {
|
||||
Some(model) => entry.model_failures.get(model).is_some_and(|f| now.duration_since(f.completed) < COOLDOWN),
|
||||
None => entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN),
|
||||
};
|
||||
let eligible = !cooling && (target.is_some() || force || !fresh);
|
||||
let mut start = None;
|
||||
if entry.flight.is_none() && !cooling && (force || !fresh) {
|
||||
if entry.flight.is_none() && eligible {
|
||||
let (done, ready) = watch::channel(false);
|
||||
entry.flight = Some(ready);
|
||||
entry.flight_model = target.clone();
|
||||
entry.error = None;
|
||||
if let Some(model) = target.as_ref() {
|
||||
entry.model_failures.remove(model);
|
||||
}
|
||||
entry.retry_at_ms = None;
|
||||
start = Some((entry.generation, done));
|
||||
// Every flight has its own generation, including superseded model selections.
|
||||
entry.generation = generation;
|
||||
start = Some((entry.generation, target, done));
|
||||
}
|
||||
let snapshot = self.snapshot(shared, &spec.id, entry);
|
||||
let flight = entry.flight.clone();
|
||||
drop(state);
|
||||
if let Some((generation, done)) = start {
|
||||
if superseded && start.is_none() {
|
||||
self.broadcast(shared, &snapshot);
|
||||
}
|
||||
if let Some((generation, model, done)) = start {
|
||||
self.broadcast(shared, &snapshot);
|
||||
let coordinator = self.clone();
|
||||
let shared = shared.clone();
|
||||
let flight_key = key.clone();
|
||||
let task = shared.runtime.clone().spawn(async move {
|
||||
let result = discover(&shared, spec).await;
|
||||
coordinator.complete(&shared, flight_key, generation, result);
|
||||
let result = discover(&shared, spec, model.as_deref()).await;
|
||||
coordinator.complete(&shared, flight_key, generation, model, result);
|
||||
let _ = done.send(true);
|
||||
});
|
||||
// A subscriber can re-enter and change configuration during the start event.
|
||||
@@ -319,7 +401,14 @@ impl AgentCatalogs {
|
||||
(snapshot, flight)
|
||||
}
|
||||
|
||||
fn complete(&self, shared: &Shared, key: Key, generation: u64, result: Result<Discovered, String>) {
|
||||
fn complete(
|
||||
&self,
|
||||
shared: &Shared,
|
||||
key: Key,
|
||||
generation: u64,
|
||||
model: Option<String>,
|
||||
result: Result<Discovered, String>,
|
||||
) {
|
||||
let current = provider::load(shared.paths.custom_agents_dir.as_deref(), shared.env_secrets())
|
||||
.into_iter()
|
||||
.find(|spec| spec.id == key.2)
|
||||
@@ -330,6 +419,7 @@ impl AgentCatalogs {
|
||||
if current.as_ref() != Some(&entry.context) {
|
||||
entry.flight = None;
|
||||
entry.abort = None;
|
||||
entry.flight_model = None;
|
||||
entry.completed = None;
|
||||
entry.retry_at_ms = None;
|
||||
entry.error = None;
|
||||
@@ -340,12 +430,16 @@ impl AgentCatalogs {
|
||||
return;
|
||||
}
|
||||
let now = self.now();
|
||||
entry.completed = Some(now);
|
||||
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
|
||||
if model.is_none() {
|
||||
entry.completed = Some(now);
|
||||
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
|
||||
}
|
||||
entry.flight = None;
|
||||
entry.abort = None;
|
||||
entry.flight_model = None;
|
||||
let success = match result {
|
||||
Ok(found) => {
|
||||
let previous = entry.catalog.take().unwrap_or_else(|| Self::fallback(shared, &key.2));
|
||||
let mut cache = shared.known.lock();
|
||||
let known = cache.entry(key.2.clone()).or_default();
|
||||
let mut catalog = CatalogData {
|
||||
@@ -354,7 +448,7 @@ impl AgentCatalogs {
|
||||
refreshed_at_ms: Some(self.epoch_ms()),
|
||||
};
|
||||
// Efforts sessions reported for models discovery doesn't read stay while listed.
|
||||
for (model, levels) in entry.catalog.take().map(|old| old.thought_levels).unwrap_or_default() {
|
||||
for (model, levels) in previous.thought_levels {
|
||||
if catalog.lists(&model) && !catalog.thought_levels.contains_key(&model) {
|
||||
catalog.thought_levels.insert(model, levels);
|
||||
}
|
||||
@@ -373,11 +467,30 @@ impl AgentCatalogs {
|
||||
entry.catalog = Some(catalog);
|
||||
shared.persist_known(&cache);
|
||||
entry.successful = Some(now);
|
||||
entry.completed = Some(now);
|
||||
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
|
||||
entry.model_failures.retain(|model, _| {
|
||||
entry
|
||||
.catalog
|
||||
.as_ref()
|
||||
.is_some_and(|catalog| catalog.lists(model) && !catalog.thought_levels.contains_key(model))
|
||||
});
|
||||
entry.error = None;
|
||||
true
|
||||
}
|
||||
Err(error) => {
|
||||
entry.error = Some(error);
|
||||
if let Some(model) = model {
|
||||
entry.model_failures.insert(
|
||||
model,
|
||||
ModelFailure {
|
||||
completed: now,
|
||||
retry_at_ms: self.epoch_ms() + COOLDOWN.as_millis() as f64,
|
||||
error,
|
||||
},
|
||||
);
|
||||
} else {
|
||||
entry.error = Some(error);
|
||||
}
|
||||
false
|
||||
}
|
||||
};
|
||||
@@ -448,18 +561,22 @@ impl AgentCatalogs {
|
||||
|
||||
impl crate::AgentManager {
|
||||
/// Return cached choices immediately and schedule discovery when eligible.
|
||||
pub fn refresh_models(&self, provider: &str, force: bool) -> IdeResult<AgentModelCatalog> {
|
||||
pub fn refresh_models(&self, provider: &str, force: bool, model: Option<&str>) -> IdeResult<AgentModelCatalog> {
|
||||
// Settings and environment secrets can change while this window is open.
|
||||
*self.shared.providers.write() =
|
||||
provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets());
|
||||
let spec = self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
|
||||
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force).0)
|
||||
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force, model).0)
|
||||
}
|
||||
}
|
||||
|
||||
async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<Discovered, String> {
|
||||
async fn discover(
|
||||
shared: &Arc<Shared>,
|
||||
spec: provider::ProviderSpec,
|
||||
model: Option<&str>,
|
||||
) -> Result<Discovered, String> {
|
||||
match spec.driver {
|
||||
provider::Driver::Acp => acp::discover::run(shared, &spec).await,
|
||||
provider::Driver::Acp => acp::discover::run(shared, &spec, model).await,
|
||||
provider::Driver::Codex => native::codex::discover(spec, shared.paths.project_root.clone()).await,
|
||||
provider::Driver::Claude => {
|
||||
let found = native::claude::discover(spec.clone(), shared.paths.project_root.clone()).await?;
|
||||
@@ -484,7 +601,7 @@ async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<
|
||||
provider::Driver::Copilot => {
|
||||
if shared.uses_copilot_acp_fallback(&spec) {
|
||||
let acp_spec = native::copilot::acp_fallback_spec(&spec);
|
||||
return acp::discover::run(shared, &acp_spec).await;
|
||||
return acp::discover::run(shared, &acp_spec, model).await;
|
||||
}
|
||||
match native::copilot::discover(spec.clone(), shared.paths.project_root.clone()).await {
|
||||
Ok(found) => Ok(Discovered {
|
||||
@@ -513,7 +630,7 @@ async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<
|
||||
);
|
||||
shared.mark_copilot_acp_fallback(&spec);
|
||||
let acp_spec = native::copilot::acp_fallback_spec(&spec);
|
||||
acp::discover::run(shared, &acp_spec).await
|
||||
acp::discover::run(shared, &acp_spec, model).await
|
||||
}
|
||||
Err(err) => Err(err.message),
|
||||
}
|
||||
|
||||
@@ -11,8 +11,10 @@ const PROVIDER: &str = "catalog-test";
|
||||
|
||||
#[derive(Debug)]
|
||||
struct Pending {
|
||||
method: String,
|
||||
params: Value,
|
||||
reply: oneshot::Sender<Result<Value, String>>,
|
||||
notifications: mpsc::UnboundedSender<Value>,
|
||||
}
|
||||
|
||||
struct Harness {
|
||||
@@ -31,6 +33,10 @@ impl Drop for Live {
|
||||
|
||||
impl Harness {
|
||||
fn new() -> Self {
|
||||
Self::with_initialize(json!({ "protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] }))
|
||||
}
|
||||
|
||||
fn with_initialize(initialize: Value) -> Self {
|
||||
let (pending_tx, pending) = mpsc::unbounded_channel();
|
||||
let launches = Arc::new(AtomicUsize::new(0));
|
||||
let live = Arc::new(AtomicUsize::new(0));
|
||||
@@ -42,26 +48,53 @@ impl Harness {
|
||||
live.fetch_add(1, Ordering::SeqCst);
|
||||
let guard = Live(live.clone());
|
||||
let pending = pending_tx.clone();
|
||||
let initialize = initialize.clone();
|
||||
let (notifications_tx, mut notifications) = mpsc::unbounded_channel::<Value>();
|
||||
let (client_io, server_io) = tokio::io::duplex(1 << 16);
|
||||
let (read, mut write) = tokio::io::split(server_io);
|
||||
tokio::spawn(async move {
|
||||
let _guard = guard;
|
||||
let mut lines = BufReader::new(read).lines();
|
||||
while let Some(line) = lines.next_line().await.unwrap() {
|
||||
loop {
|
||||
let line = tokio::select! {
|
||||
line = lines.next_line() => match line.unwrap() {
|
||||
Some(line) => line,
|
||||
None => break,
|
||||
},
|
||||
Some(notification) = notifications.recv() => {
|
||||
if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() {
|
||||
break;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
};
|
||||
let request: Value = serde_json::from_str(&line).unwrap();
|
||||
let id = &request["id"];
|
||||
if id.is_null() {
|
||||
continue;
|
||||
}
|
||||
let response = match request["method"].as_str().unwrap() {
|
||||
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": {
|
||||
"protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] } }),
|
||||
"session/new" => {
|
||||
let (reply, result) = oneshot::channel();
|
||||
pending.send(Pending { params: request["params"].clone(), reply }).unwrap();
|
||||
let result = tokio::select! {
|
||||
result = result => result.unwrap(),
|
||||
_ = lines.next_line() => break,
|
||||
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
|
||||
"session/new" | "session/set_config_option" | "session/set_model" => {
|
||||
let (reply, mut result) = oneshot::channel();
|
||||
pending
|
||||
.send(Pending {
|
||||
method: request["method"].as_str().unwrap().to_owned(),
|
||||
params: request["params"].clone(),
|
||||
reply,
|
||||
notifications: notifications_tx.clone(),
|
||||
})
|
||||
.unwrap();
|
||||
let result = loop {
|
||||
tokio::select! {
|
||||
result = &mut result => break result.unwrap(),
|
||||
_ = lines.next_line() => return,
|
||||
Some(notification) = notifications.recv() => {
|
||||
if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
match result {
|
||||
Ok(result) => json!({ "id": id, "jsonrpc": "2.0", "result": result }),
|
||||
@@ -190,7 +223,7 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
|
||||
let mut events = events(&manager);
|
||||
let old = config::options_of(&response(&["old", "retained"], &["low", "high"]));
|
||||
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
|
||||
let cached = manager.refresh_models(PROVIDER, false).unwrap();
|
||||
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert!(cached.refreshing);
|
||||
assert_eq!(model_values(&cached), ["old", "retained"]);
|
||||
assert!(cached.refreshed_at_ms.is_none(), "session reports are not fresh discovery");
|
||||
@@ -204,13 +237,13 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
|
||||
assert_eq!(fresh.thought_levels["retained"][0].values[0].value, "medium");
|
||||
assert!(fresh.refreshed_at_ms.is_some() && fresh.retry_at_ms.is_some());
|
||||
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
|
||||
assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config);
|
||||
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
|
||||
let provider = manager.providers().into_iter().find(|p| p.id == PROVIDER).unwrap();
|
||||
assert_eq!(provider.config, fresh.config);
|
||||
let persisted = std::fs::read_to_string(tmp.path().join("models.json")).unwrap();
|
||||
assert!(!persisted.contains("secret-one") && !persisted.contains("TOKEN"));
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let restored_snapshot = restored.refresh_models(PROVIDER, false).unwrap();
|
||||
let restored_snapshot = restored.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert!(!restored_snapshot.refreshing, "matching persisted launch context remains fresh");
|
||||
assert_eq!(restored_snapshot.refreshed_at_ms, fresh.refreshed_at_ms);
|
||||
let provider = restored.providers().into_iter().find(|p| p.id == PROVIDER).unwrap();
|
||||
@@ -229,7 +262,7 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["first", "second"], &["low", "high"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
// A session on "second" reports its own efforts; one on a model the catalog lacks, or on
|
||||
@@ -241,16 +274,16 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
|
||||
let efforts = |catalog: &AgentModelCatalog, model: &str| -> Vec<String> {
|
||||
catalog.thought_levels[model][0].values.iter().map(|v| v.value.clone()).collect()
|
||||
};
|
||||
let catalog = manager.refresh_models(PROVIDER, false).unwrap();
|
||||
let catalog = manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert_eq!(catalog.thought_levels.keys().map(String::as_str).collect::<Vec<_>>(), ["first", "second"]);
|
||||
assert_eq!(efforts(&catalog, "first"), ["low", "high"]);
|
||||
assert_eq!(efforts(&catalog, "second"), ["off", "auto"]);
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false).unwrap();
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert_eq!(efforts(&restored, "second"), ["off", "auto"], "persisted with the project's catalog");
|
||||
// Discovery again reads "first" only; "second" keeps what its session reported.
|
||||
advance(&catalogs, 60);
|
||||
while events.try_recv().is_ok() {}
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["first", "second"], &["medium"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
assert_eq!(efforts(&fresh, "first"), ["medium"]);
|
||||
@@ -273,7 +306,7 @@ async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
let cached = manager.refresh_models(PROVIDER, false).unwrap();
|
||||
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert_eq!(model_values(&cached), ["legacy"]);
|
||||
assert!(cached.refreshing && cached.refreshed_at_ms.is_none());
|
||||
harness.next().await.reply.send(Err("Sign in required".into())).unwrap();
|
||||
@@ -292,11 +325,11 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co
|
||||
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut first_events = events(&first);
|
||||
let mut second_events = events(&second);
|
||||
assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
let pending = harness.next().await;
|
||||
for _ in 0..10 {
|
||||
assert!(second.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(second.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
}
|
||||
let commands = tokio::spawn({
|
||||
let first = first.clone();
|
||||
@@ -309,21 +342,21 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co
|
||||
assert_eq!(completed(&mut second_events).await, done);
|
||||
commands.await.unwrap().unwrap();
|
||||
for force in [false, true, false, true] {
|
||||
assert!(!second.refresh_models(PROVIDER, force).unwrap().refreshing);
|
||||
assert!(!second.refresh_models(PROVIDER, force, None).unwrap().refreshing);
|
||||
}
|
||||
advance(&catalogs, 29);
|
||||
assert!(!first.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
advance(&catalogs, 1);
|
||||
assert!(!first.refresh_models(PROVIDER, false).unwrap().refreshing, "automatic refresh remains fresh");
|
||||
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!first.refresh_models(PROVIDER, false, None).unwrap().refreshing, "automatic refresh remains fresh");
|
||||
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["two"], &["high"]))).unwrap();
|
||||
let newer = completed(&mut first_events).await;
|
||||
assert_eq!(model_values(&newer), ["two"]);
|
||||
assert_eq!(completed(&mut second_events).await, newer);
|
||||
advance(&catalogs, 15 * 60 - 1);
|
||||
assert!(!second.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(!second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
advance(&catalogs, 1);
|
||||
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["three"], &["low"]))).unwrap();
|
||||
completed(&mut first_events).await;
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 3);
|
||||
@@ -337,25 +370,25 @@ async fn failure_keeps_successful_choices_and_throttles_manual_and_auto_retries(
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["cached"], &["low"]))).unwrap();
|
||||
let success = completed(&mut events).await;
|
||||
let disk = std::fs::read(tmp.path().join("models.json")).unwrap();
|
||||
advance(&catalogs, 15 * 60);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Err("Authentication expired".into())).unwrap();
|
||||
let failed = completed(&mut events).await;
|
||||
assert_eq!(failed.config, success.config);
|
||||
assert_eq!(failed.thought_levels, success.thought_levels);
|
||||
assert_eq!(failed.refreshed_at_ms, success.refreshed_at_ms);
|
||||
assert!(failed.error.as_deref().unwrap().contains("Authentication expired"));
|
||||
assert!(failed.error.as_deref().unwrap().contains("Sign in required"));
|
||||
assert_eq!(std::fs::read(tmp.path().join("models.json")).unwrap(), disk);
|
||||
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
advance(&catalogs, 29);
|
||||
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
advance(&catalogs, 1);
|
||||
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["recovered"], &["high"]))).unwrap();
|
||||
let recovered = completed(&mut events).await;
|
||||
assert_eq!(model_values(&recovered), ["recovered"]);
|
||||
@@ -370,21 +403,21 @@ async fn timeout_cleans_up_and_enters_the_same_failure_cooldown() {
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let pending = harness.next().await;
|
||||
tokio::time::pause();
|
||||
tokio::time::advance(Duration::from_secs(4)).await;
|
||||
let failed = completed(&mut events).await;
|
||||
assert!(failed.error.as_deref().unwrap().contains("time"));
|
||||
assert!(failed.retry_at_ms.is_some());
|
||||
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
|
||||
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
tokio::time::resume();
|
||||
stopped(&harness).await;
|
||||
assert_eq!(harness.live.load(Ordering::SeqCst), 0, "timed-out connection must close");
|
||||
assert!(pending.reply.is_closed());
|
||||
advance(&catalogs, 30);
|
||||
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["retry"], &["low"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
}
|
||||
@@ -398,16 +431,16 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() {
|
||||
let first = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&second);
|
||||
first.refresh_models(PROVIDER, false).unwrap();
|
||||
first.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
configure(tmp.path(), "two");
|
||||
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
let latest = harness.next().await;
|
||||
latest.reply.send(Ok(response(&["latest"], &["high"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"])));
|
||||
stopped(&harness).await;
|
||||
let shown = first.refresh_models(PROVIDER, false).unwrap();
|
||||
let shown = first.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert_eq!(shown.config, fresh.config);
|
||||
assert_eq!(shown.refreshed_at_ms, fresh.refreshed_at_ms);
|
||||
assert!(!shown.refreshing);
|
||||
@@ -415,7 +448,7 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() {
|
||||
assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete"));
|
||||
// A changed configuration also invalidates successful freshness/cooldown.
|
||||
configure(tmp.path(), "three");
|
||||
assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["new-config"], &["medium"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
}
|
||||
@@ -425,7 +458,7 @@ async fn invalid_provider_is_a_request_error_and_does_not_launch() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
assert!(manager.refresh_models("missing-provider", true).is_err());
|
||||
assert!(manager.refresh_models("missing-provider", true, None).is_err());
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 0);
|
||||
}
|
||||
|
||||
@@ -437,18 +470,18 @@ async fn replacing_the_executable_at_the_same_path_invalidates_freshness_and_obs
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs, &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
std::fs::write(tmp.path().join("catalog-test-bin"), "replacement executable with different size").unwrap();
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let latest = harness.next().await;
|
||||
latest.reply.send(Ok(response(&["updated"], &["high"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"])));
|
||||
stopped(&harness).await;
|
||||
assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config);
|
||||
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
|
||||
std::fs::write(tmp.path().join("catalog-test-bin"), "another executable").unwrap();
|
||||
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
|
||||
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&["new-install"], &["medium"]))).unwrap();
|
||||
assert_eq!(model_values(&completed(&mut events).await), ["new-install"]);
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 3);
|
||||
@@ -468,18 +501,18 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts()
|
||||
let second = make_manager_at(&b, &models_file, catalogs, &harness);
|
||||
let mut first_events = events(&first);
|
||||
let mut second_events = events(&second);
|
||||
first.refresh_models(PROVIDER, false).unwrap();
|
||||
first.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["account-a-model"], &["low"]))).unwrap();
|
||||
let a_catalog = completed(&mut first_events).await;
|
||||
second.refresh_models(PROVIDER, false).unwrap();
|
||||
second.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["account-b-model"], &["high"]))).unwrap();
|
||||
let b_catalog = completed(&mut second_events).await;
|
||||
assert_eq!(first.refresh_models(PROVIDER, false).unwrap().config, a_catalog.config);
|
||||
assert_eq!(second.refresh_models(PROVIDER, false).unwrap().config, b_catalog.config);
|
||||
assert_eq!(first.refresh_models(PROVIDER, false, None).unwrap().config, a_catalog.config);
|
||||
assert_eq!(second.refresh_models(PROVIDER, false, None).unwrap().config, b_catalog.config);
|
||||
assert_eq!(first.providers().into_iter().find(|p| p.id == PROVIDER).unwrap().config, a_catalog.config);
|
||||
for (root, expected) in [(&a, &a_catalog), (&b, &b_catalog)] {
|
||||
let restored = make_manager_at(root, &models_file, Arc::default(), &harness);
|
||||
let cached = restored.refresh_models(PROVIDER, false).unwrap();
|
||||
let cached = restored.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert!(!cached.refreshing, "matching persisted context should retain freshness");
|
||||
assert_eq!(cached.config, expected.config);
|
||||
assert_eq!(cached.refreshed_at_ms, expected.refreshed_at_ms);
|
||||
@@ -488,7 +521,7 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts()
|
||||
configure(&a, "new-account");
|
||||
let changed = make_manager_at(&a, &models_file, Arc::default(), &harness);
|
||||
let mut events = events(&changed);
|
||||
let stale = changed.refresh_models(PROVIDER, false).unwrap();
|
||||
let stale = changed.refresh_models(PROVIDER, false, None).unwrap();
|
||||
assert!(stale.refreshing, "a different launch environment cannot reuse persisted freshness");
|
||||
assert!(stale.refreshed_at_ms.is_none());
|
||||
assert_eq!(stale.config, a_catalog.config, "stale cached choices remain selectable");
|
||||
@@ -505,7 +538,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
configure(tmp.path(), "after");
|
||||
obsolete.reply.send(Ok(response(&["obsolete"], &["low"]))).unwrap();
|
||||
@@ -513,7 +546,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove
|
||||
assert!(model_values(&discarded).is_empty());
|
||||
assert!(discarded.refreshed_at_ms.is_none());
|
||||
assert!(!tmp.path().join("models.json").exists());
|
||||
manager.refresh_models(PROVIDER, false).unwrap();
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["current"], &["high"]))).unwrap();
|
||||
assert_eq!(model_values(&completed(&mut events).await), ["current"]);
|
||||
}
|
||||
@@ -526,13 +559,269 @@ async fn successful_empty_catalog_removes_all_previous_models_and_efforts() {
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["removed"], &["low"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
advance(&catalogs, 30);
|
||||
manager.refresh_models(PROVIDER, true).unwrap();
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&[], &[]))).unwrap();
|
||||
let empty = completed(&mut events).await;
|
||||
assert!(model_values(&empty).is_empty() && empty.thought_levels.is_empty());
|
||||
assert!(empty.refreshed_at_ms.is_some() && empty.error.is_none());
|
||||
}
|
||||
|
||||
fn selected_response(model: &str, effort: &[&str]) -> Value {
|
||||
let mut result = response(&[model], effort);
|
||||
if effort.is_empty() {
|
||||
result["configOptions"].as_array_mut().unwrap().retain(|option| option["id"] != "effort");
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn config_notification(session: &str, result: &Value) -> Value {
|
||||
json!({ "jsonrpc": "2.0", "method": "session/update", "params": {
|
||||
"sessionId": session,
|
||||
"update": { "sessionUpdate": "config_option_update", "configOptions": result["configOptions"] }
|
||||
} })
|
||||
}
|
||||
|
||||
fn efforts<'a>(catalog: &'a AgentModelCatalog, model: &str) -> Vec<&'a str> {
|
||||
catalog.thought_levels[model]
|
||||
.iter()
|
||||
.filter(|option| option.category.as_deref() == Some("thought_level"))
|
||||
.flat_map(|option| option.values.iter().map(|value| value.value.as_str()))
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn selected_models_report_their_own_controls_before_any_task_or_prompt() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
let models = ["default", "second", "plain", "unknown"];
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
|
||||
let original = completed(&mut events).await;
|
||||
assert!(!original.thought_levels.contains_key("second"));
|
||||
|
||||
// A fresh catalog and its global cooldown must not delay an unknown selection.
|
||||
assert!(manager.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
|
||||
let pending = harness.next().await;
|
||||
assert_eq!(pending.method, "session/set_config_option");
|
||||
assert_eq!(pending.params, json!({ "sessionId": "discovery-only", "configId": "model", "value": "second" }));
|
||||
let mut second = selected_response("second", &["off", "auto", "max"]);
|
||||
second["configOptions"].as_array_mut().unwrap().push(json!({
|
||||
"id": "context_tier", "type": "select", "currentValue": "large",
|
||||
"options": [{ "value": "normal" }, { "value": "large" }]
|
||||
}));
|
||||
pending.reply.send(Ok(second)).unwrap();
|
||||
let learned = completed(&mut events).await;
|
||||
assert_eq!(learned.config, original.config, "selection discovery never changes the default model");
|
||||
assert_eq!(efforts(&learned, "default"), ["low", "high"]);
|
||||
assert_eq!(efforts(&learned, "second"), ["off", "auto", "max"]);
|
||||
assert!(learned.thought_levels["second"].iter().any(|option| option.id == "context_tier"));
|
||||
assert!(!learned.thought_levels.contains_key("unknown"));
|
||||
|
||||
manager.refresh_models(PROVIDER, false, Some("plain")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
|
||||
harness.next().await.reply.send(Ok(selected_response("plain", &[]))).unwrap();
|
||||
let plain = completed(&mut events).await;
|
||||
assert!(plain.thought_levels["plain"].is_empty(), "an authoritative no-control result is cached");
|
||||
for model in ["default", "second", "plain"] {
|
||||
assert!(!manager.refresh_models(PROVIDER, false, Some(model)).unwrap().refreshing);
|
||||
}
|
||||
let restored = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let cached = restored.refresh_models(PROVIDER, false, Some("plain")).unwrap();
|
||||
assert!(!cached.refreshing);
|
||||
assert!(cached.thought_levels["plain"].is_empty());
|
||||
assert_eq!(efforts(&cached, "second"), ["off", "auto", "max"]);
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "never iterate unselected models");
|
||||
assert!(!tmp.path().join("store").exists(), "no task or prompt is needed");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn missing_or_failed_selected_settings_remain_unknown_and_have_model_scoped_retry_cooldowns() {
|
||||
for reply in [Ok(json!({})), Ok(selected_response("default", &["wrong"])), Err("token=secret-one".into())] {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
let models = ["default", "unsupported", "other"];
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
let original = completed(&mut events).await;
|
||||
manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
harness.next().await.reply.send(reply).unwrap();
|
||||
let failed = completed(&mut events).await;
|
||||
assert_eq!(failed.config, original.config);
|
||||
assert!(!failed.thought_levels.contains_key("unsupported"));
|
||||
assert!(failed.error.is_some() && failed.retry_at_ms.is_some());
|
||||
assert!(!failed.error.as_deref().unwrap().contains("secret-one"));
|
||||
assert!(!manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing);
|
||||
// The failed model cannot block another model, and its cooldown survives that success.
|
||||
assert!(manager.refresh_models(PROVIDER, false, Some("other")).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
harness.next().await.reply.send(Ok(selected_response("other", &[]))).unwrap();
|
||||
assert!(completed(&mut events).await.error.is_none());
|
||||
assert!(!manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap().refreshing);
|
||||
advance(&catalogs, 30);
|
||||
assert!(manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing);
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
harness.next().await.reply.send(Ok(selected_response("unsupported", &["high"]))).unwrap();
|
||||
let retried = completed(&mut events).await;
|
||||
assert_eq!(efforts(&retried, "unsupported"), ["high"]);
|
||||
assert!(retried.error.is_none());
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn rapid_model_selections_share_the_current_flight_and_discard_superseded_results() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let mut harness = Harness::new();
|
||||
let first = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&first);
|
||||
let models = ["default", "second", "third"];
|
||||
first.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
first.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
for _ in 0..5 {
|
||||
assert!(second.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing);
|
||||
}
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 2);
|
||||
second.refresh_models(PROVIDER, false, Some("third")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
|
||||
let current = harness.next().await;
|
||||
assert_eq!(current.params["value"], "third");
|
||||
current.reply.send(Ok(selected_response("third", &["max"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
let _ = obsolete.reply.send(Ok(selected_response("second", &["obsolete"])));
|
||||
stopped(&harness).await;
|
||||
let cached = first.refresh_models(PROVIDER, false, Some("third")).unwrap();
|
||||
assert_eq!(cached, fresh);
|
||||
assert_eq!(efforts(&cached, "third"), ["max"]);
|
||||
assert!(!cached.thought_levels.contains_key("second"));
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "no stale requests are queued");
|
||||
assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn switching_back_to_a_known_model_cancels_the_unknown_model_flight() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
let obsolete = harness.next().await;
|
||||
let known = manager.refresh_models(PROVIDER, false, Some("default")).unwrap();
|
||||
assert!(!known.refreshing);
|
||||
assert_eq!(completed(&mut events).await, known, "other subscribers also leave loading state");
|
||||
let _ = obsolete.reply.send(Err("late failure".into()));
|
||||
stopped(&harness).await;
|
||||
let cached = manager.refresh_models(PROVIDER, false, Some("default")).unwrap();
|
||||
assert!(cached.error.is_none() && !cached.thought_levels.contains_key("second"));
|
||||
assert_eq!(harness.launches.load(Ordering::SeqCst), 2);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn selected_model_uses_legacy_set_model_and_authoritative_notifications() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
// No cache is needed: the selected model is resolved in the same short-lived session.
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
harness
|
||||
.next()
|
||||
.await
|
||||
.reply
|
||||
.send(Ok(json!({
|
||||
"sessionId": "discovery-only",
|
||||
"models": { "currentModelId": "default", "availableModels": [
|
||||
{ "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" }
|
||||
] }
|
||||
})))
|
||||
.unwrap();
|
||||
let selected = harness.next().await;
|
||||
assert_eq!(selected.method, "session/set_model");
|
||||
assert_eq!(selected.params, json!({ "sessionId": "discovery-only", "modelId": "second" }));
|
||||
let notifications = selected.notifications;
|
||||
selected.reply.send(Ok(json!({}))).unwrap();
|
||||
notifications.send(config_notification("different-session", &selected_response("second", &["wrong"]))).unwrap();
|
||||
notifications
|
||||
.send(config_notification("discovery-only", &selected_response("second", &["medium", "high"])))
|
||||
.unwrap();
|
||||
let catalog = completed(&mut events).await;
|
||||
assert_eq!(efforts(&catalog, "second"), ["medium", "high"]);
|
||||
assert_eq!(catalog.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("default"));
|
||||
assert!(!catalog.thought_levels.contains_key("default"), "legacy model lists alone do not assert no controls");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn catalog_replacement_removes_selected_metadata_for_models_no_longer_listed() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let catalogs = Arc::new(AgentCatalogs::default());
|
||||
let mut harness = Harness::new();
|
||||
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap();
|
||||
harness.next().await.reply.send(Ok(selected_response("second", &["max"]))).unwrap();
|
||||
completed(&mut events).await;
|
||||
advance(&catalogs, 30);
|
||||
manager.refresh_models(PROVIDER, true, None).unwrap();
|
||||
harness.next().await.reply.send(Ok(response(&["default", "new"], &["medium"]))).unwrap();
|
||||
let replaced = completed(&mut events).await;
|
||||
assert_eq!(model_values(&replaced), ["default", "new"]);
|
||||
assert_eq!(efforts(&replaced, "default"), ["medium"]);
|
||||
assert!(!replaced.thought_levels.contains_key("second") && !replaced.thought_levels.contains_key("new"));
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn selected_model_discovery_uses_the_negotiated_v2_wire_format_and_config_updates() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::with_initialize(json!({
|
||||
"protocolVersion": 2, "info": { "name": "V2 Catalog Test" }, "capabilities": { "session": {} }
|
||||
}));
|
||||
let manager = make_manager(tmp.path(), Arc::default(), &harness);
|
||||
let mut events = events(&manager);
|
||||
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
|
||||
let mut initial = response(&["default", "second"], &["low"]);
|
||||
for option in initial["configOptions"].as_array_mut().unwrap() {
|
||||
option["configId"] = option.as_object_mut().unwrap().remove("id").unwrap();
|
||||
}
|
||||
harness.next().await.reply.send(Ok(initial)).unwrap();
|
||||
let selected = harness.next().await;
|
||||
assert_eq!(selected.method, "session/set_config_option");
|
||||
assert_eq!(
|
||||
selected.params,
|
||||
json!({
|
||||
"sessionId": "discovery-only", "configId": "model", "value": "second", "type": "id"
|
||||
})
|
||||
);
|
||||
// Notifications may arrive before the request response as well as after it.
|
||||
selected.notifications.send(config_notification("discovery-only", &selected_response("second", &[]))).unwrap();
|
||||
selected.reply.send(Ok(json!({}))).unwrap();
|
||||
let catalog = completed(&mut events).await;
|
||||
assert!(catalog.thought_levels["second"].is_empty());
|
||||
assert_eq!(efforts(&catalog, "default"), ["low"]);
|
||||
}
|
||||
|
||||
+104
-24
@@ -363,6 +363,7 @@ struct TaskState {
|
||||
session_id: Option<String>,
|
||||
conversation: Conversation,
|
||||
wanted: Vec<AgentConfigChoice>,
|
||||
model_choice: u64,
|
||||
before: Arc<BTreeMap<String, worktree::Stamp>>,
|
||||
saved: Option<String>,
|
||||
/// See `TaskFile::touched`.
|
||||
@@ -621,7 +622,7 @@ impl AgentManager {
|
||||
.into_iter()
|
||||
.find(|spec| spec.id == provider)
|
||||
{
|
||||
let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false);
|
||||
let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, None);
|
||||
if let Some(mut ready) = flight {
|
||||
while !*ready.borrow_and_update() {
|
||||
if ready.changed().await.is_err() {
|
||||
@@ -954,19 +955,36 @@ impl AgentManager {
|
||||
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
|
||||
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
|
||||
let task = self.task(id)?;
|
||||
let target = {
|
||||
let s = task.state.lock();
|
||||
let o =
|
||||
s.task.config.iter().find(|o| o.id == option).ok_or_else(|| IdeError::not_found("no such setting"))?;
|
||||
if !o.values.iter().any(|v| v.value == value) {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", o.name)));
|
||||
let (target, model_choice, previous_levels) = {
|
||||
let mut s = task.state.lock();
|
||||
let target = s
|
||||
.task
|
||||
.config
|
||||
.iter()
|
||||
.find(|o| o.id == option)
|
||||
.ok_or_else(|| IdeError::not_found("no such setting"))?
|
||||
.clone();
|
||||
if !target.values.iter().any(|v| v.value == value) {
|
||||
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
|
||||
}
|
||||
o.clone()
|
||||
if target.category.as_deref() == Some("model") {
|
||||
s.model_choice += 1;
|
||||
}
|
||||
let previous_levels =
|
||||
if target.category.as_deref() == Some("model") && target.current.as_deref() != Some(value.as_str()) {
|
||||
Some(s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>())
|
||||
} else {
|
||||
None
|
||||
};
|
||||
s.wanted.retain(|c| c.id != option);
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
|
||||
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current = Some(value.clone());
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
(target, s.model_choice, previous_levels)
|
||||
};
|
||||
let previous = target.current.clone();
|
||||
// Cursor's `session/set_config_option` (Fast, effort) can take seconds. Show the
|
||||
// choice first so the switch and slider move immediately.
|
||||
apply_config_choice(&task, option, &value);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
|
||||
@@ -976,36 +994,77 @@ impl AgentManager {
|
||||
let mut model_options = (target.category.as_deref() != Some("model")
|
||||
|| previous.as_deref() == Some(value.as_str()))
|
||||
&& task.state.lock().task.config.iter().any(config::is_per_model_option);
|
||||
if live.is_none()
|
||||
&& target.category.as_deref() == Some("model")
|
||||
&& (previous.as_deref() != Some(value.as_str()) || !model_options)
|
||||
{
|
||||
let provider = task.state.lock().task.provider.clone();
|
||||
let mut levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
|
||||
let mut error = None;
|
||||
if levels.is_none()
|
||||
&& let Some(spec) = self.shared.spec(&provider)
|
||||
{
|
||||
let (catalog, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, Some(&value));
|
||||
error = catalog.error;
|
||||
if let Some(mut ready) = flight {
|
||||
while !*ready.borrow_and_update() {
|
||||
if ready.changed().await.is_err() {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
|
||||
}
|
||||
// Another selection may have superseded this discovery while it was waiting.
|
||||
if task.state.lock().model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
let Some(levels) = levels else {
|
||||
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
return Err(IdeError::unavailable(
|
||||
error.unwrap_or_else(|| "The agent did not report settings for the selected model".into()),
|
||||
));
|
||||
};
|
||||
let mut s = task.state.lock();
|
||||
if s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
s.task.config.extend(levels);
|
||||
model_options = true;
|
||||
}
|
||||
if let Some(live) = live.filter(|_| option != config::CURSOR_APPROVAL) {
|
||||
let (method, mut params) = config::set_request(&target, &value);
|
||||
params["sessionId"] = json!(live.session);
|
||||
let reply: Value = match live.peer.request(method, params, None).await {
|
||||
Ok(reply) => reply,
|
||||
Err(e) => {
|
||||
{
|
||||
let mut s = task.state.lock();
|
||||
s.wanted.retain(|c| c.id != option);
|
||||
if let Some(prev) = previous.clone() {
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: prev });
|
||||
}
|
||||
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
|
||||
o.current = previous.clone();
|
||||
}
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
}
|
||||
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
|
||||
task.persist();
|
||||
task.emit_task();
|
||||
return Err(IdeError::internal(task.describe(e)));
|
||||
}
|
||||
};
|
||||
if target.category.as_deref() == Some("model") && task.state.lock().model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if let Some(options) = reply.get("configOptions") {
|
||||
config::merge_update(&mut task.state.lock().task.config, options);
|
||||
model_options = true;
|
||||
} else if target.category.as_deref() == Some("model") {
|
||||
// Old model controls were removed above, so these came from an update
|
||||
// that preceded the response.
|
||||
model_options = task.state.lock().task.config.iter().any(config::is_per_model_option);
|
||||
}
|
||||
}
|
||||
{
|
||||
let mut s = task.state.lock();
|
||||
if !model_options {
|
||||
if target.category.as_deref() == Some("model") && s.model_choice != model_choice {
|
||||
return Ok(());
|
||||
}
|
||||
if !model_options && target.category.as_deref() == Some("model") {
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
}
|
||||
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
|
||||
@@ -1583,6 +1642,7 @@ impl Task {
|
||||
session_id: file.session_id,
|
||||
conversation,
|
||||
wanted: file.wanted,
|
||||
model_choice: 0,
|
||||
before: Arc::new(file.before),
|
||||
saved: file.saved,
|
||||
touched: file.touched.map(Arc::new),
|
||||
@@ -3093,12 +3153,32 @@ fn retry_of(update: &Value, now: f64) -> Option<AgentRetry> {
|
||||
})
|
||||
}
|
||||
|
||||
fn apply_config_choice(task: &Task, option: &str, value: &str) {
|
||||
fn restore_config_choice(
|
||||
task: &Task,
|
||||
target: &AgentConfigOption,
|
||||
value: &str,
|
||||
previous: Option<&str>,
|
||||
model_choice: u64,
|
||||
previous_levels: Option<Vec<AgentConfigOption>>,
|
||||
) {
|
||||
let option = target.id.as_str();
|
||||
let is_model = target.category.as_deref() == Some("model");
|
||||
let mut s = task.state.lock();
|
||||
if (is_model && s.model_choice != model_choice)
|
||||
|| !s.task.config.iter().any(|o| o.id == option && o.current.as_deref() == Some(value))
|
||||
{
|
||||
return;
|
||||
}
|
||||
s.wanted.retain(|c| c.id != option);
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.to_owned() });
|
||||
if let Some(previous) = previous {
|
||||
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: previous.to_owned() });
|
||||
}
|
||||
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
|
||||
o.current = Some(value.to_owned());
|
||||
o.current = previous.map(str::to_owned);
|
||||
}
|
||||
if let Some(levels) = previous_levels {
|
||||
s.task.config.retain(|o| !config::is_per_model_option(o));
|
||||
s.task.config.extend(levels);
|
||||
}
|
||||
s.task.model = model_of(&s.task.config).or(s.task.model.take());
|
||||
}
|
||||
|
||||
@@ -51,6 +51,7 @@ struct FakeAgent {
|
||||
/// Config options `session/new` reports after the model one (per-model efforts, say).
|
||||
extra_options: Mutex<Vec<Value>>,
|
||||
model_options: Mutex<HashMap<String, Vec<Value>>>,
|
||||
model_config_gate: Mutex<Option<std::sync::mpsc::Receiver<()>>>,
|
||||
/// Advertises steering as OMP does (`_meta.steering` at the top of `initialize`)
|
||||
/// instead of `_meta.openidea.steer`.
|
||||
session_steering: bool,
|
||||
@@ -231,6 +232,12 @@ impl Handler for FakeAgent {
|
||||
std::thread::sleep(self.delay_config);
|
||||
}
|
||||
self.calls.lock().push(format!("{method} {}", params.get("value").or(params.get("modeId")).unwrap()));
|
||||
if params["configId"] == "model" {
|
||||
let gate = self.model_config_gate.lock().take();
|
||||
if let Some(gate) = gate {
|
||||
gate.recv().unwrap();
|
||||
}
|
||||
}
|
||||
if params["configId"] == "model" && !self.model_options.lock().is_empty() {
|
||||
return Ok(json!({"configOptions": self.options_for(params["value"].as_str().unwrap())}));
|
||||
}
|
||||
@@ -590,6 +597,7 @@ for line in sys.stdin:
|
||||
assert_eq!(names, ["compact", "clear", "model", "context", "triage"]);
|
||||
assert_eq!(first[0].hint.as_deref(), Some("[instructions]"));
|
||||
let restored = manager(root, Arc::new(FakeAgent::default()));
|
||||
restored.set_builtin_command("claude", Some(script.to_string_lossy().into_owned())).unwrap();
|
||||
assert_eq!(first, restored.commands("claude", None).await.unwrap());
|
||||
// The same handshake lists the models, so the composer has them before any task.
|
||||
for mgr in [&mgr, &restored] {
|
||||
@@ -1931,8 +1939,7 @@ async fn thinking_levels_are_remembered_per_provider_and_model() {
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
|
||||
// After a model switch no session reported, picking that model again or changing
|
||||
// another setting must not record the task's effort-less copy as the model's levels.
|
||||
// Idle selections use cached model controls or discover them before the next prompt.
|
||||
for (option, value) in [("mode", "code"), ("model", "big")] {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
@@ -1945,7 +1952,7 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
|
||||
.create(NewAgentTask {
|
||||
project_root: None,
|
||||
prompt: text("again"),
|
||||
provider: "claude".into(),
|
||||
provider: "claude-acp".into(),
|
||||
config: vec![],
|
||||
isolation: Isolation::Local,
|
||||
base: None,
|
||||
@@ -1957,18 +1964,165 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent);
|
||||
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
{
|
||||
let small = restored.task(&task.id).unwrap();
|
||||
let small = small.state.lock();
|
||||
let effort = small.task.config.iter().find(|option| option.id == "effort").unwrap();
|
||||
assert_eq!(
|
||||
effort.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(),
|
||||
["minimal", "medium"]
|
||||
);
|
||||
}
|
||||
restored.set_config(&task.id, "model", "big".into()).await.unwrap();
|
||||
restored.set_config(&task.id, option, value.into()).await.unwrap();
|
||||
let p = restored.providers().into_iter().find(|p| p.id == "claude").unwrap();
|
||||
let p = restored.providers().into_iter().find(|p| p.id == "claude-acp").unwrap();
|
||||
let big = p.thought_levels.get("big").and_then(|levels| levels.first());
|
||||
assert_eq!(big.map(|o| o.values.len()), Some(2), "{option}: {:?}", p.thought_levels);
|
||||
let saved: HashMap<String, Known> =
|
||||
serde_json::from_slice(&std::fs::read(&restored.shared.paths.models_file).unwrap()).unwrap();
|
||||
assert_eq!(saved["claude"].thought_levels, p.thought_levels, "{option}");
|
||||
assert_eq!(saved["claude-acp"].thought_levels, p.thought_levels, "{option}");
|
||||
restored.shutdown();
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn idle_model_switches_discover_controls_and_no_control_models_without_another_prompt() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.model_options.lock() = HashMap::from([
|
||||
("big".into(), effort_options(&["low", "high"], "high")),
|
||||
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
|
||||
("plain".into(), vec![]),
|
||||
]);
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude-acp".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent.clone());
|
||||
assert!(
|
||||
!restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels.contains_key("small")
|
||||
);
|
||||
agent.calls.lock().clear();
|
||||
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
let current = restored.task(&task.id).unwrap();
|
||||
let config = current.state.lock().task.config.clone();
|
||||
let effort = config.iter().find(|option| option.id == "effort").unwrap();
|
||||
assert_eq!(effort.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(), ["minimal", "medium"]);
|
||||
restored.set_config(&task.id, "effort", "medium".into()).await.unwrap();
|
||||
restored.set_config(&task.id, "model", "plain".into()).await.unwrap();
|
||||
assert!(!current.state.lock().task.config.iter().any(config::is_per_model_option));
|
||||
let known = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp");
|
||||
assert!(known.thought_levels["plain"].is_empty());
|
||||
assert_eq!(known.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("big"));
|
||||
{
|
||||
let mut calls = agent.calls.lock();
|
||||
assert!(!calls.iter().any(|call| call == "session/prompt" || call == "session/load"));
|
||||
assert_eq!(calls.iter().filter(|call| *call == "session/new").count(), 2);
|
||||
calls.clear();
|
||||
}
|
||||
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
|
||||
assert!(agent.calls.lock().is_empty(), "a known model remains a cache-only selection");
|
||||
assert!(current.live.lock().is_none(), "discovery never mutates a task's live session");
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn idle_model_discovery_failure_restores_the_previous_choice_without_claiming_no_controls() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.extra_options.lock() = effort_options(&["low", "high"], "low");
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude-acp".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
let restored = manager(tmp.path(), agent.clone());
|
||||
agent.calls.lock().clear();
|
||||
assert!(restored.set_config(&task.id, "model", "small".into()).await.is_err());
|
||||
let current = restored.task(&task.id).unwrap();
|
||||
assert_eq!(current.state.lock().task.model.as_deref(), Some("big"));
|
||||
assert!(current.state.lock().task.config.iter().any(|option| option.id == "effort"));
|
||||
assert!(
|
||||
!restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels.contains_key("small")
|
||||
);
|
||||
assert!(!agent.calls.lock().iter().any(|call| call == "session/prompt"));
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn rapid_idle_model_switches_share_discovery_and_never_apply_a_stale_completion() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let agent = Arc::new(FakeAgent::default());
|
||||
*agent.model_options.lock() = HashMap::from([
|
||||
("big".into(), effort_options(&["low", "high"], "high")),
|
||||
("small".into(), effort_options(&["minimal", "medium"], "minimal")),
|
||||
("plain".into(), vec![]),
|
||||
]);
|
||||
let mgr = manager(tmp.path(), agent.clone());
|
||||
let task = mgr
|
||||
.create(NewAgentTask {
|
||||
prompt: text("again"),
|
||||
provider: "claude-acp".into(),
|
||||
isolation: Isolation::Local,
|
||||
..Default::default()
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
|
||||
mgr.shutdown();
|
||||
let restored = Arc::new(manager(tmp.path(), agent.clone()));
|
||||
agent.calls.lock().clear();
|
||||
let (release, gate) = std::sync::mpsc::channel();
|
||||
*agent.model_config_gate.lock() = Some(gate);
|
||||
let first = tokio::spawn({
|
||||
let restored = restored.clone();
|
||||
let id = task.id.clone();
|
||||
async move { restored.set_config(&id, "model", "small".into()).await }
|
||||
});
|
||||
tokio::time::timeout(Duration::from_secs(5), async {
|
||||
while agent.model_config_gate.lock().is_some() {
|
||||
tokio::task::yield_now().await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.unwrap();
|
||||
let duplicate = restored.set_config(&task.id, "model", "small".into());
|
||||
tokio::pin!(duplicate);
|
||||
tokio::select! {
|
||||
biased;
|
||||
result = &mut duplicate => panic!("duplicate selection must join the pending discovery: {result:?}"),
|
||||
_ = tokio::task::yield_now() => {}
|
||||
}
|
||||
restored.set_config(&task.id, "model", "plain".into()).await.unwrap();
|
||||
release.send(()).unwrap();
|
||||
first.await.unwrap().unwrap();
|
||||
duplicate.await.unwrap();
|
||||
let current = restored.task(&task.id).unwrap();
|
||||
assert_eq!(current.state.lock().task.model.as_deref(), Some("plain"));
|
||||
assert!(!current.state.lock().task.config.iter().any(config::is_per_model_option));
|
||||
let catalog = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp");
|
||||
assert!(catalog.thought_levels["plain"].is_empty());
|
||||
assert!(!catalog.thought_levels.contains_key("small"), "obsolete discovery cannot populate model settings");
|
||||
assert_eq!(agent.calls.lock().iter().filter(|call| *call == "session/new").count(), 2);
|
||||
assert!(!agent.calls.lock().iter().any(|call| call == "session/prompt"));
|
||||
restored.shutdown();
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread")]
|
||||
async fn upfront_effort_is_validated_after_changing_model_before_the_prompt() {
|
||||
for (effort, applied) in [("medium", true), ("high", false)] {
|
||||
|
||||
@@ -30,9 +30,15 @@ pub fn providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
|
||||
}
|
||||
|
||||
/// Refreshes the selected agent's model catalog without sending a prompt.
|
||||
pub fn refresh_models(host: &Host, window: &str, provider: String, force: bool) -> IdeResult<AgentModelCatalog> {
|
||||
pub fn refresh_models(
|
||||
host: &Host,
|
||||
window: &str,
|
||||
provider: String,
|
||||
force: bool,
|
||||
model: Option<String>,
|
||||
) -> IdeResult<AgentModelCatalog> {
|
||||
host.require_trust(window)?;
|
||||
host.project(window)?.agents.refresh_models(&provider, force)
|
||||
host.project(window)?.agents.refresh_models(&provider, force, model.as_deref())
|
||||
}
|
||||
|
||||
/// Overrides built-in agent `id`'s command with `command` (its agent file keeps the
|
||||
@@ -832,7 +838,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
|
||||
d.add("agent_subscribe", |c| async move { subscribe(&c.host, &c.window, c.channel("onEvent")?) });
|
||||
d.add("agent_providers", |c| async move { providers(&c.host, &c.window) });
|
||||
d.add("agent_refresh_models", |c| async move {
|
||||
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?)
|
||||
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?, c.arg("model")?)
|
||||
});
|
||||
d.add("agent_set_command", |c| async move { set_command(&c.host, &c.window, c.arg("id")?, c.arg("command")?) });
|
||||
d.add("agent_set_env", |c| async move { set_env(&c.host, &c.window, c.arg("id")?, c.arg("env")?) });
|
||||
|
||||
@@ -68,7 +68,7 @@ done
|
||||
}
|
||||
for _ in 0..20 {
|
||||
for window in ["first", "second"] {
|
||||
let state = ops::agent::refresh_models(&host, window, "catalog-test".into(), true).unwrap();
|
||||
let state = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
|
||||
assert!(state.refreshing);
|
||||
}
|
||||
}
|
||||
@@ -87,7 +87,7 @@ done
|
||||
assert!(completed.is_ok(), "both windows must receive the completed catalog");
|
||||
for _ in 0..20 {
|
||||
for window in ["first", "second"] {
|
||||
let catalog = ops::agent::refresh_models(&host, window, "catalog-test".into(), true).unwrap();
|
||||
let catalog = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
|
||||
assert!(!catalog.refreshing);
|
||||
assert!(catalog.retry_at_ms.is_some());
|
||||
let models = catalog.config.iter().find(|o| o.category.as_deref() == Some("model")).unwrap();
|
||||
|
||||
@@ -54,7 +54,9 @@ Codex keeps its own project trust decision. If it disables the current project's
|
||||
<Step title="Pick the agent and its settings">
|
||||
Choose the agent, and its model, mode and other options when it offers them. Cached models appear immediately; the selected agent's catalog refreshes in the background when it is more than 15 minutes old, without sending a prompt or attaching project MCP servers.
|
||||
|
||||
After changing the agent CLI or account, open the model picker and choose **Refresh models**. Refreshes share one lookup and have a 30-second cooldown after completion, including failures. Cached choices remain usable while refreshing or after a failure.
|
||||
Model-specific effort levels and context options are looked up when you select a model whose settings are not cached, even before its first task. **Loading model settings…** appears beside the model during this short-lived lookup; no prompt is sent and existing tasks are not changed. Each model keeps its own choices, and models that report no effort control do not borrow another model's levels.
|
||||
|
||||
After changing the agent CLI or account, open the model picker and choose **Refresh models**. Refreshes share one lookup and have a 30-second cooldown after completion, including failures. Selecting an uncached model's settings does not wait for another model's cooldown. Cached choices remain usable while refreshing or after a failure; use **Refresh models** to retry a failed lookup after its cooldown.
|
||||
|
||||
Available models depend on the installed agent and account. If a selected model is removed, choose another before starting. Refreshing does not change running tasks.
|
||||
|
||||
|
||||
@@ -54,7 +54,9 @@ Codex 有自己的项目信任设置。如果它禁用了当前项目的 `.codex
|
||||
<Step title="选择 agent 及其设置">
|
||||
选择 agent,以及它提供的模型、模式等选项。缓存的模型会立即显示;所选 agent 的模型列表超过 15 分钟未更新时,会在后台刷新,不发送提示词,也不接入项目 MCP 服务器。
|
||||
|
||||
更改 agent CLI 或账号后,打开模型选择器并单击 **刷新模型**。并发刷新会共用一次查询;每次查询完成后(包括失败)都有 30 秒冷却时间。刷新中或刷新失败后,缓存选项仍可使用。
|
||||
选择尚未缓存设置的模型时,会按需查询该模型的思考强度和上下文选项,无需先运行任务。短暂查询期间,模型旁会显示**正在加载模型设置…**;查询不发送提示词,也不更改现有任务。每个模型分别保留你选择的设置;明确不提供思考强度的模型不会沿用其他模型的强度选项。
|
||||
|
||||
更改 agent CLI 或账号后,打开模型选择器并单击 **刷新模型**。并发刷新会共用一次查询;每次查询完成后(包括失败)都有 30 秒冷却时间。查询其他未缓存模型的设置无需等待前一个模型的冷却时间。刷新中或刷新失败后,缓存选项仍可使用;查询失败后,可在冷却结束后用**刷新模型**重试。
|
||||
|
||||
可用模型取决于已安装的 agent 和账号。如果已选模型被移除,需要先选择其他模型才能开始任务。刷新不会更改正在运行的任务。
|
||||
|
||||
|
||||
@@ -533,3 +533,69 @@ for (const setting of ["effort", "model"] as const) {
|
||||
await page.evaluate(() => document.dispatchEvent(new Event("release-config")));
|
||||
});
|
||||
}
|
||||
|
||||
test("New Task discovers uncached model effort before the first prompt", async ({ workbench: page }, testInfo) => {
|
||||
await seed(page, "editor", "new");
|
||||
await expect
|
||||
.poll(() =>
|
||||
page.evaluate(async () => {
|
||||
// The store must be loaded in the page's Vite realm, not Playwright's Node process.
|
||||
const storePath = "/src/features/agents/store.ts";
|
||||
const { useAgents } = await import(storePath);
|
||||
return useAgents.getState().modelRequests.size;
|
||||
}),
|
||||
)
|
||||
.toBe(0);
|
||||
await page.evaluate(
|
||||
async ({ provider, swift }) => {
|
||||
// Static Node imports cannot update the browser workbench's store.
|
||||
const storePath = "/src/features/agents/store.ts";
|
||||
const { useAgents } = await import(storePath);
|
||||
const thoughtLevels = { ...provider.thoughtLevels };
|
||||
delete thoughtLevels.swift;
|
||||
const cached = { ...provider, thoughtLevels };
|
||||
window.__ipc.handlers.agent_providers = () => [cached];
|
||||
window.__ipc.handlers.agent_refresh_models = async ({ model }) => {
|
||||
if (model === "swift") {
|
||||
const { promise, resolve } = Promise.withResolvers<void>();
|
||||
document.addEventListener("test:model-settings-ready", () => resolve(), { once: true });
|
||||
await promise;
|
||||
thoughtLevels.swift = [swift];
|
||||
}
|
||||
return {
|
||||
provider: cached.id,
|
||||
config: cached.config,
|
||||
thoughtLevels: { ...thoughtLevels },
|
||||
refreshing: false,
|
||||
refreshedAtMs: Date.now(),
|
||||
retryAtMs: null,
|
||||
error: null,
|
||||
};
|
||||
};
|
||||
useAgents.setState({ providers: [cached], modelCatalogs: new Map() });
|
||||
},
|
||||
{ provider, swift },
|
||||
);
|
||||
await expectEffort(page, "Gentle");
|
||||
await box(page).fill("Keep this first task unsent");
|
||||
await chooseModel(page, "Swift");
|
||||
try {
|
||||
await expect
|
||||
.poll(async () => (await ipcCalls(page, "agent_refresh_models")).filter((call) => call.model === "swift"))
|
||||
.toEqual([{ provider: provider.id, force: false, model: "swift" }]);
|
||||
await expect(page.getByRole("status").filter({ hasText: "Loading model settings…" })).toBeVisible();
|
||||
await expect(effortButton(page)).toHaveCount(0);
|
||||
await page.screenshot({ path: testInfo.outputPath("model-settings-loading.png") });
|
||||
await page.evaluate(() => document.dispatchEvent(new Event("test:model-settings-ready")));
|
||||
await expectEffort(page, "Quick");
|
||||
await effortButton(page).click();
|
||||
await expect(page.getByRole("option", { name: "Quick", exact: true })).toBeVisible();
|
||||
await expect(page.getByRole("option", { name: "Thorough", exact: true })).toBeVisible();
|
||||
await expect(page.getByRole("option", { name: "Gentle", exact: true })).toHaveCount(0);
|
||||
await expect(box(page)).toHaveText("Keep this first task unsent");
|
||||
await expectNoSubmission(page);
|
||||
expect(await ipcCalls(page, "agent_set_config")).toEqual([]);
|
||||
} finally {
|
||||
await page.screenshot({ path: testInfo.outputPath("uncached-model-effort.png") });
|
||||
}
|
||||
});
|
||||
|
||||
@@ -46,8 +46,9 @@ pub fn agent_refresh_models(
|
||||
state: State<'_, AppState>,
|
||||
provider: String,
|
||||
force: bool,
|
||||
model: Option<String>,
|
||||
) -> IdeResult<AgentModelCatalog> {
|
||||
agent::refresh_models(&state.host, window.label(), provider, force)
|
||||
agent::refresh_models(&state.host, window.label(), provider, force, model)
|
||||
}
|
||||
|
||||
/// Overrides built-in agent `id`'s command with `command` (its agent file keeps the
|
||||
|
||||
+1
-1
@@ -148,7 +148,7 @@ export const commands = {
|
||||
agentSubscribe: (onEvent: Channel<AgentEvent_Deserialize>) => typedError<AgentTask_Serialize[], IdeError>(__TAURI_INVOKE("agent_subscribe", { onEvent })),
|
||||
agentProviders: () => typedError<AgentProvider[], IdeError>(__TAURI_INVOKE("agent_providers")),
|
||||
/** Refreshes the model catalog; force bypasses freshness, not the cooldown. */
|
||||
agentRefreshModels: (provider: string, force: boolean) => typedError<AgentModelCatalog, IdeError>(__TAURI_INVOKE("agent_refresh_models", { provider, force })),
|
||||
agentRefreshModels: (provider: string, force: boolean, model: string | null) => typedError<AgentModelCatalog, IdeError>(__TAURI_INVOKE("agent_refresh_models", { provider, force, model })),
|
||||
/**
|
||||
* Overrides built-in agent `id`'s command with `command` (its agent file keeps the
|
||||
* built-in's driver and arguments), or returns it to auto-detection with `None`.
|
||||
|
||||
@@ -72,6 +72,7 @@ const selected = (option: AgentConfigOption, value: string | null) =>
|
||||
|
||||
interface ModelRefresh {
|
||||
refreshing: boolean;
|
||||
loadingSettings?: boolean;
|
||||
retryAtMs: number | null;
|
||||
error: string | null;
|
||||
onRefresh: () => void;
|
||||
@@ -151,6 +152,11 @@ export function ConfigPickers({
|
||||
) : (
|
||||
<ConfigPicker option={o} value={valueOf(o)} onChange={onChange} />
|
||||
)}
|
||||
{o === model && modelRefresh?.loadingSettings && (
|
||||
<span className={styles.pickerValue} role="status">
|
||||
<T>Loading model settings…</T>
|
||||
</span>
|
||||
)}
|
||||
</span>
|
||||
))}
|
||||
{secondary.length > 0 && (
|
||||
|
||||
@@ -92,16 +92,47 @@ export function HomeEditor({ docked = false, input }: { docked?: boolean; input?
|
||||
const probe = useProbe(provider?.installed ? provider.id : null, provider?.command, shown);
|
||||
const catalog = useAgents((s) => s.modelCatalogs.get(provider?.id ?? ""));
|
||||
const requestingModels = useAgents((s) => s.modelRequests.has(provider?.id ?? ""));
|
||||
const requestTarget = useAgents((s) => s.modelRequestTargets.get(provider?.id ?? ""));
|
||||
const { defaults, fitWindowWidth } = useAgentSettings();
|
||||
const config = draftConfig(provider, draft, (provider && defaults[provider.id]) || {});
|
||||
const model = config.find((o) => o.category === "model");
|
||||
const selectedModel = model?.current ?? null;
|
||||
const selectedModelRef = useRef(selectedModel);
|
||||
useEffect(() => {
|
||||
selectedModelRef.current = selectedModel;
|
||||
}, [selectedModel]);
|
||||
const attemptedModels = useRef(new Set<string>());
|
||||
const launch = provider && JSON.stringify([provider.program, provider.args, provider.env, provider.command]);
|
||||
useEffect(() => {
|
||||
if (!provider?.installed) return;
|
||||
const refresh = () => void refreshModels(provider.id, false);
|
||||
const refresh = () => void refreshModels(provider.id, false, selectedModelRef.current);
|
||||
refresh();
|
||||
window.addEventListener("focus", refresh);
|
||||
return () => window.removeEventListener("focus", refresh);
|
||||
}, [provider?.id, provider?.installed, launch, project?.root]);
|
||||
const { defaults, fitWindowWidth } = useAgentSettings();
|
||||
const config = draftConfig(provider, draft, (provider && defaults[provider.id]) || {});
|
||||
const unknownModelSettings =
|
||||
!!selectedModel &&
|
||||
!!model?.values.some((v) => v.value === selectedModel) &&
|
||||
!Object.hasOwn((catalog ?? provider)?.thoughtLevels ?? {}, selectedModel);
|
||||
useEffect(() => {
|
||||
if (!provider?.installed || !selectedModel || !unknownModelSettings) return;
|
||||
const key = JSON.stringify([provider.id, launch, project?.root, selectedModel]);
|
||||
if (requestTarget === selectedModel) attemptedModels.current.add(key);
|
||||
if (requestingModels || catalog?.refreshing || attemptedModels.current.has(key)) return;
|
||||
attemptedModels.current.add(key);
|
||||
void refreshModels(provider.id, false, selectedModel);
|
||||
}, [
|
||||
provider?.id,
|
||||
provider?.installed,
|
||||
launch,
|
||||
project?.root,
|
||||
selectedModel,
|
||||
unknownModelSettings,
|
||||
requestingModels,
|
||||
catalog,
|
||||
requestTarget,
|
||||
]);
|
||||
const currentModelRequest = requestTarget === undefined || requestTarget === selectedModel;
|
||||
const homeRoot = useRef<HTMLDivElement>(null);
|
||||
const { zoomStyle } = useAgentFontZoomSurface(homeRoot, input?.key ?? HOME_KEY, docked);
|
||||
const unavailableModel = config.some(
|
||||
@@ -194,8 +225,12 @@ export function HomeEditor({ docked = false, input }: { docked?: boolean; input?
|
||||
provider?.installed
|
||||
? {
|
||||
refreshing: requestingModels || (catalog?.refreshing ?? false),
|
||||
retryAtMs: catalog?.retryAtMs ?? null,
|
||||
error: catalog?.error ?? null,
|
||||
loadingSettings: unknownModelSettings && (requestingModels || (catalog?.refreshing ?? false)),
|
||||
retryAtMs:
|
||||
currentModelRequest || (!unknownModelSettings && !catalog?.error)
|
||||
? (catalog?.retryAtMs ?? null)
|
||||
: null,
|
||||
error: !requestingModels && currentModelRequest ? (catalog?.error ?? null) : null,
|
||||
onRefresh: () => void executeAction("agents.refreshModels"),
|
||||
}
|
||||
: undefined
|
||||
|
||||
@@ -39,7 +39,8 @@ vi.mock("@/platform/ipc", async (original) => ({
|
||||
return ok([]);
|
||||
},
|
||||
agentProviders: async () => ok(backend.providers),
|
||||
agentRefreshModels: (provider: string, force: boolean) => backend.refresh(provider, force),
|
||||
agentRefreshModels: (provider: string, force: boolean, model: string | null) =>
|
||||
backend.refresh(provider, force, model),
|
||||
agentProbe: async () => ok(null),
|
||||
agentCommands: async () => ok([]),
|
||||
vcsBranchInfo: async () => ok({ head: "main" }),
|
||||
@@ -85,7 +86,7 @@ const provider = (id: string): AgentProvider => ({
|
||||
commands: [],
|
||||
source: { kind: "custom" },
|
||||
config: [option("model", "model", ["big", "small"])],
|
||||
thoughtLevels: { big: [option("effort", "thought_level", ["low", "high"], "high")] },
|
||||
thoughtLevels: { big: [option("effort", "thought_level", ["low", "high"], "high")], small: [] },
|
||||
});
|
||||
function catalog(id = "first", patch: Partial<AgentModelCatalog> = {}): AgentModelCatalog {
|
||||
const offered = backend.providers.find((p) => p.id === id)!;
|
||||
@@ -155,6 +156,8 @@ it("keeps cached choices usable while refreshing and shares the completion/coold
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
expect(screen.getByRole("button", { name: /Refresh in \d+s/ })).toBeDisabled();
|
||||
expect(screen.getByRole("button", { name: "Model" })).toHaveTextContent("small");
|
||||
await act(async () => executeAction("agents.refreshModels"));
|
||||
expect(backend.refresh).toHaveBeenCalledTimes(1);
|
||||
fireEvent.click(screen.getByRole("button", { name: "Start" }));
|
||||
await waitFor(() => expect(backend.create).toHaveBeenCalled());
|
||||
expect(backend.create.mock.calls[0]![0].config).toEqual([{ id: "model", value: "small" }]);
|
||||
@@ -166,7 +169,7 @@ it("uses the same popup for model-only agents and coalesces repeated manual acti
|
||||
render(<HomeEditor />);
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
await screen.findByRole("button", { name: "Refresh models" });
|
||||
expect(backend.refresh).toHaveBeenCalledExactlyOnceWith("first", false);
|
||||
expect(backend.refresh).toHaveBeenCalledExactlyOnceWith("first", false, "big");
|
||||
const pending = deferred<CatalogReply>();
|
||||
backend.refresh.mockReturnValueOnce(pending.promise);
|
||||
fireEvent.click(screen.getByRole("button", { name: "Refresh models" }));
|
||||
@@ -176,7 +179,7 @@ it("uses the same popup for model-only agents and coalesces repeated manual acti
|
||||
await executeAction("agents.refreshModels");
|
||||
});
|
||||
expect(backend.refresh).toHaveBeenCalledTimes(2);
|
||||
expect(backend.refresh).toHaveBeenLastCalledWith("first", true);
|
||||
expect(backend.refresh).toHaveBeenLastCalledWith("first", true, "big");
|
||||
await act(async () => pending.resolve(ok(catalog("first", { refreshing: true }))));
|
||||
await act(async () => executeAction("agents.refreshModels"));
|
||||
expect(backend.refresh).toHaveBeenCalledTimes(2);
|
||||
@@ -201,7 +204,7 @@ it("shows initial loading and inline discovery failure/retry without blocking a
|
||||
expect(screen.getByText("No models reported by this agent.")).toBeVisible();
|
||||
expect(screen.getByRole("button", { name: "Refresh models" })).toBeEnabled();
|
||||
fireEvent.click(screen.getByRole("button", { name: "Refresh models" }));
|
||||
expect(backend.refresh).toHaveBeenLastCalledWith("first", true);
|
||||
expect(backend.refresh).toHaveBeenLastCalledWith("first", true, null);
|
||||
expect(screen.getByRole("button", { name: "Refreshing…" })).toBeDisabled();
|
||||
fireEvent.click(screen.getByRole("button", { name: "Start" }));
|
||||
await waitFor(() => expect(backend.create).toHaveBeenCalled());
|
||||
@@ -290,7 +293,7 @@ it("ignores a delayed refresh after switching agents and preserves the new draft
|
||||
render(<HomeEditor />);
|
||||
fireEvent.click(screen.getByRole("button", { name: "Agent" }));
|
||||
fireEvent.click(screen.getByRole("option", { name: "second" }));
|
||||
await waitFor(() => expect(backend.refresh).toHaveBeenLastCalledWith("second", false));
|
||||
await waitFor(() => expect(backend.refresh).toHaveBeenLastCalledWith("second", false, "big"));
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
fireEvent.click(screen.getByRole("option", { name: "small" }));
|
||||
await act(async () => pending.resolve(ok(catalog("first", { config: [option("model", "model", ["obsolete"])] }))));
|
||||
@@ -321,7 +324,7 @@ it("does not let a delayed command snapshot replace a newer catalog event", asyn
|
||||
const pending = deferred<CatalogReply>();
|
||||
backend.refresh.mockReturnValueOnce(pending.promise);
|
||||
render(<HomeEditor />);
|
||||
emit(catalog("first", { config: [option("model", "model", ["latest"])] }));
|
||||
emit(catalog("first", { config: [option("model", "model", ["latest"])], thoughtLevels: { latest: [] } }));
|
||||
await act(async () => pending.resolve(ok(catalog("first", { refreshing: true }))));
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
expect(screen.getByRole("option", { name: "latest" })).toBeVisible();
|
||||
@@ -349,3 +352,157 @@ it("requests freshness on focus without a retry timer, and counts down only the
|
||||
act(() => vi.advanceTimersByTime(60_000));
|
||||
expect(backend.refresh).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
it("discovers an uncached model's own settings before its first task and restores its draft choices", async () => {
|
||||
delete backend.providers[0]!.thoughtLevels!.small;
|
||||
await connect();
|
||||
render(<HomeEditor />);
|
||||
await waitFor(() => expect(useAgents.getState().modelRequests.size).toBe(0));
|
||||
const pending = deferred<CatalogReply>();
|
||||
backend.refresh.mockReturnValueOnce(pending.promise);
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
fireEvent.click(screen.getByRole("option", { name: "small" }));
|
||||
await waitFor(() => expect(backend.refresh).toHaveBeenLastCalledWith("first", false, "small"));
|
||||
expect(screen.getByText("Loading model settings…")).toHaveAttribute("role", "status");
|
||||
expect(screen.queryByRole("button", { name: "Reasoning" })).not.toBeInTheDocument();
|
||||
expect(backend.create).not.toHaveBeenCalled();
|
||||
await act(async () =>
|
||||
pending.resolve(
|
||||
ok(
|
||||
catalog("first", {
|
||||
thoughtLevels: {
|
||||
...catalog().thoughtLevels,
|
||||
small: [
|
||||
option("effort", "thought_level", ["minimal", "medium", "max"], "medium"),
|
||||
option("context_tier", "model_config", ["default", "long_context"]),
|
||||
],
|
||||
},
|
||||
}),
|
||||
),
|
||||
),
|
||||
);
|
||||
expect(screen.queryByText("Loading model settings…")).not.toBeInTheDocument();
|
||||
expect(screen.getByRole("button", { name: "Reasoning" })).toHaveTextContent("medium");
|
||||
fireEvent.click(screen.getByRole("button", { name: "Reasoning" }));
|
||||
fireEvent.click(screen.getByRole("option", { name: "max" }));
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
expect(screen.getByRole("radio", { name: "long_context" })).toBeVisible();
|
||||
fireEvent.click(screen.getByRole("radio", { name: "long_context" }));
|
||||
fireEvent.click(screen.getByRole("option", { name: "big" }));
|
||||
expect(screen.getByRole("button", { name: "Reasoning" })).toHaveTextContent("high");
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
fireEvent.click(screen.getByRole("option", { name: "small" }));
|
||||
expect(screen.getByRole("button", { name: "Reasoning" })).toHaveTextContent("max");
|
||||
expect(backend.refresh).toHaveBeenCalledTimes(2);
|
||||
fireEvent.click(screen.getByRole("button", { name: "Start" }));
|
||||
await waitFor(() => expect(backend.create).toHaveBeenCalled());
|
||||
expect(backend.create.mock.calls[0]![0].config).toEqual([
|
||||
{ id: "model", value: "small" },
|
||||
{ id: "effort", value: "max" },
|
||||
{ id: "context_tier", value: "long_context" },
|
||||
]);
|
||||
});
|
||||
|
||||
it("does not rediscover a model that explicitly reports no per-model controls", async () => {
|
||||
backend.providers[0]!.thoughtLevels!.small = [];
|
||||
await connect();
|
||||
render(<HomeEditor />);
|
||||
await waitFor(() => expect(useAgents.getState().modelRequests.size).toBe(0));
|
||||
for (const model of ["small", "big", "small"]) {
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
fireEvent.click(screen.getByRole("option", { name: model }));
|
||||
}
|
||||
expect(backend.refresh).toHaveBeenCalledExactlyOnceWith("first", false, "big");
|
||||
expect(screen.queryByText("Loading model settings…")).not.toBeInTheDocument();
|
||||
expect(screen.queryByRole("button", { name: "Reasoning" })).not.toBeInTheDocument();
|
||||
});
|
||||
|
||||
it("waits for an unrelated lookup and discovers only the latest selected model", async () => {
|
||||
backend.providers[0]!.config = [option("model", "model", ["big", "small", "latest"])];
|
||||
await connect();
|
||||
const pending = deferred<CatalogReply>();
|
||||
backend.refresh.mockReturnValueOnce(pending.promise);
|
||||
render(<HomeEditor />);
|
||||
for (const model of ["small", "latest"]) {
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
fireEvent.click(screen.getByRole("option", { name: model }));
|
||||
}
|
||||
expect(backend.refresh).toHaveBeenCalledTimes(1);
|
||||
const latest = deferred<CatalogReply>();
|
||||
backend.refresh.mockReturnValueOnce(latest.promise);
|
||||
await act(async () =>
|
||||
pending.resolve(ok(catalog("first", { retryAtMs: Date.now() + 30_000, error: "previous model failed" }))),
|
||||
);
|
||||
await waitFor(() => expect(backend.refresh).toHaveBeenLastCalledWith("first", false, "latest"));
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
expect(screen.queryByRole("alert")).not.toBeInTheDocument();
|
||||
fireEvent.keyDown(document, { key: "Escape" });
|
||||
await act(async () =>
|
||||
latest.resolve(
|
||||
ok(catalog("first", { thoughtLevels: { latest: [option("effort", "thought_level", ["medium", "max"])] } })),
|
||||
),
|
||||
);
|
||||
expect(screen.getByRole("button", { name: "Reasoning" })).toHaveTextContent("medium");
|
||||
expect(backend.refresh).toHaveBeenCalledTimes(2);
|
||||
expect(backend.create).not.toHaveBeenCalled();
|
||||
});
|
||||
|
||||
it("does not loop after an unknown-model failure and permits a manual retry after cooldown", async () => {
|
||||
delete backend.providers[0]!.thoughtLevels!.small;
|
||||
await connect();
|
||||
render(<HomeEditor />);
|
||||
await waitFor(() => expect(useAgents.getState().modelRequests.size).toBe(0));
|
||||
backend.refresh.mockResolvedValueOnce(
|
||||
ok(catalog("first", { retryAtMs: Date.now() + 30_000, error: "settings unavailable" })),
|
||||
);
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
fireEvent.click(screen.getByRole("option", { name: "small" }));
|
||||
await waitFor(() => expect(useAgents.getState().modelRequests.size).toBe(0));
|
||||
expect(backend.refresh).toHaveBeenCalledTimes(2);
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
expect(screen.getByRole("alert")).toHaveTextContent("settings unavailable");
|
||||
expect(screen.getByRole("button", { name: /Refresh in \d+s/ })).toBeDisabled();
|
||||
emit(catalog("first", { retryAtMs: Date.now() - 1, error: "settings unavailable" }));
|
||||
expect(backend.refresh).toHaveBeenCalledTimes(2);
|
||||
backend.refresh.mockResolvedValueOnce(ok(catalog("first", { thoughtLevels: { small: [] } })));
|
||||
fireEvent.click(screen.getByRole("button", { name: "Refresh models" }));
|
||||
await waitFor(() => expect(backend.refresh).toHaveBeenLastCalledWith("first", true, "small"));
|
||||
await waitFor(() => expect(screen.queryByRole("alert")).not.toBeInTheDocument());
|
||||
expect(backend.refresh).toHaveBeenCalledTimes(3);
|
||||
});
|
||||
|
||||
it("does not leak a delayed model's levels or failure into a newer selection", async () => {
|
||||
delete backend.providers[0]!.thoughtLevels!.small;
|
||||
await connect();
|
||||
useAgents.setState({
|
||||
draft: savedDraft({ provider: "first", config: { model: "big" }, thoughtLevels: { big: { effort: "low" } } }),
|
||||
});
|
||||
render(<HomeEditor />);
|
||||
await waitFor(() => expect(useAgents.getState().modelRequests.size).toBe(0));
|
||||
const pending = deferred<CatalogReply>();
|
||||
backend.refresh.mockReturnValueOnce(pending.promise);
|
||||
for (const model of ["small", "big"]) {
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
fireEvent.click(screen.getByRole("option", { name: model }));
|
||||
}
|
||||
await act(async () =>
|
||||
pending.resolve(
|
||||
ok(
|
||||
catalog("first", {
|
||||
thoughtLevels: {
|
||||
...catalog().thoughtLevels,
|
||||
small: [option("effort", "thought_level", ["minimal", "max"], "max")],
|
||||
},
|
||||
retryAtMs: Date.now() + 30_000,
|
||||
error: "small lookup failed",
|
||||
}),
|
||||
),
|
||||
),
|
||||
);
|
||||
expect(screen.getByRole("button", { name: "Model" })).toHaveTextContent("big");
|
||||
expect(screen.getByRole("button", { name: "Reasoning" })).toHaveTextContent("low");
|
||||
fireEvent.click(screen.getByRole("button", { name: "Model" }));
|
||||
expect(screen.queryByRole("alert")).not.toBeInTheDocument();
|
||||
expect(screen.getByRole("button", { name: "Refresh models" })).toBeEnabled();
|
||||
expect(backend.refresh).toHaveBeenCalledTimes(2);
|
||||
});
|
||||
|
||||
@@ -102,6 +102,8 @@ interface AgentsState {
|
||||
providers: AgentProvider[];
|
||||
modelCatalogs: Map<string, AgentModelCatalog>;
|
||||
modelRequests: Set<string>;
|
||||
/** Last New Task discovery target, so another model never inherits its error/cooldown. */
|
||||
modelRequestTargets: Map<string, string | null>;
|
||||
/** The usage limits each agent last reported for its account, by provider. */
|
||||
limits: Map<string, AgentLimit[]>;
|
||||
draft: Draft;
|
||||
@@ -187,6 +189,7 @@ export const useAgents = create<AgentsState>(() => ({
|
||||
limits: new Map(),
|
||||
modelCatalogs: new Map(),
|
||||
modelRequests: new Set(),
|
||||
modelRequestTargets: new Map(),
|
||||
draft: savedDraft(load<Partial<Draft>>(DRAFT_KEY, {})),
|
||||
composers: new Map(),
|
||||
lastComposer: HOME,
|
||||
@@ -391,18 +394,29 @@ function applyModelCatalog(catalog: AgentModelCatalog) {
|
||||
}
|
||||
|
||||
/** Refreshes only the New Task agent; discovery failures stay beside the cached choices. */
|
||||
export async function refreshModels(provider = selectedProvider()?.id, force = true): Promise<void> {
|
||||
export async function refreshModels(
|
||||
provider = selectedProvider()?.id,
|
||||
force = true,
|
||||
model?: string | null,
|
||||
): Promise<void> {
|
||||
const selected = selectedProvider();
|
||||
if (!provider || !selected?.installed || selected.id !== provider || useProject.getState().project?.trusted === false)
|
||||
return;
|
||||
const state = useAgents.getState();
|
||||
const catalog = state.modelCatalogs.get(provider);
|
||||
model ??= draftConfig(selected, state.draft).find((o) => o.category === "model")?.current ?? null;
|
||||
const missingModelSettings =
|
||||
model !== null && !Object.hasOwn(catalog?.thoughtLevels ?? selected.thoughtLevels ?? {}, model);
|
||||
const requestTarget = state.modelRequestTargets.get(provider);
|
||||
const launch = launchKey(selected);
|
||||
const pending = modelFlights.get(provider);
|
||||
if (
|
||||
(pending?.launch === launch && pending.generation === generation && pending.draftGeneration === draftGeneration) ||
|
||||
catalog?.refreshing ||
|
||||
(force && catalog?.retryAtMs != null && catalog.retryAtMs > Date.now())
|
||||
(force &&
|
||||
(requestTarget === undefined || requestTarget === model || (!missingModelSettings && !catalog?.error)) &&
|
||||
catalog?.retryAtMs != null &&
|
||||
catalog.retryAtMs > Date.now())
|
||||
)
|
||||
return;
|
||||
const gen = generation;
|
||||
@@ -410,7 +424,10 @@ export async function refreshModels(provider = selectedProvider()?.id, force = t
|
||||
const root = useProject.getState().project?.root;
|
||||
const flight = { launch, generation: gen, draftGeneration: draftGen };
|
||||
modelFlights.set(provider, flight);
|
||||
useAgents.setState((s) => ({ modelRequests: new Set(s.modelRequests).add(provider) }));
|
||||
useAgents.setState((s) => ({
|
||||
modelRequests: new Set(s.modelRequests).add(provider),
|
||||
modelRequestTargets: new Map(s.modelRequestTargets).set(provider, model),
|
||||
}));
|
||||
const current = () =>
|
||||
gen === generation &&
|
||||
root === useProject.getState().project?.root &&
|
||||
@@ -418,7 +435,7 @@ export async function refreshModels(provider = selectedProvider()?.id, force = t
|
||||
selectedProvider()?.id === provider &&
|
||||
launchKey(selectedProvider()!) === launch;
|
||||
try {
|
||||
const result = await call(commands.agentRefreshModels(provider, force));
|
||||
const result = await call(commands.agentRefreshModels(provider, force, model));
|
||||
// A streamed status/completion is newer than the snapshot returned by the command.
|
||||
if (current() && useAgents.getState().modelCatalogs.get(provider) === catalog) applyModelCatalog(result);
|
||||
} catch (e) {
|
||||
@@ -545,6 +562,7 @@ export function disconnect() {
|
||||
groupedChanges: new Map(),
|
||||
modelCatalogs: new Map(),
|
||||
modelRequests: new Set(),
|
||||
modelRequestTargets: new Map(),
|
||||
organize: EMPTY_ORGANIZE,
|
||||
organizeRoot: null,
|
||||
docked: null,
|
||||
@@ -785,12 +803,16 @@ export async function refreshProviders() {
|
||||
if (!providers || gen !== generation || root !== useProject.getState().project?.root) return;
|
||||
useAgents.setState((s) => {
|
||||
const modelCatalogs = new Map(s.modelCatalogs);
|
||||
const modelRequestTargets = new Map(s.modelRequestTargets);
|
||||
for (const [id] of modelCatalogs) {
|
||||
const previous = s.providers.find((p) => p.id === id);
|
||||
const provider = providers.find((p) => p.id === id);
|
||||
if (!provider || (previous && launchKey(previous) !== launchKey(provider))) modelCatalogs.delete(id);
|
||||
if (!provider || (previous && launchKey(previous) !== launchKey(provider))) {
|
||||
modelCatalogs.delete(id);
|
||||
modelRequestTargets.delete(id);
|
||||
}
|
||||
}
|
||||
return { providers, modelCatalogs };
|
||||
return { providers, modelCatalogs, modelRequestTargets };
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -75,6 +75,7 @@
|
||||
"Refreshing…": "Refreshing…",
|
||||
"Refresh in {seconds}s": "Refresh in {seconds}s",
|
||||
"Loading models…": "Loading models…",
|
||||
"Loading model settings…": "Loading model settings…",
|
||||
"No models reported by this agent.": "No models reported by this agent.",
|
||||
"Could not refresh models: {detail}": "Could not refresh models: {detail}",
|
||||
"{model} (unavailable)": "{model} (unavailable)",
|
||||
|
||||
@@ -66,6 +66,7 @@
|
||||
"Refreshing…": "正在刷新…",
|
||||
"Refresh in {seconds}s": "{seconds} 秒后可刷新",
|
||||
"Loading models…": "正在加载模型…",
|
||||
"Loading model settings…": "正在加载模型设置…",
|
||||
"No models reported by this agent.": "此 Agent 未提供模型。",
|
||||
"Could not refresh models: {detail}": "无法刷新模型:{detail}",
|
||||
"{model} (unavailable)": "{model}(不可用)",
|
||||
|
||||
Reference in New Issue
Block a user