use super::{Client, UserStore};use anyhow::anyhow;use cloud_api_client::LlmApiToken;use cloud_api_types::websocket_protocol::MessageToClient;use cloud_llm_client::{EXPIRED_LLM_TOKEN_HEADER_NAME, OUTDATED_LLM_TOKEN_HEADER_NAME};use futures::StreamExt;use gpui::{    App, AppContext as _, Context, Entity, EventEmitter, Global, ReadGlobal as _, Subscription,    Task, TaskExt,};use std::sync::Arc; pub trait NeedsLlmTokenRefresh {    /// Returns whether the LLM token needs to be refreshed.    fn needs_llm_token_refresh(&self) -> bool;} impl NeedsLlmTokenRefresh for http_client::Response<http_client::AsyncBody> {    fn needs_llm_token_refresh(&self) -> bool {        self.headers().get(EXPIRED_LLM_TOKEN_HEADER_NAME).is_some()            || self.headers().get(OUTDATED_LLM_TOKEN_HEADER_NAME).is_some()    }} enum TokenRefreshMode {    Refresh,    ClearAndRefresh,} pub fn global_llm_token(cx: &App) -> LlmApiToken {    RefreshLlmTokenListener::global(cx)        .read(cx)        .llm_api_token        .clone()} struct GlobalRefreshLlmTokenListener(Entity<RefreshLlmTokenListener>); impl Global for GlobalRefreshLlmTokenListener {} pub struct LlmTokenRefreshedEvent; pub struct RefreshLlmTokenListener {    client: Arc<Client>,    user_store: Entity<UserStore>,    llm_api_token: LlmApiToken,    _clear_llm_token_on_sign_out: Task<()>,    _subscription: Subscription,} impl EventEmitter<LlmTokenRefreshedEvent> for RefreshLlmTokenListener {} impl RefreshLlmTokenListener {    pub fn register(client: Arc<Client>, user_store: Entity<UserStore>, cx: &mut App) {        let listener = cx.new(|cx| RefreshLlmTokenListener::new(client, user_store, cx));        cx.set_global(GlobalRefreshLlmTokenListener(listener));    }     pub fn global(cx: &App) -> Entity<Self> {        GlobalRefreshLlmTokenListener::global(cx).0.clone()    }     fn new(client: Arc<Client>, user_store: Entity<UserStore>, cx: &mut Context<Self>) -> Self {        client.add_message_to_client_handler({            let this = cx.weak_entity();            move |message, cx| {                if let Some(this) = this.upgrade() {                    Self::handle_refresh_llm_token(this, message, cx);                }            }        });         let subscription = cx.subscribe(&user_store, |this, _user_store, event, cx| {            if matches!(event, super::user::Event::OrganizationChanged) {                this.refresh(TokenRefreshMode::ClearAndRefresh, cx);            }        });         let llm_api_token = LlmApiToken::default();        let mut status = client.status();        let clear_llm_token_on_sign_out = cx.spawn({            let llm_api_token = llm_api_token.clone();            async move |_this, _cx| {                while let Some(status) = status.next().await {                    if status.is_signed_out() {                        llm_api_token.clear().await;                    }                }            }        });         Self {            client,            user_store,            llm_api_token,            _clear_llm_token_on_sign_out: clear_llm_token_on_sign_out,            _subscription: subscription,        }    }     fn refresh(&self, mode: TokenRefreshMode, cx: &mut Context<Self>) {        let client = self.client.clone();        let llm_api_token = self.llm_api_token.clone();        let organization_id = self            .user_store            .read(cx)            .current_organization()            .map(|organization| organization.id.clone());        cx.spawn(async move |this, cx| {            let organization_id =                organization_id.ok_or_else(|| anyhow!("No organization selected."))?;             match mode {                TokenRefreshMode::Refresh => {                    client                        .refresh_llm_token(&llm_api_token, organization_id)                        .await?;                }                TokenRefreshMode::ClearAndRefresh => {                    client                        .clear_and_refresh_llm_token(&llm_api_token, organization_id)                        .await?;                }            }            this.update(cx, |_this, cx| cx.emit(LlmTokenRefreshedEvent))        })        .detach_and_log_err(cx);    }     fn handle_refresh_llm_token(this: Entity<Self>, message: &MessageToClient, cx: &mut App) {        match message {            MessageToClient::UserUpdated => {                this.update(cx, |this, cx| this.refresh(TokenRefreshMode::Refresh, cx));            }        }    }}