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.lockindex 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.rsindex 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 providercx.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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.tomlindex 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 = trueopencode = { workspace = true, features = ["schemars"] }open_router = { workspace = true, features = ["schemars"] }+paths.workspace = truerand.workspace = truerelease_channel.workspace = trueschemars.workspace = truediff --git a/crates/language_models/src/provider/opencode.rs b/crates/language_models/src/provider/opencode.rsindex 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)