use super::super::*;
use super::MissionControlApp;
use crate::sessions::preferences::{RestoredSessionPreferences, SessionPreferences};
impl MissionControlApp {
pub(super) fn save_session_preferences(
&mut self,
preferences: &SessionPreferences,
) -> Result<()> {
anyhow::ensure!(
self.preference_save_worker.is_none(),
"session preference save is in progress"
);
let Some(session) = self.state.current_session.clone() else {
return Ok(());
};
let cwd = self.state.cwd.clone();
let payload = serde_json::to_value(preferences)?;
self.preference_save_worker = Some(super::completion_worker::CompletionWorker::spawn(
"magi-session-preferences",
self.events.clone(),
move || {
record_session_event(
Some(&session),
&cwd,
SessionEventKind::SessionPreferences,
payload,
)
.map(|_| ())
.map_err(|error| error.to_string())
},
)?);
Ok(())
}
pub(super) fn reap_preference_save(&mut self, ui: &mut state::MissionControlState) -> bool {
let Some(worker) = &mut self.preference_save_worker else {
return false;
};
let result = worker.take_result();
let ready = worker.ready_to_reap();
let changed = result.is_some();
if let Some(Err(error)) = result {
Self::apply_ui_error(ui, format!("session preference save failed: {error}"));
}
if ready && let Some(worker) = self.preference_save_worker.take() {
let _ = worker.join();
}
changed
}
pub(in crate::tui) fn join_preference_save_for_cleanup(&mut self) -> Vec<String> {
self.preference_save_worker
.take()
.and_then(|worker| worker.join().err())
.into_iter()
.collect()
}
pub(super) fn restore_session_preferences(
&mut self,
ui: &mut state::MissionControlState,
restored: Option<RestoredSessionPreferences>,
) {
let (config, saved, notice) = match restored {
Some(restored) => (restored.config, Some(restored.saved), restored.notice),
None => (self.default_config.clone(), None, None),
};
self.session_preferences = saved;
self.state.model = config.model.clone().unwrap_or_else(|| {
crate::providers::default_model_for_provider(config.provider_id()).to_owned()
});
self.state.auth_state = config.auth_state();
self.state.config = Some(config.clone());
self.config = config;
self.summarizer.refresh_config(&self.config, &self.settings);
ui.provider = self.state.auth_state.provider().to_owned();
ui.provider_ready = self.state.auth_state.is_ready();
ui.model = self.state.model.clone();
let levels = cached_thinking_levels_for_model(
&self.config.paths,
&ui.provider,
&ui.model,
crate::thinking::capability_scope_for_provider(
&self.config.custom_providers,
&ui.provider,
),
);
ui.refresh_thinking_levels(self.config.thinking_level, levels);
if let Ok(budget) = crate::config::load_context_budget(&self.config) {
ui.update_context_window(budget.max_tokens);
}
self.refresh_fast_mode_state(ui);
if let Some(notice) = notice {
ui.apply_output_event(&OutputEvent::Diagnostic {
level: "warning".into(),
message: notice,
});
}
}
}