Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
openai_subscribed: Discover account-specific models (#62651)
Anant Goel3cf86bed1b32
diff --git a/crates/language_models/src/provider/openai_subscribed.rs b/crates/language_models/src/provider/openai_subscribed.rsindex 30c189dbd5a..8b645ea240d 100644--- a/crates/language_models/src/provider/openai_subscribed.rs+++ b/crates/language_models/src/provider/openai_subscribed.rs@@ -1,4 +1,4 @@-use anyhow::Result;+use anyhow::{Result, anyhow};use credentials_provider::CredentialsProvider;use futures::future::Shared;use gpui::{App, Context, Entity, SharedString, Task, Window};@@ -8,7 +8,8 @@ use language_model::{LanguageModelProvider, LanguageModelProviderId, LanguageModelProviderName,LanguageModelProviderState, ProviderSettingsView,};-use openai_subscribed::{ChatGptModel, PROVIDER_ID, PROVIDER_NAME, State, create_language_model};+use openai_subscribed::{PROVIDER_ID, PROVIDER_NAME, State, create_language_model};+use release_channel::AppVersion;use std::sync::Arc;use ui::{ConfiguredApiCard, prelude::*};@@ -25,7 +26,15 @@ impl OpenAiSubscribedProvider {credentials_provider: Arc<dyn CredentialsProvider>,cx: &mut App,) -> Self {- let state = cx.new(|cx| State::new(http_client, credentials_provider, cx));+ let app_version = AppVersion::global(cx);+ let client_version = format!(+ "{}.{}.{}",+ app_version.major, app_version.minor, app_version.patch+ )+ .into();+ let state = cx.new(|cx| {+ State::new_with_client_version(http_client, credentials_provider, client_version, cx)+ });Self { state }}}@@ -52,34 +61,31 @@ impl LanguageModelProvider for OpenAiSubscribedProvider {}fn default_model(&self, cx: &App) -> Option<Arc<dyn LanguageModel>> {- Some(create_language_model(- ChatGptModel::Gpt56Sol,- &self.state,- cx,- ))+ self.state+ .read(cx)+ .default_model()+ .map(|model| create_language_model(model, &self.state, cx))}fn default_fast_model(&self, cx: &App) -> Option<Arc<dyn LanguageModel>> {- Some(create_language_model(- ChatGptModel::Gpt56Luna,- &self.state,- cx,- ))+ self.state+ .read(cx)+ .default_fast_model()+ .map(|model| create_language_model(model, &self.state, cx))}fn provided_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> {- ChatGptModel::all()- .into_iter()+ self.state+ .read(cx)+ .available_models()+ .iter()+ .cloned().map(|model| create_language_model(model, &self.state, cx)).collect()}fn recommended_models(&self, cx: &App) -> Vec<Arc<dyn LanguageModel>> {- vec![create_language_model(- ChatGptModel::Gpt56Sol,- &self.state,- cx,- )]+ self.default_model(cx).into_iter().collect()}fn is_authenticated(&self, cx: &App) -> bool {@@ -94,10 +100,12 @@ impl LanguageModelProvider for OpenAiSubscribedProvider {if let Some(load_task) = load_task {let weak_state = self.state.downgrade();cx.spawn(async move |cx| {- let _ = load_task.await;+ load_task+ .await+ .map_err(|error| AuthenticateError::Other(anyhow!("{error:#}")))?;let is_auth = weak_state.read_with(&*cx, |state, _| state.is_authenticated())- .unwrap_or(false);+ .map_err(AuthenticateError::Other)?;if is_auth {Ok(())} else {@@ -179,10 +187,12 @@ impl Render for ConfigurationView {.email().map(|e| format!("Signed in as {e}")).unwrap_or_else(|| "Signed in".to_string());+ let model_catalog_error = state.model_catalog_error();let state_entity = self.state.clone();return v_flex()+ .gap_2().child(ConfiguredApiCard::new("openai-subscribed-sign-out", SharedString::from(label)).button_label("Sign Out")@@ -192,6 +202,19 @@ impl Render for ConfigurationView {.detach_and_log_err(cx);})),)+ .when_some(model_catalog_error, |this, error| {+ this.child(+ h_flex()+ .gap_1()+ .justify_center()+ .child(+ Icon::new(IconName::XCircle)+ .color(Color::Error)+ .size(IconSize::Small),+ )+ .child(Label::new(error).color(Color::Muted)),+ )+ }).into_any_element();}@@ -265,7 +288,24 @@ mod tests {let http_client = FakeHttpClient::create(|_| async {Ok(http_client::Response::builder().status(200)- .body(http_client::AsyncBody::default())?)+ .body(http_client::AsyncBody::from(+ serde_json::json!({+ "models": [{+ "slug": "gpt-account-default",+ "display_name": "Account Default",+ "default_reasoning_level": "medium",+ "supported_reasoning_levels": [],+ "visibility": "list",+ "priority": 0,+ "additional_speed_tiers": [],+ "service_tiers": [],+ "context_window": 128_000,+ "max_context_window": null,+ "input_modalities": ["text"]+ }]+ })+ .to_string(),+ ))?)});let provider =@@ -282,6 +322,20 @@ mod tests {result.is_ok(),"authenticate should succeed after load completes with valid credentials");+ cx.update(|cx| {+ let models = provider.provided_models(cx);+ assert_eq!(models.len(), 1);+ assert_eq!(+ models.first().map(|model| model.id().0.to_string()),+ Some("gpt-account-default".to_string())+ );+ assert_eq!(+ provider+ .default_model(cx)+ .map(|model| model.id().0.to_string()),+ Some("gpt-account-default".to_string())+ );+ });}struct FakeCredentialsProvider {diff --git a/crates/openai_subscribed/src/openai_subscribed.rs b/crates/openai_subscribed/src/openai_subscribed.rsindex 7fbdc29fb3b..9e258637aaf 100644--- a/crates/openai_subscribed/src/openai_subscribed.rs+++ b/crates/openai_subscribed/src/openai_subscribed.rs@@ -5,7 +5,7 @@ use credentials_provider::CredentialsProvider;use futures::{FutureExt, StreamExt, future::BoxFuture, future::Shared};use gpui::{App, AsyncApp, Context, Entity, SharedString, Task, WeakEntity};use http_client::{- AsyncBody, CustomHeaders, HttpClient, Method, Request as HttpRequest,+ AsyncBody, CustomHeaders, HttpClient, Method, Request as HttpRequest, RequestBuilderExt as _,http::{HeaderName, HeaderValue},};use language_model::{@@ -21,7 +21,7 @@ use rand::RngCore as _;use serde::{Deserialize, Serialize};use sha2::{Digest, Sha256};use std::sync::Arc;-use std::time::{SystemTime, UNIX_EPOCH};+use std::time::{Duration, SystemTime, UNIX_EPOCH};use url::form_urlencoded;use util::ResultExt as _;@@ -38,6 +38,8 @@ const CLIENT_ID: &str = "app_EMoamEEZ73f0CkXaXp7hrann";const CREDENTIALS_KEY: &str = "https://chatgpt.com/backend-api/codex";const TOKEN_REFRESH_BUFFER_MS: u64 = 5 * 60 * 1000;+// Codex applies the same bound because model discovery is a startup-critical request.+const MODEL_CATALOG_REQUEST_TIMEOUT: Duration = Duration::from_secs(5);#[derive(Serialize, Deserialize, Clone, Debug)]struct CodexCredentials {@@ -62,8 +64,12 @@ pub struct State {load_task: Option<Shared<Task<Result<(), Arc<anyhow::Error>>>>>,credentials_provider: Arc<dyn CredentialsProvider>,http_client: Arc<dyn HttpClient>,+ client_version: SharedString,+ available_models: Vec<ChatGptModel>,auth_generation: u64,+ model_catalog_generation: u64,last_auth_error: Option<SharedString>,+ last_model_catalog_error: Option<SharedString>,}#[derive(Debug)]@@ -88,6 +94,16 @@ impl State {http_client: Arc<dyn HttpClient>,credentials_provider: Arc<dyn CredentialsProvider>,cx: &mut Context<Self>,+ ) -> Self {+ Self::new_with_client_version(http_client, credentials_provider, "0.0.0".into(), cx)+ }++ /// Creates the state with the client version reported during model discovery.+ pub fn new_with_client_version(+ http_client: Arc<dyn HttpClient>,+ credentials_provider: Arc<dyn CredentialsProvider>,+ client_version: SharedString,+ cx: &mut Context<Self>,) -> Self {let load_task = cx.spawn({@@ -96,17 +112,39 @@ impl State {let result = credentials_provider.read_credentials(CREDENTIALS_KEY, cx).await;- this.update(cx, |state, cx| {- if let Ok(Some((_, bytes))) = result {- match serde_json::from_slice::<CodexCredentials>(&bytes) {- Ok(creds) => state.credentials = Some(creds),- Err(err) => {- log::warn!(- "Failed to deserialize ChatGPT subscription credentials: {err}"- );+ let refresh_models_task = this.update(cx, |state, cx| {+ match result {+ Ok(Some((_, bytes))) => {+ match serde_json::from_slice::<CodexCredentials>(&bytes) {+ Ok(credentials) => {+ state.auth_generation =+ state.auth_generation.wrapping_add(1);+ state.credentials = Some(credentials);+ }+ Err(error) => {+ log::warn!(+ "Failed to deserialize ChatGPT subscription credentials: {error}"+ );+ }}}+ Ok(None) => {}+ Err(error) => {+ log::error!(+ "Failed to load ChatGPT subscription credentials: {error:#}"+ );+ }}+ state+ .is_authenticated()+ .then(|| state.refresh_model_catalog(cx))+ })?;+ if let Some(refresh_models_task) = refresh_models_task+ && let Err(error) = refresh_models_task.await+ {+ log::warn!("Failed to refresh ChatGPT models: {error:#}");+ }+ this.update(cx, |state, cx| {state.load_task = None;cx.notify();})?;@@ -122,8 +160,12 @@ impl State {load_task: Some(load_task),credentials_provider,http_client,+ client_version,+ available_models: ChatGptModel::all(),auth_generation: 0,+ model_catalog_generation: 0,last_auth_error: None,+ last_model_catalog_error: None,}}@@ -143,12 +185,91 @@ impl State {self.last_auth_error.clone()}+ pub fn model_catalog_error(&self) -> Option<SharedString> {+ self.last_model_catalog_error.clone()+ }++ pub fn available_models(&self) -> &[ChatGptModel] {+ &self.available_models+ }++ pub fn default_model(&self) -> Option<ChatGptModel> {+ self.available_models.first().cloned()+ }++ pub fn default_fast_model(&self) -> Option<ChatGptModel> {+ self.available_models+ .iter()+ .find(|model| model.id() == "gpt-5.6-luna")+ .cloned()+ }+/// The in-flight task loading persisted credentials, or `None` once the/// initial load has finished.pub fn load_task(&self) -> Option<Shared<Task<Result<(), Arc<anyhow::Error>>>>> {self.load_task.clone()}+ fn refresh_model_catalog(+ &mut self,+ cx: &mut Context<Self>,+ ) -> Task<Result<(), Arc<anyhow::Error>>> {+ self.model_catalog_generation = self.model_catalog_generation.wrapping_add(1);+ let model_catalog_generation = self.model_catalog_generation;+ let http_client = self.http_client.clone();+ let client_version = self.client_version.clone();++ cx.spawn(async move |this, cx| {+ let result = async {+ let credentials = get_fresh_credentials(&this, &http_client, cx)+ .await+ .map_err(|error| anyhow!("{error}"))?;+ let request =+ list_models(http_client.as_ref(), &credentials, client_version.as_ref());+ let timeout = cx+ .background_executor()+ .timer(MODEL_CATALOG_REQUEST_TIMEOUT);+ futures::select! {+ result = request.fuse() => result,+ () = timeout.fuse() => Err(anyhow!(+ "ChatGPT models request timed out after {MODEL_CATALOG_REQUEST_TIMEOUT:?}"+ )),+ }+ }+ .await;++ match result {+ Ok(models) => this+ .update(cx, |state, cx| {+ if state.model_catalog_generation == model_catalog_generation {+ state.available_models = models;+ state.last_model_catalog_error = None;+ cx.notify();+ }+ })+ .map_err(Arc::new),+ Err(error) => {+ let error = Arc::new(error);+ this.update(cx, |state, cx| {+ if state.model_catalog_generation == model_catalog_generation {+ state.last_model_catalog_error =+ Some(format!("Failed to load models: {error:#}").into());+ cx.notify();+ }+ })+ .map_err(Arc::new)?;+ Err(error)+ }+ }+ })+ }++ fn reset_model_catalog(&mut self) {+ self.model_catalog_generation = self.model_catalog_generation.wrapping_add(1);+ self.available_models = ChatGptModel::all();+ self.last_model_catalog_error = None;+ }+/// Starts the browser-based OAuth sign-in flow. No-op while a sign-in is/// already in progress; observe the entity to react to the outcome.pub fn sign_in(&mut self, cx: &mut Context<Self>) {@@ -173,13 +294,19 @@ impl State {match persist_result {Ok(()) => {- this.update(cx, |state, cx| {+ let refresh_models_task = this.update(cx, |state, cx| {+ state.auth_generation = state.auth_generation.wrapping_add(1);state.credentials = Some(creds);- state.sign_in_task = None;state.last_auth_error = None;+ state.refresh_model_catalog(cx)+ })?;+ if let Err(error) = refresh_models_task.await {+ log::warn!("Failed to refresh ChatGPT models: {error:#}");+ }+ this.update(cx, |state, cx| {+ state.sign_in_task = None;cx.notify();- })- .log_err();+ })?;}Err(err) => {log::error!(@@ -222,6 +349,7 @@ impl State {self.sign_in_task = None;self.refresh_task = None;self.last_auth_error = None;+ self.reset_model_catalog();cx.notify();let credentials_provider = self.credentials_provider.clone();@@ -235,20 +363,6 @@ impl State {}}-//-// The ChatGPT Subscription provider routes requests to chatgpt.com/backend-api/codex,-// which only supports a subset of OpenAI models. This list is maintained separately-// from the standard OpenAI API model list (open_ai::Model).-//-// TODO: The Codex CLI fetches this list dynamically from-// `GET <codex_base_url>/models?client_version=...` (see-// codex-rs/codex-api/src/endpoint/models.rs in openai/codex) and falls back to-// a bundled models.json. Beyond going stale, the static approach also can't-// model per-account access (e.g. free accounts cannot use gpt-5.4 even though-// paid accounts can), so the backend still rejects some requests. The bundled-// list at-// codex-rs/models-manager/models.json (openai/codex) is the closest-// approximation; the entries below mirror that file's picker-visible models.#[derive(Clone, Debug, PartialEq)]pub enum ChatGptModel {Gpt56Sol,@@ -257,6 +371,18 @@ pub enum ChatGptModel {Gpt55,Gpt54,Gpt54Mini,+ Discovered(Box<DiscoveredChatGptModel>),+}++#[derive(Clone, Debug, PartialEq)]+pub struct DiscoveredChatGptModel {+ id: String,+ display_name: String,+ max_token_count: u64,+ supports_images: bool,+ default_reasoning_effort: Option<ReasoningEffort>,+ supported_reasoning_efforts: Vec<ReasoningEffort>,+ supports_priority: bool,}impl ChatGptModel {@@ -279,6 +405,7 @@ impl ChatGptModel {Self::Gpt55 => "gpt-5.5",Self::Gpt54 => "gpt-5.4",Self::Gpt54Mini => "gpt-5.4-mini",+ Self::Discovered(model) => &model.id,}}@@ -290,6 +417,7 @@ impl ChatGptModel {Self::Gpt55 => "GPT-5.5",Self::Gpt54 => "GPT-5.4",Self::Gpt54Mini => "GPT-5.4 Mini",+ Self::Discovered(model) => &model.display_name,}}@@ -297,6 +425,7 @@ impl ChatGptModel {match self {Self::Gpt56Sol | Self::Gpt56Terra | Self::Gpt56Luna => 372_000,Self::Gpt55 | Self::Gpt54 | Self::Gpt54Mini => 272_000,+ Self::Discovered(model) => model.max_token_count,}}@@ -307,7 +436,10 @@ impl ChatGptModel {}fn supports_images(&self) -> bool {- true+ match self {+ Self::Discovered(model) => model.supports_images,+ _ => true,+ }}fn default_reasoning_effort(&self) -> Option<ReasoningEffort> {@@ -316,10 +448,11 @@ impl ChatGptModel {Self::Gpt56Terra | Self::Gpt56Luna | Self::Gpt55 | Self::Gpt54 | Self::Gpt54Mini => {Some(ReasoningEffort::Medium)}+ Self::Discovered(model) => model.default_reasoning_effort,}}- fn supported_reasoning_efforts(&self) -> &'static [ReasoningEffort] {+ fn supported_reasoning_efforts(&self) -> &[ReasoningEffort] {match self {Self::Gpt56Sol | Self::Gpt56Terra | Self::Gpt56Luna => &[ReasoningEffort::Low,@@ -334,6 +467,7 @@ impl ChatGptModel {ReasoningEffort::High,ReasoningEffort::XHigh,],+ Self::Discovered(model) => &model.supported_reasoning_efforts,}}@@ -349,6 +483,7 @@ impl ChatGptModel {match self {Self::Gpt56Sol | Self::Gpt56Terra | Self::Gpt56Luna | Self::Gpt55 | Self::Gpt54 => true,Self::Gpt54Mini => false,+ Self::Discovered(model) => model.supports_priority,}}}@@ -432,6 +567,150 @@ fn codex_extra_headers(CustomHeaders::new(header_pairs)}+#[derive(Deserialize)]+struct ModelsResponse {+ models: Vec<CatalogModel>,+}++#[derive(Deserialize)]+struct CatalogModel {+ slug: String,+ display_name: String,+ default_reasoning_level: Option<String>,+ #[serde(default)]+ supported_reasoning_levels: Vec<ReasoningEffortPreset>,+ visibility: ModelVisibility,+ priority: i32,+ #[serde(default)]+ additional_speed_tiers: Vec<String>,+ #[serde(default)]+ service_tiers: Vec<ModelServiceTier>,+ context_window: Option<u64>,+ max_context_window: Option<u64>,+ input_modalities: Option<Vec<String>>,+}++#[derive(Deserialize)]+struct ReasoningEffortPreset {+ effort: String,+}++#[derive(Deserialize)]+struct ModelServiceTier {+ id: String,+}++#[derive(Clone, Copy, Deserialize, PartialEq)]+#[serde(rename_all = "lowercase")]+enum ModelVisibility {+ List,+ Hide,+ None,+}++impl From<CatalogModel> for ChatGptModel {+ fn from(model: CatalogModel) -> Self {+ let default_reasoning_effort = model+ .default_reasoning_level+ .as_deref()+ .and_then(parse_reasoning_effort);+ let mut supported_reasoning_efforts = model+ .supported_reasoning_levels+ .iter()+ .filter_map(|preset| parse_reasoning_effort(&preset.effort))+ .collect::<Vec<_>>();+ if supported_reasoning_efforts.is_empty()+ && let Some(default_reasoning_effort) = default_reasoning_effort+ {+ supported_reasoning_efforts.push(default_reasoning_effort);+ }+ let supports_priority = model+ .additional_speed_tiers+ .iter()+ .any(|tier| tier == "fast")+ || model.service_tiers.iter().any(|tier| tier.id == "priority");+ let supports_images = model+ .input_modalities+ .as_ref()+ .is_none_or(|modalities| modalities.iter().any(|modality| modality == "image"));++ Self::Discovered(Box::new(DiscoveredChatGptModel {+ id: model.slug,+ display_name: model.display_name,+ max_token_count: model+ .context_window+ .or(model.max_context_window)+ .unwrap_or(272_000),+ supports_images,+ default_reasoning_effort,+ supported_reasoning_efforts,+ supports_priority,+ }))+ }+}++fn parse_reasoning_effort(effort: &str) -> Option<ReasoningEffort> {+ match effort {+ "none" => Some(ReasoningEffort::None),+ "minimal" => Some(ReasoningEffort::Minimal),+ "low" => Some(ReasoningEffort::Low),+ "medium" => Some(ReasoningEffort::Medium),+ "high" => Some(ReasoningEffort::High),+ "xhigh" => Some(ReasoningEffort::XHigh),+ "max" => Some(ReasoningEffort::Max),+ _ => None,+ }+}++async fn list_models(+ http_client: &dyn HttpClient,+ credentials: &CodexCredentials,+ client_version: &str,+) -> Result<Vec<ChatGptModel>> {+ let query = form_urlencoded::Serializer::new(String::new())+ .append_pair("client_version", client_version)+ .finish();+ let uri = format!("{CODEX_BASE_URL}/models?{query}");+ let extra_headers = codex_extra_headers(credentials, None);+ let request = HttpRequest::builder()+ .method(Method::GET)+ .uri(uri)+ .header("Accept", "application/json")+ .header(+ "Authorization",+ format!("Bearer {}", credentials.access_token),+ )+ .extra_headers(&extra_headers)+ .body(AsyncBody::default())+ .context("failed to build ChatGPT models request")?;+ let mut response = http_client+ .send(request)+ .await+ .context("failed to request ChatGPT models")?;+ let status = response.status();+ let mut body = String::new();+ smol::io::AsyncReadExt::read_to_string(response.body_mut(), &mut body)+ .await+ .context("failed to read ChatGPT models response")?;+ if !status.is_success() {+ return Err(anyhow!(+ "ChatGPT models request failed (HTTP {status}): {body}"+ ));+ }++ let mut models = serde_json::from_str::<ModelsResponse>(&body)+ .context("failed to parse ChatGPT models response")?+ .models;+ models.retain(|model| model.visibility == ModelVisibility::List);+ models.sort_by_key(|model| model.priority);+ if models.is_empty() {+ return Err(anyhow!(+ "ChatGPT models response did not contain any picker-visible models"+ ));+ }+ Ok(models.into_iter().map(ChatGptModel::from).collect())+}+impl LanguageModel for OpenAiSubscribedLanguageModel {fn id(&self) -> LanguageModelId {self.id.clone()@@ -735,6 +1014,7 @@ async fn get_fresh_credentials(s.credentials = None;s.last_auth_error =Some("Your session has expired. Please sign in again.".into());+ s.reset_model_catalog();cx.notify();}).ok();@@ -1328,10 +1608,34 @@ mod tests {.lock().replace(("Bearer".to_string(), creds_json));- let http: Arc<dyn HttpClient> = FakeHttpClient::create(|_| async {+ let http: Arc<dyn HttpClient> = FakeHttpClient::create(|request| async move {+ assert_eq!(+ request.uri().to_string(),+ "https://chatgpt.com/backend-api/codex/models?client_version=0.0.0"+ );Ok(http_client::Response::builder().status(200)- .body(http_client::AsyncBody::default())?)+ .body(http_client::AsyncBody::from(+ serde_json::json!({+ "models": [{+ "slug": "gpt-account-default",+ "display_name": "Account Default",+ "default_reasoning_level": "medium",+ "supported_reasoning_levels": [{+ "effort": "medium",+ "description": "Medium"+ }],+ "visibility": "list",+ "priority": 0,+ "additional_speed_tiers": [],+ "service_tiers": [],+ "context_window": 128_000,+ "max_context_window": null,+ "input_modalities": ["text"]+ }]+ })+ .to_string(),+ ))?)});let state = cx.new(|cx| State::new(http, creds_provider, cx));@@ -1347,6 +1651,277 @@ mod tests {let state = state.read(cx);assert!(state.is_authenticated());assert!(state.load_task().is_none());+ assert_eq!(+ state.available_models().first().map(ChatGptModel::id),+ Some("gpt-account-default")+ );+ });+ }++ #[gpui::test]+ async fn test_model_catalog_uses_account_visible_models(cx: &mut TestAppContext) {+ let http_client = FakeHttpClient::create(|request| async move {+ assert_eq!(request.method(), Method::GET);+ assert_eq!(+ request.uri().to_string(),+ "https://chatgpt.com/backend-api/codex/models?client_version=1.2.3"+ );+ assert_eq!(+ request+ .headers()+ .get("authorization")+ .and_then(|value| value.to_str().ok()),+ Some("Bearer fresh_access")+ );+ assert_eq!(+ request+ .headers()+ .get("chatgpt-account-id")+ .and_then(|value| value.to_str().ok()),+ Some("account-123")+ );+ assert_eq!(+ request+ .headers()+ .get("originator")+ .and_then(|value| value.to_str().ok()),+ Some("zed")+ );+ Ok(http_client::Response::builder()+ .status(200)+ .body(http_client::AsyncBody::from(+ serde_json::json!({+ "models": [+ {+ "slug": "gpt-5.6-sol",+ "display_name": "GPT-5.6 Sol",+ "default_reasoning_level": "low",+ "supported_reasoning_levels": [{+ "effort": "low",+ "description": "Low"+ }],+ "visibility": "hide",+ "priority": 0,+ "additional_speed_tiers": ["fast"],+ "service_tiers": [],+ "context_window": 372_000,+ "max_context_window": null,+ "input_modalities": ["text", "image"]+ },+ {+ "slug": "gpt-5.6-luna",+ "display_name": "GPT-5.6 Luna",+ "default_reasoning_level": "medium",+ "supported_reasoning_levels": [{+ "effort": "medium",+ "description": "Medium"+ }],+ "visibility": "list",+ "priority": 2,+ "additional_speed_tiers": [],+ "service_tiers": [{"id": "priority"}],+ "context_window": 372_000,+ "max_context_window": null,+ "input_modalities": ["text", "image"]+ },+ {+ "slug": "gpt-5.5",+ "display_name": "GPT-5.5",+ "default_reasoning_level": "medium",+ "supported_reasoning_levels": [{+ "effort": "medium",+ "description": "Medium"+ }],+ "visibility": "list",+ "priority": 1,+ "additional_speed_tiers": [],+ "service_tiers": [],+ "context_window": 272_000,+ "max_context_window": null,+ "input_modalities": ["text"]+ }+ ]+ })+ .to_string(),+ ))?)+ });+ let mut credentials = make_fresh_credentials();+ credentials.account_id = Some("account-123".to_string());+ let state = make_state(http_client, Some(credentials), cx);+ state.update(cx, |state, _cx| {+ state.client_version = "1.2.3".into();+ });++ state+ .update(cx, |state, cx| state.refresh_model_catalog(cx))+ .await+ .expect("model discovery should succeed");++ cx.read(|cx| {+ let state = state.read(cx);+ let model_ids = state+ .available_models()+ .iter()+ .map(ChatGptModel::id)+ .collect::<Vec<_>>();+ assert_eq!(model_ids, ["gpt-5.5", "gpt-5.6-luna"]);+ assert_eq!(+ state.default_model().as_ref().map(ChatGptModel::id),+ Some("gpt-5.5")+ );+ assert_eq!(+ state.default_fast_model().as_ref().map(ChatGptModel::id),+ Some("gpt-5.6-luna")+ );+ let default_model = state+ .available_models()+ .iter()+ .find(|model| model.id() == "gpt-5.5")+ .expect("default model should be present");+ let fast_model = state+ .available_models()+ .iter()+ .find(|model| model.id() == "gpt-5.6-luna")+ .expect("fast model should be present");+ assert!(!default_model.supports_images());+ assert!(fast_model.supports_priority());+ assert!(state.model_catalog_error().is_none());+ });+ }++ #[gpui::test]+ async fn test_model_catalog_failure_preserves_fallback_models(cx: &mut TestAppContext) {+ let http_client = FakeHttpClient::create(|_| async move {+ Ok(http_client::Response::builder()+ .status(500)+ .body(http_client::AsyncBody::from("backend unavailable"))?)+ });+ let state = make_state(http_client, Some(make_fresh_credentials()), cx);+ let fallback_model_ids = cx.read(|cx| {+ state+ .read(cx)+ .available_models()+ .iter()+ .map(ChatGptModel::id)+ .map(str::to_owned)+ .collect::<Vec<_>>()+ });++ state+ .update(cx, |state, cx| state.refresh_model_catalog(cx))+ .await+ .expect_err("model discovery should fail");++ cx.read(|cx| {+ let state = state.read(cx);+ let model_ids = state+ .available_models()+ .iter()+ .map(ChatGptModel::id)+ .map(str::to_owned)+ .collect::<Vec<_>>();+ assert_eq!(model_ids, fallback_model_ids);+ assert!(+ state+ .model_catalog_error()+ .is_some_and(|error| error.contains("backend unavailable"))+ );+ });+ }++ #[gpui::test]+ async fn test_model_catalog_request_times_out(cx: &mut TestAppContext) {+ let http_client = FakeHttpClient::create(|_| {+ futures::future::pending::<Result<http_client::Response<AsyncBody>>>()+ });+ let state = make_state(http_client, Some(make_fresh_credentials()), cx);++ let refresh_task = state.update(cx, |state, cx| state.refresh_model_catalog(cx));+ cx.run_until_parked();+ cx.executor().advance_clock(MODEL_CATALOG_REQUEST_TIMEOUT);+ cx.run_until_parked();++ let error = refresh_task+ .await+ .expect_err("model discovery should time out");+ assert!(+ error.to_string().contains("timed out after 5s"),+ "unexpected model discovery error: {error:#}"+ );+ }++ #[gpui::test]+ async fn test_obsolete_model_catalog_cannot_replace_newer_models(cx: &mut TestAppContext) {+ let (release_obsolete_request, obsolete_request) =+ futures::channel::oneshot::channel::<()>();+ let obsolete_request = Arc::new(Mutex::new(Some(obsolete_request)));+ let request_count = Arc::new(AtomicUsize::new(0));+ let http_client = FakeHttpClient::create({+ let obsolete_request = obsolete_request.clone();+ let request_count = request_count.clone();+ move |_| {+ let obsolete_request = obsolete_request.clone();+ let request_count = request_count.clone();+ async move {+ let request_index = request_count.fetch_add(1, Ordering::SeqCst);+ if request_index == 0 {+ let receiver = obsolete_request.lock().take();+ if let Some(receiver) = receiver {+ receiver.await.expect("obsolete request should be released");+ }+ }+ let model_id = if request_index == 0 {+ "obsolete-model"+ } else {+ "current-model"+ };+ Ok(http_client::Response::builder().status(200).body(+ http_client::AsyncBody::from(+ serde_json::json!({+ "models": [{+ "slug": model_id,+ "display_name": model_id,+ "default_reasoning_level": "medium",+ "supported_reasoning_levels": [],+ "visibility": "list",+ "priority": 0,+ "additional_speed_tiers": [],+ "service_tiers": [],+ "context_window": 128_000,+ "max_context_window": null,+ "input_modalities": ["text"]+ }]+ })+ .to_string(),+ ),+ )?)+ }+ }+ });+ let state = make_state(http_client, Some(make_fresh_credentials()), cx);++ let obsolete_refresh = state.update(cx, |state, cx| state.refresh_model_catalog(cx));+ cx.run_until_parked();+ state+ .update(cx, |state, cx| state.refresh_model_catalog(cx))+ .await+ .expect("newer model discovery should succeed");+ release_obsolete_request+ .send(())+ .expect("obsolete request should remain connected");+ obsolete_refresh+ .await+ .expect("obsolete model discovery may still complete");++ cx.read(|cx| {+ assert_eq!(+ state+ .read(cx)+ .available_models()+ .first()+ .map(ChatGptModel::id),+ Some("current-model")+ );});}@@ -1643,8 +2218,12 @@ mod tests {load_task: None,credentials_provider,http_client,+ client_version: "0.0.0".into(),+ available_models: ChatGptModel::all(),auth_generation: 0,+ model_catalog_generation: 0,last_auth_error: None,+ last_model_catalog_error: None,})}