diff --git a/crates/ai_onboarding/src/edit_prediction_onboarding_content.rs b/crates/ai_onboarding/src/edit_prediction_onboarding_content.rs index 01425c62632..1e9eb46705f 100644 --- a/crates/ai_onboarding/src/edit_prediction_onboarding_content.rs +++ b/crates/ai_onboarding/src/edit_prediction_onboarding_content.rs @@ -1,8 +1,7 @@ use std::sync::Arc; use client::{Client, UserStore}; -use cloud_api_types::Plan; -use gpui::{Entity, IntoElement, ParentElement}; +use gpui::{Entity, IntoElement}; use ui::prelude::*; use crate::ZedAiOnboarding; @@ -10,72 +9,31 @@ use crate::ZedAiOnboarding; pub struct EditPredictionOnboarding { user_store: Entity, client: Arc, - copilot_is_configured: bool, continue_with_zed_ai: Arc, - continue_with_copilot: Arc, } impl EditPredictionOnboarding { pub fn new( user_store: Entity, client: Arc, - copilot_is_configured: bool, continue_with_zed_ai: Arc, - continue_with_copilot: Arc, _cx: &mut Context, ) -> Self { Self { user_store, - copilot_is_configured, client, continue_with_zed_ai, - continue_with_copilot, } } } impl Render for EditPredictionOnboarding { fn render(&mut self, _window: &mut Window, cx: &mut Context) -> impl IntoElement { - let is_free_plan = self - .user_store - .read(cx) - .plan() - .is_some_and(|plan| plan == Plan::ZedFree); - - let github_copilot = v_flex() - .gap_1() - .child(Label::new(if self.copilot_is_configured { - "Alternatively, you can continue to use GitHub Copilot as that's already set up." - } else { - "Alternatively, you can use GitHub Copilot as your edit prediction provider." - })) - .child( - Button::new( - "configure-copilot", - if self.copilot_is_configured { - "Use Copilot" - } else { - "Configure Copilot" - }, - ) - .full_width() - .style(ButtonStyle::Outlined) - .on_click({ - let callback = self.continue_with_copilot.clone(); - move |_, window, cx| callback(window, cx) - }), - ); - - v_flex() - .gap_2() - .child(ZedAiOnboarding::new( - self.client.clone(), - &self.user_store, - self.continue_with_zed_ai.clone(), - cx, - )) - .when(is_free_plan, |this| { - this.child(ui::Divider::horizontal()).child(github_copilot) - }) + ZedAiOnboarding::new( + self.client.clone(), + &self.user_store, + self.continue_with_zed_ai.clone(), + cx, + ) } } diff --git a/crates/ai_onboarding/src/plan_definitions.rs b/crates/ai_onboarding/src/plan_definitions.rs index 58c47a582b7..36a7c0c92fa 100644 --- a/crates/ai_onboarding/src/plan_definitions.rs +++ b/crates/ai_onboarding/src/plan_definitions.rs @@ -7,7 +7,6 @@ pub struct PlanDefinitions; impl PlanDefinitions { pub fn free_plan(&self) -> impl IntoElement { List::new() - .child(ListBulletItem::new("2,000 accepted edit predictions")) .child(ListBulletItem::new( "Unlimited prompts with your AI API keys", )) diff --git a/crates/client/src/user.rs b/crates/client/src/user.rs index 7a8ab595113..1d8c2693c4f 100644 --- a/crates/client/src/user.rs +++ b/crates/client/src/user.rs @@ -762,6 +762,15 @@ impl UserStore { cx.notify(); } + #[cfg(any(test, feature = "test-support"))] + pub fn set_current_organization_plan_for_test(&mut self, plan: Plan, cx: &mut Context) { + if let Some(organization) = &self.current_organization { + self.plans_by_organization + .insert(organization.id.clone(), plan); + } + cx.notify(); + } + pub fn plan(&self) -> Option { #[cfg(debug_assertions)] if let Ok(plan) = std::env::var("ZED_SIMULATE_PLAN").as_ref() { @@ -832,6 +841,13 @@ impl UserStore { self.edit_prediction_usage } + /// Returns whether the current plan doesn't include Zed's hosted edit predictions. This is + /// decided by plan rather than by the usage limit Cloud reports, because Cloud may still + /// report a nonzero Free allowance while it denies requests. + pub fn edit_predictions_excluded_from_plan(&self) -> bool { + self.plan() == Some(Plan::ZedFree) + } + pub fn update_edit_prediction_usage( &mut self, usage: EditPredictionUsage, diff --git a/crates/edit_prediction/src/edit_prediction.rs b/crates/edit_prediction/src/edit_prediction.rs index 650bc9173ab..61ee444ab1e 100644 --- a/crates/edit_prediction/src/edit_prediction.rs +++ b/crates/edit_prediction/src/edit_prediction.rs @@ -1,6 +1,6 @@ use anyhow::{Context as _, Result, anyhow}; use buffer_diff::BufferDiff; -use client::{Client, EditPredictionUsage, UserStore, global_llm_token}; +use client::{Client, EditPredictionUsage, UserStore, global_llm_token, zed_urls}; use cloud_api_client::LlmApiToken; use cloud_api_types::{ EditPredictionRecentFile, EditPredictionSettledKeptChars, @@ -52,12 +52,16 @@ use release_channel::AppVersion; use semver::Version; use serde::de::DeserializeOwned; use settings::{ - EditPredictionDataCollectionChoice, EditPredictionProvider, Settings as _, update_settings_file, + EditPredictionDataCollectionChoice, EditPredictionProvider, Settings as _, SettingsStore, + update_settings_file, }; use std::collections::{VecDeque, hash_map}; use std::env; use std::rc::Rc; use text::{AnchorRangeExt, Edit}; +use workspace::notifications::{ + NotificationId, show_app_notification, simple_message_notification::MessageNotification, +}; use workspace::{AppState, Workspace}; use zeta_prompt::ContextSource; use zeta_prompt::{Zeta2PromptInput, Zeta3PromptInput, ZetaFormat}; @@ -166,6 +170,7 @@ pub struct EditPredictionStore { user_store: Entity, llm_token: LlmApiToken, _fetch_experiments_task: Task<()>, + _user_store_subscription: gpui::Subscription, projects: HashMap, update_required: bool, edit_prediction_model: EditPredictionModel, @@ -1030,6 +1035,12 @@ impl EditPredictionStore { .log_err(); }); + let user_store_subscription = cx.subscribe(&user_store, |_, user_store, event, cx| { + if let client::user::Event::PrivateUserInfoUpdated = event { + show_free_plan_edit_predictions_ended_notice_once(&user_store, cx); + } + }); + let credentials_provider = zed_credentials_provider::global(cx); let this = Self { @@ -1038,6 +1049,7 @@ impl EditPredictionStore { user_store, llm_token, _fetch_experiments_task: fetch_experiments_task, + _user_store_subscription: user_store_subscription, update_required: false, edit_prediction_model: EditPredictionModel::Zeta, zeta2_raw_config: Self::zeta2_raw_config_from_env(), @@ -3519,6 +3531,86 @@ pub fn should_show_upsell_modal(cx: &App) -> bool { !is_upsell_dismissed(cx) } +/// Returns whether the user is set up to use Zed's hosted edit predictions but their plan +/// doesn't include them. Other providers, including Ollama and OpenAI-compatible servers that +/// run Zeta, don't go through Zed's servers and are unaffected. +pub fn zed_edit_predictions_excluded_from_plan(user_store: &UserStore, cx: &App) -> bool { + all_language_settings(None, cx).edit_predictions.provider == EditPredictionProvider::Zed + && user_store.edit_predictions_excluded_from_plan() +} + +/// Returns whether Zed's edit predictions should be treated as turned off: the user's plan +/// doesn't include them and Zed is only their provider by default. Users who explicitly chose +/// Zed keep the status bar button, which explains why predictions aren't available. +pub fn zed_edit_predictions_off_for_plan(user_store: &UserStore, cx: &App) -> bool { + let provider_explicitly_chosen = cx + .global::() + .raw_user_settings() + .and_then(|settings| { + settings + .content + .project + .all_languages + .edit_predictions + .as_ref()? + .provider + }) + .is_some(); + + !provider_explicitly_chosen && zed_edit_predictions_excluded_from_plan(user_store, cx) +} + +struct FreePlanEditPredictionsEndedNotice; + +impl Dismissable for FreePlanEditPredictionsEndedNotice { + const KEY: &'static str = "free-plan-edit-predictions-ended-notice"; +} + +fn show_free_plan_edit_predictions_ended_notice_once(user_store: &Entity, cx: &mut App) { + // Accepted predictions are metered per billing period, so a nonzero count identifies users + // who were actually relying on edit predictions rather than just having the default provider. + let has_accepted_predictions = user_store + .read(cx) + .edit_prediction_usage() + .is_some_and(|usage| usage.amount > 0); + + if DisableAiSettings::get_global(cx).disable_ai + || !has_accepted_predictions + || !zed_edit_predictions_excluded_from_plan(user_store.read(cx), cx) + || FreePlanEditPredictionsEndedNotice::dismissed(cx) + { + return; + } + + // Recorded when shown rather than when dismissed, so users see this once even if they + // never interact with it. + FreePlanEditPredictionsEndedNotice::set_dismissed(true, cx); + telemetry::event!("Free Plan Edit Predictions Ended Notice Shown"); + + show_app_notification( + NotificationId::unique::(), + cx, + |cx| { + cx.new(|cx| { + MessageNotification::new( + "Edit predictions are no longer included in the Free plan. \ + Upgrade to Pro for unlimited edit predictions.", + cx, + ) + .primary_message("Upgrade") + .primary_on_click(|_window, cx| { + telemetry::event!( + "Upgrade To Pro Clicked", + state = "free-plan-edit-predictions-ended" + ); + cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx)); + }) + .show_suppress_button(false) + }) + }, + ); +} + pub fn init(cx: &mut App) { cx.observe_new(move |workspace: &mut Workspace, _, _cx| { workspace.register_action( diff --git a/crates/edit_prediction/src/edit_prediction_tests.rs b/crates/edit_prediction/src/edit_prediction_tests.rs index 0f35f75b3c6..331bc6b3dbe 100644 --- a/crates/edit_prediction/src/edit_prediction_tests.rs +++ b/crates/edit_prediction/src/edit_prediction_tests.rs @@ -3,12 +3,12 @@ use clock::FakeSystemClock; use clock::ReplicaId; use cloud_api_types::{ CreateLlmTokenResponse, LlmToken, Organization, OrganizationConfiguration, - OrganizationEditPredictionConfiguration, OrganizationId, SettledEditPrediction, + OrganizationEditPredictionConfiguration, OrganizationId, Plan, SettledEditPrediction, SubmitEditPredictionSettledBatchBody, SubmitEditPredictionSettledResponse, }; use cloud_llm_client::{ EditPredictionRejectReason, EditPredictionRejection, PredictEditsRequestTrigger, - RejectEditPredictionsBody, + RejectEditPredictionsBody, UsageLimit, predict_edits_v3::{ PredictEditsV3Request, PredictEditsV3Response, RawCompletionChoice, RawCompletionRequest, RawCompletionResponse, RawCompletionUsage, @@ -2861,6 +2861,77 @@ fn set_test_organization(user_store: &Entity, cx: &mut TestAppContext }); } +#[gpui::test] +async fn test_free_plan_edit_predictions_ended_for_zed_provider(cx: &mut TestAppContext) { + let (ep_store, _requests) = init_test_with_fake_client(cx); + let user_store = ep_store.read_with(cx, |ep_store, _| ep_store.user_store.clone()); + + // Cloud reports a 2,000 allowance for Free, which must not keep predictions on. + let set_plan_and_usage = |plan, amount, cx: &mut TestAppContext| { + user_store.update(cx, |user_store, cx| { + user_store.set_current_organization_plan_for_test(plan, cx); + user_store.update_edit_prediction_usage( + EditPredictionUsage(client::RequestUsage { + limit: UsageLimit::Limited(2_000), + amount, + }), + cx, + ); + cx.emit(client::user::Event::PrivateUserInfoUpdated); + }); + cx.run_until_parked(); + }; + let set_provider = |provider: Option, cx: &mut TestAppContext| { + cx.update(|cx| { + SettingsStore::update_global(cx, |store, cx| { + store.update_user_settings(cx, |settings| { + settings + .project + .all_languages + .edit_predictions + .get_or_insert_default() + .provider = provider; + }); + }); + }); + }; + let excluded_from_plan = |cx: &mut TestAppContext| { + cx.read(|cx| zed_edit_predictions_excluded_from_plan(user_store.read(cx), cx)) + }; + let off_for_plan = |cx: &mut TestAppContext| { + cx.read(|cx| zed_edit_predictions_off_for_plan(user_store.read(cx), cx)) + }; + let notice_shown = + |cx: &mut TestAppContext| cx.read(|cx| FreePlanEditPredictionsEndedNotice::dismissed(cx)); + + set_provider(None, cx); + set_plan_and_usage(Plan::ZedPro, 250, cx); + assert!(!excluded_from_plan(cx)); + assert!(!off_for_plan(cx)); + assert!(!notice_shown(cx)); + + // Local Zeta models don't go through Zed's servers. + set_provider(Some(EditPredictionProvider::Ollama), cx); + set_plan_and_usage(Plan::ZedFree, 250, cx); + assert!(!excluded_from_plan(cx)); + assert!(!notice_shown(cx)); + + // Free users who never accepted a prediction this period don't need to be told. + set_provider(None, cx); + set_plan_and_usage(Plan::ZedFree, 0, cx); + assert!(excluded_from_plan(cx)); + assert!(off_for_plan(cx)); + assert!(!notice_shown(cx)); + + // Explicitly choosing Zed keeps it on, so the status bar can explain why it isn't working. + set_provider(Some(EditPredictionProvider::Zed), cx); + assert!(excluded_from_plan(cx)); + assert!(!off_for_plan(cx)); + + set_plan_and_usage(Plan::ZedFree, 250, cx); + assert!(notice_shown(cx)); +} + #[gpui::test] async fn test_edit_prediction_basic_interpolation(cx: &mut TestAppContext) { let buffer = cx.new(|cx| Buffer::local("Lorem ipsum dolor", cx)); diff --git a/crates/edit_prediction/src/onboarding_modal.rs b/crates/edit_prediction/src/onboarding_modal.rs index 0147fb75bdd..18df8ff4e99 100644 --- a/crates/edit_prediction/src/onboarding_modal.rs +++ b/crates/edit_prediction/src/onboarding_modal.rs @@ -1,6 +1,6 @@ use std::sync::Arc; -use crate::{EditPredictionStore, ZedPredictUpsell}; +use crate::ZedPredictUpsell; use ai_onboarding::EditPredictionOnboarding; use client::{Client, UserStore}; use db::kvp::Dismissable; @@ -50,19 +50,13 @@ impl ZedPredictModal { window: &mut Window, cx: &mut Context, ) { - let project = workspace.project().clone(); workspace.toggle_modal(window, cx, |_window, cx| { let weak_entity = cx.weak_entity(); - let copilot = EditPredictionStore::try_global(cx) - .and_then(|store| store.read(cx).copilot_for_project(&project)); Self { onboarding: cx.new(|cx| { EditPredictionOnboarding::new( user_store.clone(), client.clone(), - copilot - .as_ref() - .is_some_and(|copilot| copilot.read(cx).status().is_configured()), Arc::new({ let this = weak_entity.clone(); move |_window, cx| { @@ -71,17 +65,6 @@ impl ZedPredictModal { this.update(cx, |_, cx| cx.emit(DismissEvent)).ok(); } }), - Arc::new({ - let this = weak_entity.clone(); - move |window, cx| { - ZedPredictUpsell::set_dismissed(true, cx); - set_edit_prediction_provider(EditPredictionProvider::Copilot, cx); - this.update(cx, |_, cx| cx.emit(DismissEvent)).ok(); - if let Some(copilot) = copilot.clone() { - copilot_ui::initiate_sign_in(copilot, window, cx); - } - } - }), cx, ) }), diff --git a/crates/edit_prediction/src/zed_edit_prediction_delegate.rs b/crates/edit_prediction/src/zed_edit_prediction_delegate.rs index 9984a8255b4..9b4bd1a0ede 100644 --- a/crates/edit_prediction/src/zed_edit_prediction_delegate.rs +++ b/crates/edit_prediction/src/zed_edit_prediction_delegate.rs @@ -148,8 +148,10 @@ impl EditPredictionDelegate for ZedEditPredictionDelegate { ) { let store = self.store.read(cx); - if store.user_store.read_with(cx, |user_store, _cx| { - user_store.account_too_young() || user_store.has_overdue_invoices() + if store.user_store.read_with(cx, |user_store, cx| { + user_store.account_too_young() + || user_store.has_overdue_invoices() + || crate::zed_edit_predictions_excluded_from_plan(user_store, cx) }) { return; } diff --git a/crates/edit_prediction_ui/src/edit_prediction_button.rs b/crates/edit_prediction_ui/src/edit_prediction_button.rs index 4a06ff04b41..2a96d9c1f5b 100644 --- a/crates/edit_prediction_ui/src/edit_prediction_button.rs +++ b/crates/edit_prediction_ui/src/edit_prediction_button.rs @@ -343,6 +343,11 @@ impl Render for EditPredictionButton { ) } provider @ (EditPredictionProvider::Zed | EditPredictionProvider::Mercury) => { + if edit_prediction::zed_edit_predictions_off_for_plan(self.user_store.read(cx), cx) + { + return div().hidden(); + } + let enabled = self.editor_enabled.unwrap_or(true); let file = self.file.clone(); let language = self.language.clone(); @@ -428,6 +433,10 @@ impl Render for EditPredictionButton { let show_editor_predictions = self.editor_show_predictions; let user = self.user_store.read(cx).current_user(); + let excluded_from_plan = edit_prediction::zed_edit_predictions_excluded_from_plan( + self.user_store.read(cx), + cx, + ); let mercury_has_error = matches!(provider, EditPredictionProvider::Mercury) && edit_prediction::EditPredictionStore::try_global(cx).is_some_and( @@ -436,6 +445,8 @@ impl Render for EditPredictionButton { let indicator_color = if missing_token || mercury_has_error { Some(Color::Error) + } else if excluded_from_plan { + Some(Color::Muted) } else if enabled && (!show_editor_predictions || over_limit) { Some(if over_limit { Color::Error @@ -465,6 +476,8 @@ impl Render for EditPredictionButton { "Disabled For This File" } else if zed_cloud_needs_sign_in { "Sign In Or Configure a Provider" + } else if excluded_from_plan { + "Configure a Provider" } else if provider_unavailable || show_editor_predictions { tooltip_meta } else { @@ -600,6 +613,9 @@ impl EditPredictionButton { let is_zed_provider_disabled = organization_configuration .is_some_and(|configuration| !configuration.edit_prediction.is_enabled); + let user_store = self.user_store.read(cx); + let is_zed_provider_unavailable = user_store.current_user().is_none() + || edit_prediction::zed_edit_predictions_excluded_from_plan(user_store, cx); let available_providers = get_available_providers(cx); @@ -618,11 +634,18 @@ impl EditPredictionButton { let is_current = provider == current_provider; let is_disabled_zed_provider = provider == EditPredictionProvider::Zed && is_zed_provider_disabled; + // Zed stays selected in settings, but checking it would imply predictions are + // working when the user still needs to sign in or upgrade. + let is_unavailable_zed_provider = + provider == EditPredictionProvider::Zed && is_zed_provider_unavailable; let fs = self.fs.clone(); menu = menu.item( ContextMenuEntry::new(name) - .toggleable(IconPosition::Start, is_current && !is_disabled_zed_provider) + .toggleable( + IconPosition::Start, + is_current && !is_disabled_zed_provider && !is_unavailable_zed_provider, + ) .disabled(is_disabled_zed_provider) .when(is_disabled_zed_provider, |item| { item.documentation_aside(DocumentationSide::Left, move |_cx| { @@ -1118,8 +1141,8 @@ impl EditPredictionButton { menu = menu .custom_row(move |_window, cx| { let description = indoc! { - "You get 2,000 accepted suggestions at every keystroke for free, \ - powered by Zeta, our open-source, open-data model" + "Suggestions at every keystroke, powered by Zeta, our open-source, \ + open-data model. Included with Zed Pro and the Pro trial." }; v_flex() @@ -1135,7 +1158,7 @@ impl EditPredictionButton { .into_any_element() }) .separator() - .entry("Sign In & Start Using", None, |window, cx| { + .entry("Sign In", None, |window, cx| { telemetry::event!( "Edit Prediction Menu Action", action = "sign_in", @@ -1185,7 +1208,30 @@ impl EditPredictionButton { .separator(); } - if let Some(usage) = self + if edit_prediction::zed_edit_predictions_excluded_from_plan( + self.user_store.read(cx), + cx, + ) { + menu = menu + .custom_entry( + |_window, _cx| { + Label::new("Zed's edit predictions not included in the Free plan.") + .size(LabelSize::Small) + .color(Color::Muted) + .into_any_element() + }, + |_window, cx| cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx)), + ) + .entry("Upgrade to Pro", None, |_window, cx| { + telemetry::event!( + "Edit Prediction Menu Action", + action = "upsell_clicked", + reason = "excluded_from_plan", + ); + cx.open_url(&zed_urls::upgrade_to_zed_pro_url(cx)) + }) + .separator(); + } else if let Some(usage) = self .edit_prediction_provider .as_ref() .and_then(|provider| provider.usage(cx)) diff --git a/docs/src/account/plans-and-pricing.md b/docs/src/account/plans-and-pricing.md index ebf3e1ba417..8198ff0202b 100644 --- a/docs/src/account/plans-and-pricing.md +++ b/docs/src/account/plans-and-pricing.md @@ -11,19 +11,19 @@ Zed works without AI features or a subscription. No [authentication](../authenti ## Plans {#plans} -| | Free | Pro | Student | Business | -| -------------------------------------------------------- | ------- | --------- | --------- | --------- | -| Zed-hosted AI models | — | ✓ | ✓ | ✓ | -| [AI via own API keys](../ai/use-api-access.md) | ✓ | ✓ | ✓ | ✓ | -| [External Agents](../ai/external-agents.md) | ✓ | ✓ | ✓ | ✓ | -| Edit Predictions | Limited | Unlimited | Unlimited | Unlimited | -| [Org-wide admin controls](../business/admin-controls.md) | — | — | — | ✓ | -| Roles & permissions | — | — | — | ✓ | -| Consolidated billing | — | — | — | ✓ | +| | Free | Pro | Student | Business | +| -------------------------------------------------------- | ---- | --------- | --------- | --------- | +| Zed-hosted AI models | — | ✓ | ✓ | ✓ | +| [AI via own API keys](../ai/use-api-access.md) | ✓ | ✓ | ✓ | ✓ | +| [External Agents](../ai/external-agents.md) | ✓ | ✓ | ✓ | ✓ | +| Edit Predictions | — | Unlimited | Unlimited | Unlimited | +| [Org-wide admin controls](../business/admin-controls.md) | — | — | — | ✓ | +| Roles & permissions | — | — | — | ✓ | +| Consolidated billing | — | — | — | ✓ | ### Zed Free {#free} -Zed is free to use. You can configure AI agents with your own API keys via [Use API Access](../ai/use-api-access.md). [Edit Predictions](../ai/edit-prediction.md) are available on a limited basis. Zed's hosted models require a Pro subscription. +Zed is free to use. You can configure AI agents with your own API keys via [Use API Access](../ai/use-api-access.md). Zed's hosted models and [Edit Predictions](../ai/edit-prediction.md) require a Pro subscription. You can still use edit predictions from [other providers](../ai/edit-prediction.md#other-providers), like GitHub Copilot or a local model. ### Zed Pro {#pro} diff --git a/docs/src/ai/edit-prediction.md b/docs/src/ai/edit-prediction.md index afc2fc41274..ee6e5260b9a 100644 --- a/docs/src/ai/edit-prediction.md +++ b/docs/src/ai/edit-prediction.md @@ -35,7 +35,7 @@ The Z icon in the status bar also indicates Zeta is active. ### Pricing and Plans -The free plan includes 2,000 Zeta predictions per month. The [Pro plan](../account/plans-and-pricing.md) removes this limit. See [Zed's pricing page](https://zed.dev/pricing) for details. +Zeta predictions are included with [Zed Pro](../account/plans-and-pricing.md#pro), the [Pro trial](../account/plans-and-pricing.md#trials), and the [Student](../account/plans-and-pricing.md#student) and [Business](../account/plans-and-pricing.md#business) plans. On the Free plan, you can use [other providers](#other-providers), like GitHub Copilot or a [local model](#local-and-self-hosted-models). See [Zed's pricing page](https://zed.dev/pricing) for details. ### Switching Modes {#switching-modes}