mirror of
https://github.com/l0ng-ai/openidea.git
synced 2026-11-21 11:49:57 -10:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
f041f7e763 |
No files matched your search
@@ -56,6 +56,16 @@ pub(crate) struct CatalogData {
|
||||
pub refreshed_at_ms: Option<f64>,
|
||||
}
|
||||
|
||||
impl CatalogData {
|
||||
fn model_option(&self) -> Option<&AgentConfigOption> {
|
||||
self.config.iter().find(|o| o.category.as_deref() == Some("model"))
|
||||
}
|
||||
|
||||
fn lists(&self, model: &str) -> bool {
|
||||
self.model_option().is_some_and(|o| o.values.iter().any(|v| v.value == model))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Serialize, Deserialize)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub(crate) struct SavedCatalog {
|
||||
@@ -329,11 +339,17 @@ impl AgentCatalogs {
|
||||
Ok(found) => {
|
||||
let mut cache = shared.known.lock();
|
||||
let known = cache.entry(key.2.clone()).or_default();
|
||||
let catalog = CatalogData {
|
||||
let mut catalog = CatalogData {
|
||||
config: found.config,
|
||||
thought_levels: found.levels,
|
||||
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() {
|
||||
if catalog.lists(&model) && !catalog.thought_levels.contains_key(&model) {
|
||||
catalog.thought_levels.insert(model, levels);
|
||||
}
|
||||
}
|
||||
known.config = catalog.config.clone();
|
||||
known.thought_levels = catalog.thought_levels.clone();
|
||||
if let Some(commands) = found.commands {
|
||||
@@ -366,6 +382,42 @@ impl AgentCatalogs {
|
||||
}
|
||||
}
|
||||
|
||||
/// Records the efforts a session reported for a listed `model` other than the one discovery
|
||||
/// read: ACP discovery opens one session, so it knows only that model's efforts.
|
||||
pub(crate) fn learn_levels(&self, shared: &Shared, provider: &str, model: &str, levels: Vec<AgentConfigOption>) {
|
||||
let lacks = |catalog: &CatalogData| {
|
||||
catalog.lists(model)
|
||||
&& catalog.model_option().and_then(|o| o.current.as_deref()) != Some(model)
|
||||
&& catalog.thought_levels.get(model) != Some(&levels)
|
||||
};
|
||||
let key = Self::key(shared, provider);
|
||||
let mut state = self.state.lock();
|
||||
let mut learned = false;
|
||||
if let Some(catalog) = state.entries.get_mut(&key).and_then(|e| e.catalog.as_mut()).filter(|c| lacks(c)) {
|
||||
catalog.thought_levels.insert(model.to_owned(), levels.clone());
|
||||
learned = true;
|
||||
}
|
||||
let mut cache = shared.known.lock();
|
||||
if let Some(saved) = cache
|
||||
.get_mut(provider)
|
||||
.and_then(|known| known.catalogs.get_mut(&shared.root_key()))
|
||||
.filter(|saved| lacks(&saved.catalog))
|
||||
{
|
||||
saved.catalog.thought_levels.insert(model.to_owned(), levels);
|
||||
learned = true;
|
||||
}
|
||||
if !learned {
|
||||
return;
|
||||
}
|
||||
shared.persist_known(&cache);
|
||||
drop(cache);
|
||||
let snapshot = state.entries.get(&key).map(|entry| self.snapshot(shared, provider, entry));
|
||||
drop(state);
|
||||
if let Some(snapshot) = snapshot {
|
||||
self.broadcast(shared, &snapshot);
|
||||
}
|
||||
}
|
||||
|
||||
fn subscribers(&self, shared: &Shared) -> Vec<Arc<Shared>> {
|
||||
self.state
|
||||
.lock()
|
||||
|
||||
@@ -221,6 +221,42 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
|
||||
assert!(!tmp.path().join("store").exists(), "refresh never creates tasks");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
configure(tmp.path(), "one");
|
||||
let mut harness = Harness::new();
|
||||
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();
|
||||
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
|
||||
// "first" with other efforts, changes nothing.
|
||||
let second = config::options_of(&response(&["second"], &["off", "auto"]));
|
||||
manager.shared.remember(PROVIDER, Some(&second), None, Some("second"));
|
||||
manager.shared.remember(PROVIDER, Some(&config::options_of(&response(&["gone"], &["x"]))), None, Some("gone"));
|
||||
manager.shared.remember(PROVIDER, Some(&config::options_of(&response(&["first"], &["max"]))), None, Some("first"));
|
||||
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();
|
||||
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();
|
||||
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();
|
||||
harness.next().await.reply.send(Ok(response(&["first", "second"], &["medium"]))).unwrap();
|
||||
let fresh = completed(&mut events).await;
|
||||
assert_eq!(efforts(&fresh, "first"), ["medium"]);
|
||||
assert_eq!(efforts(&fresh, "second"), ["off", "auto"]);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
|
||||
@@ -224,6 +224,7 @@ impl Shared {
|
||||
commands: Option<&[AgentCommand]>,
|
||||
model: Option<&str>,
|
||||
) {
|
||||
let acp = self.spec(provider).is_some_and(|spec| spec.driver == provider::Driver::Acp);
|
||||
let mut cache = self.known.lock();
|
||||
let known = cache.entry(provider.to_owned()).or_default();
|
||||
let mut changed = false;
|
||||
@@ -245,6 +246,12 @@ impl Shared {
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
// Discovery reads one model's efforts; a session on another model reports that model's.
|
||||
let learned = model.filter(|_| acp && known.authoritative).zip(config).map(|(model, config)| {
|
||||
let levels: Vec<_> =
|
||||
config.iter().filter(|o| o.category.as_deref() == Some("thought_level")).cloned().collect();
|
||||
(model, levels)
|
||||
});
|
||||
if let Some(commands) = commands.filter(|c| !c.is_empty())
|
||||
&& known.commands.get(&self.root_key()).map(Vec::as_slice) != Some(commands)
|
||||
{
|
||||
@@ -255,6 +262,9 @@ impl Shared {
|
||||
self.persist_known(&cache);
|
||||
}
|
||||
drop(cache);
|
||||
if let Some((model, levels)) = learned.filter(|(_, levels)| !levels.is_empty()) {
|
||||
self.paths.catalogs.learn_levels(self, provider, model, levels);
|
||||
}
|
||||
if changed {
|
||||
self.emit(AgentEvent::Providers);
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user