Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

opencode: Dynamic model fetching improvements (#64666)

Bennet Bo Fenner7fc2cf9b8400
diff --git a/Cargo.lock b/Cargo.lock
index 03a7ca31b9d..d5bef4eea95 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -9772,6 +9772,7 @@ dependencies = [
"openai_subscribed",
"opencode",
"parking_lot",
+ "paths",
"rand 0.9.4",
"release_channel",
"schemars 1.0.4",
diff --git a/crates/agent/src/tests/mod.rs b/crates/agent/src/tests/mod.rs
index fdd16eb3281..c93e11d031f 100644
--- a/crates/agent/src/tests/mod.rs
+++ b/crates/agent/src/tests/mod.rs
@@ -4197,9 +4197,11 @@ async fn test_building_request_with_pending_tools(cx: &mut TestAppContext) {
async fn test_agent_connection(cx: &mut TestAppContext) {
cx.update(settings::init);
let templates = Templates::new();
+ let fake_fs = fs::FakeFs::new(cx.background_executor.clone());
// Initialize language model system with test provider
cx.update(|cx| {
+ <dyn fs::Fs>::set_global(fake_fs.clone(), cx);
gpui_tokio::init(cx);
let http_client = FakeHttpClient::with_404_response();
@@ -4214,7 +4216,6 @@ async fn test_agent_connection(cx: &mut TestAppContext) {
cx.executor().forbid_parking();
// Create a project for new_thread
- let fake_fs = cx.update(|cx| fs::FakeFs::new(cx.background_executor().clone()));
fake_fs.insert_tree(path!("/test"), json!({})).await;
let project = Project::test(fake_fs.clone(), [Path::new("/test")], cx).await;
let cwd = PathList::new(&[Path::new("/test")]);
@@ -4950,6 +4951,7 @@ async fn setup(cx: &mut TestAppContext, model: TestModel) -> ThreadTest {
match model {
TestModel::Fake => {}
TestModel::Sonnet4 => {
+ <dyn fs::Fs>::set_global(fs.clone(), cx);
gpui_tokio::init(cx);
let http_client = ReqwestClient::user_agent("agent tests").unwrap();
cx.set_http_client(Arc::new(http_client));
diff --git a/crates/agent/src/tools/evals/edit_file.rs b/crates/agent/src/tools/evals/edit_file.rs
index 73e449fa3cd..124664fd39d 100644
--- a/crates/agent/src/tools/evals/edit_file.rs
+++ b/crates/agent/src/tools/evals/edit_file.rs
@@ -235,6 +235,7 @@ impl EditToolTest {
let fs = FakeFs::new(cx.executor());
cx.update(|cx| {
+ <dyn fs::Fs>::set_global(fs.clone(), cx);
let settings_store = SettingsStore::test(cx);
cx.set_global(settings_store);
SettingsStore::update_global(cx, |store: &mut SettingsStore, cx| {
diff --git a/crates/agent/src/tools/evals/terminal_tool.rs b/crates/agent/src/tools/evals/terminal_tool.rs
index 463a95975ae..03b6c3a07c2 100644
--- a/crates/agent/src/tools/evals/terminal_tool.rs
+++ b/crates/agent/src/tools/evals/terminal_tool.rs
@@ -154,6 +154,7 @@ impl TerminalToolTest {
cx.executor().allow_parking();
cx.update(|cx| {
+ <dyn fs::Fs>::set_global(fs::FakeFs::new(cx.background_executor().clone()), cx);
let settings_store = SettingsStore::test(cx);
cx.set_global(settings_store);
diff --git a/crates/agent/src/tools/evals/write_file.rs b/crates/agent/src/tools/evals/write_file.rs
index 739b251770a..4c471ab61af 100644
--- a/crates/agent/src/tools/evals/write_file.rs
+++ b/crates/agent/src/tools/evals/write_file.rs
@@ -77,6 +77,7 @@ impl WriteToolTest {
let fs = FakeFs::new(cx.executor());
cx.update(|cx| {
+ <dyn fs::Fs>::set_global(fs.clone(), cx);
let settings_store = SettingsStore::test(cx);
cx.set_global(settings_store);
SettingsStore::update_global(cx, |store: &mut SettingsStore, cx| {
diff --git a/crates/edit_prediction_cli/src/headless.rs b/crates/edit_prediction_cli/src/headless.rs
index b19c2612b28..0b62b1124eb 100644
--- a/crates/edit_prediction_cli/src/headless.rs
+++ b/crates/edit_prediction_cli/src/headless.rs
@@ -67,6 +67,7 @@ pub fn init(cx: &mut App) -> EpAppState {
let git_binary_path = None;
let fs = RealFs::new(git_binary_path, cx.background_executor().clone());
+ <dyn fs::Fs>::set_global(fs.clone(), cx);
let mut languages = LanguageRegistry::new(cx.background_executor().clone());
languages.set_language_server_download_dir(paths::languages_dir().clone());
diff --git a/crates/language_models/Cargo.toml b/crates/language_models/Cargo.toml
index ae6c7c5687a..552e9e296fc 100644
--- a/crates/language_models/Cargo.toml
+++ b/crates/language_models/Cargo.toml
@@ -57,6 +57,7 @@ open_ai = { workspace = true, features = ["schemars"] }
openai_subscribed.workspace = true
opencode = { workspace = true, features = ["schemars"] }
open_router = { workspace = true, features = ["schemars"] }
+paths.workspace = true
rand.workspace = true
release_channel.workspace = true
schemars.workspace = true
diff --git a/crates/language_models/src/provider/opencode.rs b/crates/language_models/src/provider/opencode.rs
index e4a472530ba..17c490e8242 100644
--- a/crates/language_models/src/provider/opencode.rs
+++ b/crates/language_models/src/provider/opencode.rs
@@ -3,8 +3,10 @@ use collections::{BTreeMap, HashMap};
use credentials_provider::CredentialsProvider;
use fs::Fs;
use futures::{AsyncReadExt, FutureExt, StreamExt, future::BoxFuture};
-use gpui::{App, AsyncApp, Context, Entity, SharedString, Task, TaskExt, Window};
-use http_client::{AsyncBody, CustomHeaders, HttpClient, Method, Request, RequestBuilderExt, http};
+use gpui::{
+ App, AsyncApp, BackgroundExecutor, Context, Entity, SharedString, Task, TaskExt, Window,
+};
+use http_client::{AsyncBody, CustomHeaders, HttpClient, Method, Request, http};
use language_model::{
ApiKeyState, AuthenticateError, EnvVar, IconOrSvg, InlineDescription, LanguageModel,
LanguageModelCompletionError, LanguageModelCompletionEvent, LanguageModelEffortLevel,
@@ -18,7 +20,11 @@ use serde::Deserialize;
pub use settings::OpenCodeApiProtocol;
pub use settings::OpenCodeAvailableModel as AvailableModel;
use settings::{Settings, SettingsStore, update_settings_file};
-use std::sync::{Arc, LazyLock};
+use std::{
+ path::{Path, PathBuf},
+ sync::{Arc, LazyLock},
+ time::{Duration, SystemTime},
+};
use ui::{
Banner, ButtonLink, ConfiguredApiCard, Divider, List, ListBulletItem, Severity, Switch,
SwitchLabelPosition, ToggleState, prelude::*,
@@ -73,6 +79,9 @@ static API_KEY_ENV_VAR: LazyLock<EnvVar> = env_var!(API_KEY_ENV_VAR_NAME);
const OPENCODE_SESSION_HEADER_NAME: &str = "x-opencode-session";
const RICH_MODEL_CATALOG_URL: &str = "https://models.opencode.ai/api.json";
const MODEL_CATALOG_RESPONSE_LIMIT_BYTES: u64 = 8 * 1024 * 1024;
+const MODEL_CATALOG_FETCH_TIMEOUT: Duration = Duration::from_secs(15);
+const MODEL_CATALOG_DISK_FRESHNESS: Duration = Duration::from_secs(5 * 60);
+const MODEL_CATALOG_REFRESH_INTERVAL: Duration = Duration::from_secs(60 * 60);
pub(crate) const RESERVED_HEADER_NAMES: &[&str] = &[OPENCODE_SESSION_HEADER_NAME];
#[derive(Default, Clone, Debug, PartialEq)]
@@ -96,6 +105,9 @@ pub struct State {
discovered_models: HashMap<OpenCodeSubscription, Vec<DiscoveredModel>>,
fetch_models_errors: HashMap<OpenCodeSubscription, SharedString>,
fetch_models_task: Option<Task<()>>,
+ refresh_models_task: Option<Task<()>>,
+ cache_path: PathBuf,
+ fs: Arc<dyn Fs>,
}
#[derive(Clone)]
@@ -114,6 +126,7 @@ impl State {
let credentials_provider = self.credentials_provider.clone();
let api_url = OpenCodeLanguageModelProvider::api_url(cx);
self.fetch_models_task = None;
+ self.refresh_models_task = None;
self.discovered_models.clear();
self.fetch_models_errors.clear();
let task = self.api_key_state.store(
@@ -155,51 +168,153 @@ impl State {
fn restart_fetch_models_task(&mut self, cx: &mut Context<Self>) {
self.fetch_models_task = None;
- self.discovered_models.clear();
- self.fetch_models_errors.clear();
+ self.refresh_models_task = None;
let api_url = OpenCodeLanguageModelProvider::api_url(cx);
- let custom_headers = OpenCodeLanguageModelProvider::settings(cx)
- .custom_headers
- .clone();
- let Some(api_key) = self.api_key_state.key(&api_url) else {
+ if self.api_key_state.key(&api_url).is_none() {
self.fetch_models_task = None;
cx.notify();
return;
- };
+ }
let http_client = self.http_client.clone();
+ let fs = self.fs.clone();
+ let cache_path = self.cache_path.clone();
+ let executor = cx.background_executor().clone();
self.fetch_models_task = Some(cx.spawn(async move |this, cx| {
- let mut discovered_models = HashMap::default();
- let mut fetch_models_errors = HashMap::default();
- for subscription in [OpenCodeSubscription::Zen, OpenCodeSubscription::Go] {
- match fetch_discovered_models(
- http_client.clone(),
- &api_url,
- subscription,
- &api_key,
- &custom_headers,
- )
- .await
- {
- Ok(models) => {
- discovered_models.insert(subscription, models);
- }
- Err(error) => {
- log::warn!(
- "Failed to fetch OpenCode {} models: {error:#}",
- subscription.display_name()
- );
- fetch_models_errors.insert(subscription, format!("{error:#}").into());
- }
- }
+ let cached_catalog = load_cached_catalog(fs.as_ref(), &cache_path).await;
+ if let Ok(Some((catalog, _))) = &cached_catalog {
+ let results = catalog_results(Ok(catalog));
+ this.update(cx, |this, cx| {
+ apply_discovery_results(
+ &mut this.discovered_models,
+ &mut this.fetch_models_errors,
+ results,
+ );
+ cx.notify();
+ })
+ .ok();
+ }
+
+ if cached_catalog
+ .as_ref()
+ .ok()
+ .and_then(|catalog| catalog.as_ref())
+ .is_some_and(|(_, is_fresh)| *is_fresh)
+ {
+ this.update(cx, |this, _| this.fetch_models_task = None)
+ .ok();
+ return;
+ }
+
+ let catalog = fetch_model_catalog(http_client, executor).await;
+ let results = catalog_results(catalog.as_ref().map(String::as_str));
+ if results.iter().all(|(_, result)| result.is_ok())
+ && let Ok(catalog) = catalog
+ && let Err(error) = store_cached_catalog(fs.as_ref(), cache_path, catalog).await
+ {
+ log::warn!("Failed to cache OpenCode model catalog: {error:#}");
}
this.update(cx, |this, cx| {
- this.discovered_models = discovered_models;
- this.fetch_models_errors = fetch_models_errors;
+ apply_discovery_results(
+ &mut this.discovered_models,
+ &mut this.fetch_models_errors,
+ results,
+ );
this.fetch_models_task = None;
cx.notify();
})
.ok();
}));
+
+ let http_client = self.http_client.clone();
+ let fs = self.fs.clone();
+ let cache_path = self.cache_path.clone();
+ let executor = cx.background_executor().clone();
+ self.refresh_models_task = Some(cx.spawn(async move |this, cx| {
+ loop {
+ executor.timer(MODEL_CATALOG_REFRESH_INTERVAL).await;
+ let catalog = fetch_model_catalog(http_client.clone(), executor.clone()).await;
+ let results = catalog_results(catalog.as_ref().map(String::as_str));
+ if results.iter().all(|(_, result)| result.is_ok())
+ && let Ok(catalog) = catalog
+ && let Err(error) =
+ store_cached_catalog(fs.as_ref(), cache_path.clone(), catalog).await
+ {
+ log::warn!("Failed to cache OpenCode model catalog: {error:#}");
+ }
+ if this
+ .update(cx, |this, cx| {
+ apply_discovery_results(
+ &mut this.discovered_models,
+ &mut this.fetch_models_errors,
+ results,
+ );
+ cx.notify();
+ })
+ .is_err()
+ {
+ break;
+ }
+ }
+ }));
+ }
+}
+
+fn catalog_results(
+ catalog: Result<&str, &anyhow::Error>,
+) -> [(OpenCodeSubscription, Result<Vec<DiscoveredModel>>); 2] {
+ [OpenCodeSubscription::Zen, OpenCodeSubscription::Go].map(|subscription| {
+ let result = catalog
+ .map_err(|error| anyhow!("{error:#}"))
+ .and_then(|catalog| parse_discovered_models(catalog, subscription));
+ if let Err(error) = &result {
+ log::warn!(
+ "Failed to fetch OpenCode {} models: {error:#}",
+ subscription.display_name()
+ );
+ }
+ (subscription, result)
+ })
+}
+
+async fn load_cached_catalog(fs: &dyn Fs, path: &Path) -> Result<Option<(String, bool)>> {
+ let Some(metadata) = fs.metadata(path).await? else {
+ return Ok(None);
+ };
+ let catalog = fs.load(path).await?;
+ for subscription in [OpenCodeSubscription::Zen, OpenCodeSubscription::Go] {
+ parse_discovered_models(&catalog, subscription)?;
+ }
+ let is_fresh = SystemTime::now()
+ .duration_since(metadata.mtime.timestamp_for_user())
+ .is_ok_and(|age| age < MODEL_CATALOG_DISK_FRESHNESS);
+ Ok(Some((catalog, is_fresh)))
+}
+
+async fn store_cached_catalog(fs: &dyn Fs, path: PathBuf, catalog: String) -> Result<()> {
+ let mut catalog = serde_json::from_str::<serde_json::Map<String, serde_json::Value>>(&catalog)?;
+ catalog.retain(|provider, _| matches!(provider.as_str(), "opencode" | "opencode-go"));
+ if let Some(parent) = path.parent() {
+ fs.create_dir(parent).await?;
+ }
+ fs.atomic_write(path, serde_json::to_string(&catalog)?)
+ .await
+}
+
+fn apply_discovery_results(
+ discovered_models: &mut HashMap<OpenCodeSubscription, Vec<DiscoveredModel>>,
+ fetch_models_errors: &mut HashMap<OpenCodeSubscription, SharedString>,
+ results: [(OpenCodeSubscription, Result<Vec<DiscoveredModel>>); 2],
+) {
+ for (subscription, result) in results {
+ match result {
+ Ok(models) => {
+ discovered_models.insert(subscription, models);
+ fetch_models_errors.remove(&subscription);
+ }
+ Err(error) => {
+ fetch_models_errors.insert(subscription, format!("{error:#}").into());
+ }
+ }
}
}
@@ -208,24 +323,35 @@ impl OpenCodeLanguageModelProvider {
http_client: Arc<dyn HttpClient>,
credentials_provider: Arc<dyn CredentialsProvider>,
cx: &mut App,
+ ) -> Self {
+ Self::new_with_cache(
+ http_client,
+ credentials_provider,
+ <dyn Fs>::global(cx),
+ paths::temp_dir().join("opencode").join("models.json"),
+ cx,
+ )
+ }
+
+ fn new_with_cache(
+ http_client: Arc<dyn HttpClient>,
+ credentials_provider: Arc<dyn CredentialsProvider>,
+ fs: Arc<dyn Fs>,
+ cache_path: PathBuf,
+ cx: &mut App,
) -> Self {
let state = cx.new(|cx| {
cx.observe_global::<SettingsStore>({
let mut last_api_url = Self::api_url(cx);
- let mut last_custom_headers = Self::settings(cx).custom_headers.clone();
move |this: &mut State, cx| {
let api_url = Self::api_url(cx);
- let custom_headers = Self::settings(cx).custom_headers.clone();
if api_url != last_api_url {
last_api_url = api_url;
- last_custom_headers = custom_headers;
this.discovered_models.clear();
this.fetch_models_errors.clear();
this.fetch_models_task = None;
+ this.refresh_models_task = None;
this.authenticate(cx).detach();
- } else if custom_headers != last_custom_headers {
- last_custom_headers = custom_headers;
- this.restart_fetch_models_task(cx);
}
cx.notify();
}
@@ -238,6 +364,9 @@ impl OpenCodeLanguageModelProvider {
discovered_models: HashMap::default(),
fetch_models_errors: HashMap::default(),
fetch_models_task: None,
+ refresh_models_task: None,
+ cache_path,
+ fs,
}
});
@@ -682,7 +811,19 @@ impl LanguageModel for OpenCodeLanguageModel {
if levels.is_empty() {
return Vec::new();
}
- let default_index = levels.len() - 1;
+ let default_index = if levels.contains(&ReasoningEffort::Max) {
+ [
+ ReasoningEffort::High,
+ ReasoningEffort::Medium,
+ ReasoningEffort::Low,
+ ReasoningEffort::Minimal,
+ ]
+ .into_iter()
+ .find_map(|effort| levels.iter().position(|level| *level == effort))
+ .unwrap_or(levels.len() - 1)
+ } else {
+ levels.len() - 1
+ };
levels
.into_iter()
.enumerate()
@@ -869,16 +1010,6 @@ impl LanguageModel for OpenCodeLanguageModel {
}
}
-#[derive(Deserialize)]
-struct AvailableModelsResponse {
- data: Vec<AvailableModelResponse>,
-}
-
-#[derive(Deserialize)]
-struct AvailableModelResponse {
- id: String,
-}
-
#[derive(Deserialize)]
struct RichCatalogProvider {
npm: Option<String>,
@@ -902,6 +1033,7 @@ struct RichCatalogModel {
limit: ModelLimits,
provider: Option<ModelTransport>,
cost: Option<ModelCost>,
+ status: Option<String>,
}
#[derive(Deserialize)]
@@ -938,11 +1070,9 @@ struct ReasoningOption {
}
fn parse_discovered_models(
- available_models: &str,
rich_catalog: &str,
subscription: OpenCodeSubscription,
) -> Result<Vec<DiscoveredModel>> {
- let available_models = serde_json::from_str::<AvailableModelsResponse>(available_models)?;
let provider_key = match subscription {
OpenCodeSubscription::Zen => "opencode",
OpenCodeSubscription::Go => "opencode-go",
@@ -953,22 +1083,22 @@ fn parse_discovered_models(
.cloned()
.ok_or_else(|| anyhow!("OpenCode catalog is missing {provider_key}"))?;
let provider = serde_json::from_value::<RichCatalogProvider>(provider)?;
- let mut available_model_count = available_models.data.len();
- let models = available_models
- .data
+ let mut compatible_candidate_count = provider.models.len();
+ let models = provider
+ .models
.into_iter()
- .filter_map(|available| {
- let metadata = provider.models.get(&available.id)?;
- if subscription == OpenCodeSubscription::Zen
- && metadata
- .cost
- .as_ref()
- .is_some_and(|cost| cost.input == Some(0.0) && cost.output == Some(0.0))
+ .filter_map(|(catalog_id, metadata)| {
+ if metadata.status.as_deref() == Some("deprecated")
+ || (subscription == OpenCodeSubscription::Zen
+ && metadata
+ .cost
+ .as_ref()
+ .is_some_and(|cost| cost.input == Some(0.0) && cost.output == Some(0.0)))
{
- available_model_count -= 1;
+ compatible_candidate_count -= 1;
return None;
}
- if metadata.id != available.id
+ if metadata.id != catalog_id
|| !metadata.tool_call
|| !metadata
.modalities
@@ -1021,7 +1151,7 @@ fn parse_discovered_models(
})
})
.collect::<Vec<_>>();
- if available_model_count > 0 && models.is_empty() {
+ if compatible_candidate_count > 0 && models.is_empty() {
bail!("OpenCode model metadata did not contain any compatible models");
}
Ok(models)
@@ -1037,43 +1167,22 @@ fn protocol_for_transport(transport: &str) -> Option<ApiProtocol> {
}
}
-async fn fetch_discovered_models(
+async fn fetch_model_catalog(
client: Arc<dyn HttpClient>,
- api_url: &str,
- subscription: OpenCodeSubscription,
- api_key: &str,
- custom_headers: &CustomHeaders,
-) -> Result<Vec<DiscoveredModel>> {
- let models_url = format!(
- "{}{}/v1/models",
- api_url.trim_end_matches('/'),
- subscription.api_path_suffix()
- );
- let available_models =
- fetch_catalog_resource(client.as_ref(), &models_url, Some(api_key), custom_headers).await?;
- let rich_catalog = fetch_catalog_resource(
- client.as_ref(),
- RICH_MODEL_CATALOG_URL,
- None,
- &CustomHeaders::default(),
- )
- .await?;
- parse_discovered_models(&available_models, &rich_catalog, subscription)
-}
-
-async fn fetch_catalog_resource(
- client: &dyn HttpClient,
- url: &str,
- api_key: Option<&str>,
- custom_headers: &CustomHeaders,
+ executor: BackgroundExecutor,
) -> Result<String> {
- let mut request = Request::builder()
- .method(Method::GET)
- .uri(url)
- .extra_headers(custom_headers);
- if let Some(api_key) = api_key {
- request = request.header(http::header::AUTHORIZATION, format!("Bearer {api_key}"));
+ let fetch = fetch_catalog_resource(client.as_ref(), RICH_MODEL_CATALOG_URL).fuse();
+ let timeout = executor.timer(MODEL_CATALOG_FETCH_TIMEOUT).fuse();
+ futures::pin_mut!(fetch, timeout);
+ futures::select_biased! {
+ result = fetch => result,
+ _ = timeout => bail!("OpenCode model catalog request timed out"),
}
+}
+
+async fn fetch_catalog_resource(client: &dyn HttpClient, url: &str) -> Result<String> {
+ // Catalogs are public; completion credentials and custom headers must not be sent here.
+ let request = Request::builder().method(Method::GET).uri(url);
let mut response = client
.send(request.body(AsyncBody::empty())?)
.await
@@ -1329,76 +1438,168 @@ impl Render for ConfigurationView {
#[cfg(test)]
mod tests {
use super::*;
+ use fs::FakeFs;
use http_client::{FakeHttpClient, Response};
use language_model::{LanguageModelRequestMessage, MessageContent, Role};
use parking_lot::Mutex;
+ fn test_catalog() -> &'static str {
+ r#"{
+ "opencode": {
+ "npm": "@ai-sdk/anthropic",
+ "models": {
+ "zen-model": {
+ "id": "zen-model",
+ "name": "Zen Model",
+ "tool_call": true,
+ "modalities": {"input":["text"],"output":["text"]},
+ "limit": {"context": 12345}
+ }
+ }
+ },
+ "opencode-go": {
+ "npm": "@ai-sdk/openai-compatible",
+ "models": {
+ "go-model": {
+ "id": "go-model",
+ "name": "Go Model",
+ "tool_call": true,
+ "modalities": {"input":["text"],"output":["text"]},
+ "limit": {"context": 12345}
+ }
+ }
+ }
+ }"#
+ }
+
#[gpui::test]
- async fn test_discovery_authenticates_and_applies_custom_headers() {
- let requests = Arc::new(Mutex::new(Vec::new()));
- let http_client = FakeHttpClient::create({
- let requests = requests.clone();
- move |request| {
+ async fn test_disk_cache_and_hourly_refresh(cx: &mut gpui::TestAppContext) {
+ for (cached, stale, fail, initial_requests) in [
+ (Some(test_catalog()), false, false, 0),
+ (Some("not json"), false, false, 1),
+ (Some(test_catalog()), true, true, 1),
+ (None, false, false, 1),
+ ] {
+ let fs = FakeFs::new(cx.background_executor.clone());
+ let cache_path = PathBuf::from("/cache/opencode/models.json");
+ if let Some(cached) = cached {
+ fs.create_dir(Path::new("/cache/opencode")).await.unwrap();
+ fs.set_next_mtime(if stale {
+ SystemTime::now() - MODEL_CATALOG_REFRESH_INTERVAL
+ } else {
+ SystemTime::now() - Duration::from_secs(1)
+ });
+ fs.atomic_write(cache_path.clone(), cached.to_string())
+ .await
+ .unwrap();
+ }
+ let requests = Arc::new(Mutex::new(0));
+ let fail_request = Arc::new(Mutex::new(fail));
+ let client = FakeHttpClient::create({
let requests = requests.clone();
- async move {
- let uri = request.uri().to_string();
- requests.lock().push((
- uri.clone(),
- request.headers().get(http::header::AUTHORIZATION).cloned(),
- request.headers().get("x-test-header").cloned(),
- ));
- let body = if uri == RICH_MODEL_CATALOG_URL {
- r#"{
- "opencode": {
- "npm": "@ai-sdk/anthropic",
- "models": {
- "new-model": {
- "id": "new-model",
- "name": "New Model",
- "tool_call": true,
- "modalities": {"input":["text"],"output":["text"]},
- "limit": {"context": 12345}
- }
- }
- }
- }"#
- } else {
- r#"{"data":[{"id":"new-model"}]}"#
- };
- Ok(Response::builder()
- .status(200)
- .body(AsyncBody::from(body))?)
+ let fail_request = fail_request.clone();
+ move |_| {
+ *requests.lock() += 1;
+ let status = if *fail_request.lock() { 503 } else { 200 };
+ async move {
+ Ok(Response::builder().status(status).body(AsyncBody::from(
+ test_catalog().replace("zen-model", "updated-model"),
+ ))?)
+ }
}
+ });
+ let provider = cx.update(|cx| {
+ let settings_store = SettingsStore::test(cx);
+ cx.set_global(settings_store);
+ OpenCodeLanguageModelProvider::new_with_cache(
+ client,
+ Arc::new(TestCredentialsProvider),
+ fs.clone(),
+ cache_path.clone(),
+ cx,
+ )
+ });
+ provider
+ .state
+ .update(cx, |state, cx| {
+ state.set_api_key(Some("secret".to_string()), cx)
+ })
+ .await
+ .unwrap();
+ cx.run_until_parked();
+ assert_eq!(*requests.lock(), initial_requests);
+ let expected = if initial_requests == 0 || fail {
+ "zen-model"
+ } else {
+ "updated-model"
+ };
+ provider.state.read_with(cx, |state, _cx| {
+ assert_eq!(
+ state.discovered_models[&OpenCodeSubscription::Zen][0]
+ .model
+ .id(),
+ expected,
+ );
+ });
+ if fail {
+ assert_eq!(fs.load(&cache_path).await.unwrap(), test_catalog());
}
- });
- let custom_headers = CustomHeaders::new(vec![(
- http::HeaderName::from_static("x-test-header"),
- http::HeaderValue::from_static("configured"),
- )]);
- let models = fetch_discovered_models(
- http_client,
- "https://api.example.test",
- OpenCodeSubscription::Zen,
- "secret",
- &custom_headers,
- )
- .await
- .unwrap();
+ *fail_request.lock() = false;
+ cx.background_executor
+ .advance_clock(MODEL_CATALOG_REFRESH_INTERVAL);
+ cx.run_until_parked();
+ assert_eq!(*requests.lock(), initial_requests + 1);
+ provider.state.read_with(cx, |state, _cx| {
+ assert_eq!(
+ state.discovered_models[&OpenCodeSubscription::Zen][0]
+ .model
+ .id(),
+ "updated-model",
+ );
+ assert!(state.fetch_models_errors.is_empty());
+ });
+ assert_eq!(
+ serde_json::from_str::<serde_json::Value>(&fs.load(&cache_path).await.unwrap())
+ .unwrap(),
+ serde_json::from_str::<serde_json::Value>(
+ &test_catalog().replace("zen-model", "updated-model")
+ )
+ .unwrap(),
+ );
+ drop(provider);
+ cx.run_until_parked();
+ }
+ }
- assert_eq!(models.len(), 1);
- let requests = requests.lock();
- assert_eq!(requests.len(), 2);
- assert_eq!(
- requests[0].1.as_ref().and_then(|value| value.to_str().ok()),
- Some("Bearer secret")
- );
- assert_eq!(
- requests[0].2.as_ref().and_then(|value| value.to_str().ok()),
- Some("configured")
- );
- assert_eq!(requests[1].1, None);
- assert_eq!(requests[1].2, None);
+ #[gpui::test]
+ async fn test_fresh_disk_catalog_is_usable(cx: &mut gpui::TestAppContext) {
+ let fs = FakeFs::new(cx.background_executor.clone());
+ let cache_path = PathBuf::from("/cache/models.json");
+ fs.set_next_mtime(SystemTime::now());
+ fs.atomic_write(cache_path.clone(), test_catalog().to_string())
+ .await
+ .unwrap();
+
+ let (catalog, is_fresh) = load_cached_catalog(fs.as_ref(), &cache_path)
+ .await
+ .unwrap()
+ .unwrap();
+
+ assert!(is_fresh);
+ assert_eq!(catalog, test_catalog());
+ }
+
+ #[gpui::test]
+ async fn test_invalid_disk_catalog_falls_back_to_network(cx: &mut gpui::TestAppContext) {
+ let fs = FakeFs::new(cx.background_executor.clone());
+ let cache_path = PathBuf::from("/cache/models.json");
+ fs.atomic_write(cache_path.clone(), "not json".to_string())
+ .await
+ .unwrap();
+
+ assert!(load_cached_catalog(fs.as_ref(), &cache_path).await.is_err());
+ assert_eq!(fs.load(&cache_path).await.unwrap(), "not json");
}
#[gpui::test]
@@ -1408,9 +1609,11 @@ mod tests {
let provider = cx.update(|cx| {
let settings_store = SettingsStore::test(cx);
cx.set_global(settings_store);
- OpenCodeLanguageModelProvider::new(
+ OpenCodeLanguageModelProvider::new_with_cache(
FakeHttpClient::with_404_response(),
Arc::new(TestCredentialsProvider),
+ FakeFs::new(cx.background_executor().clone()),
+ PathBuf::from("/cache/models.json"),
cx,
)
});
@@ -1442,6 +1645,105 @@ mod tests {
store_task.await.unwrap();
}
+ #[test]
+ fn test_refresh_failure_preserves_last_success_per_subscription() {
+ let mut discovered_models = HashMap::default();
+ discovered_models.insert(
+ OpenCodeSubscription::Zen,
+ vec![DiscoveredModel {
+ model: test_model("old-zen", ApiProtocol::Anthropic),
+ supports_images: true,
+ supports_thinking: false,
+ }],
+ );
+ discovered_models.insert(
+ OpenCodeSubscription::Go,
+ vec![DiscoveredModel {
+ model: test_model("old-go", ApiProtocol::OpenAiChat),
+ supports_images: false,
+ supports_thinking: false,
+ }],
+ );
+ let mut errors = HashMap::default();
+ let new_go_model = DiscoveredModel {
+ model: test_model("new-go", ApiProtocol::OpenAiChat),
+ supports_images: true,
+ supports_thinking: true,
+ };
+
+ apply_discovery_results(
+ &mut discovered_models,
+ &mut errors,
+ [
+ (OpenCodeSubscription::Zen, Err(anyhow!("refresh failed"))),
+ (OpenCodeSubscription::Go, Ok(vec![new_go_model])),
+ ],
+ );
+
+ assert_eq!(
+ discovered_models[&OpenCodeSubscription::Zen][0].model.id(),
+ "old-zen"
+ );
+ assert_eq!(
+ discovered_models[&OpenCodeSubscription::Go][0].model.id(),
+ "new-go"
+ );
+ assert!(errors.contains_key(&OpenCodeSubscription::Zen));
+ assert!(!errors.contains_key(&OpenCodeSubscription::Go));
+ }
+
+ #[gpui::test]
+ fn test_default_reasoning_effort(cx: &mut gpui::TestAppContext) {
+ use ReasoningEffort::{High, Low, Max, Medium, Minimal, XHigh};
+
+ cx.update(|cx| {
+ let settings_store = SettingsStore::test(cx);
+ cx.set_global(settings_store);
+ let provider = OpenCodeLanguageModelProvider::new_with_cache(
+ FakeHttpClient::with_404_response(),
+ Arc::new(TestCredentialsProvider),
+ FakeFs::new(cx.background_executor().clone()),
+ PathBuf::from("/cache/models.json"),
+ cx,
+ );
+ for (levels, expected) in [
+ (vec![Low, Medium, High, XHigh, Max], Some("high")),
+ (vec![Max, High, Medium], Some("high")),
+ (vec![Low, Medium, Max], Some("medium")),
+ (vec![Minimal, Low, Max], Some("low")),
+ (vec![Minimal, Max], Some("minimal")),
+ (vec![Low, High, XHigh], Some("xhigh")),
+ (vec![High, Low], Some("low")),
+ (vec![Max], Some("max")),
+ (vec![ReasoningEffort::None], None),
+ (vec![], None),
+ ] {
+ let model = provider.create_language_model_with_capabilities(
+ opencode::Model::new(
+ "test-model".to_string(),
+ None,
+ 1000,
+ None,
+ ApiProtocol::OpenAiChat,
+ Some(levels),
+ None,
+ false,
+ ),
+ OpenCodeSubscription::Zen,
+ false,
+ true,
+ );
+ assert_eq!(
+ model
+ .default_effort_level()
+ .map(|effort| effort.value.to_string())
+ .as_deref(),
+ expected,
+ );
+ }
+ });
+ }
+
#[test]
fn test_none_only_reasoning_does_not_enable_thinking() {
let model = opencode::Model::new(
@@ -1492,11 +1794,7 @@ mod tests {
(OpenCodeSubscription::Zen, zen_model_count),
(OpenCodeSubscription::Go, 1),
] {
- let models = parse_discovered_models(
- r#"{"data":[{"id":"model"}]}"#,
- &catalog,
- subscription,
- )?;
+ let models = parse_discovered_models(&catalog, subscription)?;
assert_eq!(models.len(), expected_count, "{subscription:?}: {cost}");
}
}
@@ -1504,9 +1802,44 @@ mod tests {
}
#[test]
- fn test_parse_discovered_models_joins_subscription_and_metadata_catalogs() {
+ fn test_discovery_filters_deprecated_status_per_subscription() -> Result<()> {
+ for (zen_status, go_status, zen_count, go_count) in [
+ (Some("deprecated"), None, 0, 1),
+ (None, Some("deprecated"), 1, 0),
+ (Some("active"), Some("preview"), 1, 1),
+ (Some("deprecated"), Some("deprecated"), 0, 0),
+ ] {
+ let mut catalog = serde_json::json!({});
+ for (provider_key, status) in [("opencode", zen_status), ("opencode-go", go_status)] {
+ let mut model = serde_json::json!({
+ "id": "model",
+ "name": "Model",
+ "tool_call": true,
+ "modalities": {"output": ["text"]},
+ "limit": {"context": 1000},
+ });
+ if let Some(status) = status {
+ model["status"] = status.into();
+ }
+ catalog[provider_key] = serde_json::json!({
+ "npm": "@ai-sdk/openai-compatible",
+ "models": {"model": model},
+ });
+ }
+ for (subscription, expected_count) in [
+ (OpenCodeSubscription::Zen, zen_count),
+ (OpenCodeSubscription::Go, go_count),
+ ] {
+ let models = parse_discovered_models(&catalog.to_string(), subscription)?;
+ assert_eq!(models.len(), expected_count, "{subscription:?}: {catalog}",);
+ }
+ }
+ Ok(())
+ }
+
+ #[test]
+ fn test_parse_discovered_models_uses_catalog_entries_directly() {
let models = parse_discovered_models(
- r#"{"data":[{"id":"new-model"}]}"#,
r#"{
"opencode-go": {
"npm": "@ai-sdk/openai-compatible",
@@ -1545,7 +1878,6 @@ mod tests {
#[test]
fn test_parse_discovered_models_rejects_catalog_without_compatible_models() {
let result = parse_discovered_models(
- r#"{"data":[{"id":"text-only"}]}"#,
r#"{
"opencode": {
"npm": "@ai-sdk/anthropic",
@@ -1615,7 +1947,13 @@ mod tests {
let provider = cx.update(|cx| {
let settings_store = SettingsStore::test(cx);
cx.set_global(settings_store);
- OpenCodeLanguageModelProvider::new(http_client, Arc::new(TestCredentialsProvider), cx)
+ OpenCodeLanguageModelProvider::new_with_cache(
+ http_client,
+ Arc::new(TestCredentialsProvider),
+ FakeFs::new(cx.background_executor().clone()),
+ PathBuf::from("/cache/models.json"),
+ cx,
+ )
});
let store_key = provider.state.update(cx, |state, cx| {
state.set_api_key(Some("test-key".to_string()), cx)