mirror of
https://github.com/openai/codex.git
synced 2026-11-18 22:20:48 +00:00
## What changed - Open a searchable picker with `Ctrl+X E` to choose a saved personal or workspace environment, or use Default with the current GitHub project when available. - Show the selected environment above the composer and expose `tui.keymap.global.choose_cloud_environment` for custom bindings. - Preserve the composer draft and staged model, reasoning effort, and service tier when changing environments. Remember the saved environment when cycling through a local host and back to the same Cloud backend. ## Testing Add coverage for picker search and selection, dismissal without losing the draft, keyboard routing, environment label truncation, staged settings on the first turn, and saved-environment reuse after host switching. GitOrigin-RevId: ac9036fd46b252286852df4d792418a3330bae73
1492 lines
62 KiB
Rust
1492 lines
62 KiB
Rust
//! Overview of recent and locally retained sessions across registered backends.
|
|
//! Selecting a task on another backend prepares its owner before switching the UI.
|
|
//! Only the immediate attachment of a dashboard-created task is treated as fresh.
|
|
|
|
#[path = "agents_overview_new.rs"]
|
|
mod new;
|
|
pub(crate) use new::PendingWorktree;
|
|
|
|
#[path = "agents_overview_errors.rs"]
|
|
mod errors;
|
|
|
|
#[path = "agents_overview_loading.rs"]
|
|
mod loading;
|
|
|
|
#[path = "agents_overview_selection.rs"]
|
|
mod selection;
|
|
|
|
use super::agents_overview_discovery::is_overview_root;
|
|
use super::agents_overview_discovery::is_visible_in_agents_overview;
|
|
use super::agents_overview_view::AgentsOverviewGroup;
|
|
use super::agents_overview_view::AgentsOverviewRow;
|
|
use super::agents_overview_view::AgentsOverviewView;
|
|
use super::app_server_requests::BufferedServerRequest;
|
|
use super::session_lifecycle::ThreadAttachPresentation;
|
|
use super::*;
|
|
use crate::app_event::AgentsOverviewThreadRefresh;
|
|
use crate::backend_id::BackendId;
|
|
use crate::bottom_pane::BottomPaneView;
|
|
use crate::chatwidget::ThreadInputStateRestoreMode;
|
|
use crate::startup_draft::StartupDraftPump;
|
|
use codex_app_server_protocol::SessionSource;
|
|
use codex_app_server_protocol::Thread;
|
|
use codex_app_server_protocol::ThreadHistoryMode;
|
|
use codex_protocol::protocol::SubAgentSource;
|
|
use std::collections::VecDeque;
|
|
|
|
pub(crate) const AGENTS_OVERVIEW_VIEW_ID: &str = "agents-overview";
|
|
|
|
#[derive(Default)]
|
|
pub(super) struct AgentsOverviewState {
|
|
/// Missing metadata records a local resume until the next metadata refresh.
|
|
pub(super) threads: HashMap<ThreadId, Option<Thread>>,
|
|
/// Identifies the query that populated the cached search results.
|
|
pub(super) search_id: Uuid,
|
|
pub(super) search_matches: HashMap<ThreadId, Thread>,
|
|
/// Lifecycle removals take precedence over delayed tool registration responses.
|
|
pub(super) removed_threads: HashSet<ThreadId>,
|
|
/// Local visibility only; activity and metadata refreshes never reveal hidden roots.
|
|
pub(super) hidden_threads: HashSet<ThreadId>,
|
|
/// Hide pending archives; retain their outcomes if shutdown beats event dispatch.
|
|
pub(super) pending_archives:
|
|
HashMap<ThreadId, tokio::sync::oneshot::Receiver<Result<(), String>>>,
|
|
pub(super) unread: HashSet<ThreadId>,
|
|
pub(super) last_messages: HashMap<ThreadId, String>,
|
|
pub(super) usage: HashMap<ThreadId, super::agents_overview_usage::AgentsOverviewUsage>,
|
|
pub(super) pending_usage: Option<(ThreadId, Uuid)>,
|
|
pub(super) usage_disabled: bool,
|
|
pub(super) activity: HashMap<ThreadId, super::agents_overview_details::AgentsOverviewActivity>,
|
|
pub(super) initialized: HashSet<BackendId>,
|
|
pub(super) discovery:
|
|
HashMap<BackendId, super::agents_overview_discovery::AgentsOverviewDiscovery>,
|
|
pub(super) show_more_backends: HashSet<BackendId>,
|
|
pub(super) refresh_show_more: bool,
|
|
pub(super) refresh_failed_backends: HashSet<BackendId>,
|
|
/// Vacancies left by lifecycle removals, tracked by the backend that owned the row.
|
|
pub(super) refill_by_backend: HashMap<BackendId, usize>,
|
|
pub(super) active_refresh: Option<(Uuid, BackendId)>,
|
|
/// Other backends queued while the shared overview refresh slot is occupied.
|
|
pub(super) pending_refresh_backends: VecDeque<BackendId>,
|
|
pub(super) pin_refresh_requested: bool,
|
|
pub(super) refresh_thread_ids: HashSet<ThreadId>,
|
|
pub(super) active_refresh_thread_ids: HashSet<ThreadId>,
|
|
pub(super) pins_by_backend: std::collections::BTreeMap<BackendId, Option<Vec<ThreadId>>>,
|
|
pub(super) pending_pin_change: Option<(Uuid, BackendId)>,
|
|
pub(super) refresh_task: Option<tokio::task::AbortHandle>,
|
|
pub(super) refresh_notifications: HashMap<ThreadId, Vec<ServerNotification>>,
|
|
pub(super) rendered_full_screen: bool,
|
|
pub(super) visible_thread_ids: Vec<ThreadId>,
|
|
/// One-shot successor selected before a removal invalidates the displayed rows.
|
|
pub(super) selection_after_removal: Option<ThreadId>,
|
|
pub(super) view_state:
|
|
Arc<std::sync::Mutex<super::agents_overview_view::AgentsOverviewViewState>>,
|
|
/// Explicit permission-profile choices for new-session carryover, retained across navigation.
|
|
pub(super) selected_permission_profiles: HashMap<ThreadId, String>,
|
|
/// Accepted menu requests; unchanged settings may never produce a notification.
|
|
pub(super) requested_permission_profiles: HashMap<ThreadId, PermissionProfileSelection>,
|
|
/// Keep new tasks subscribed and reusable until a first turn makes them resumable.
|
|
pub(super) blank_sessions: HashMap<ThreadId, crate::app_server_session::AppServerStartedThread>,
|
|
/// A host switch carries this choice with the draft, but only its original backend can use it.
|
|
pub(super) draft_cloud_environments:
|
|
HashMap<ThreadId, (BackendId, codex_app_server_client::SavedEnvironment)>,
|
|
pub(super) input_states: HashMap<ThreadId, ThreadInputState>,
|
|
pub(super) new_session_draft: Option<Box<StartupDraftPump>>,
|
|
pub(super) dispatched_requests: HashMap<ThreadId, Vec<BufferedServerRequest>>,
|
|
}
|
|
|
|
impl AgentsOverviewState {
|
|
pub(super) fn refill_count(&self, owner: BackendId) -> usize {
|
|
self.refill_by_backend
|
|
.get(&owner)
|
|
.copied()
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
pub(super) fn has_more_for(
|
|
&self,
|
|
registry: &super::backend_registry::BackendRegistry,
|
|
owner: BackendId,
|
|
) -> bool {
|
|
registry.request_handle(owner).is_some()
|
|
&& self
|
|
.discovery
|
|
.get(&owner)
|
|
.is_some_and(super::agents_overview_discovery::AgentsOverviewDiscovery::has_more)
|
|
}
|
|
}
|
|
|
|
impl Drop for AgentsOverviewState {
|
|
fn drop(&mut self) {
|
|
if let Some(task) = self.refresh_task.take() {
|
|
task.abort();
|
|
}
|
|
}
|
|
}
|
|
|
|
impl App {
|
|
pub(super) fn open_agents_overview(&mut self, app_server: &AppServerSession) {
|
|
let threads = self
|
|
.agents_overview
|
|
.threads
|
|
.values()
|
|
.flatten()
|
|
.cloned()
|
|
.collect();
|
|
let selected_thread_id = self.agents_overview.selection_after_removal.take();
|
|
let view = self.agents_overview_view(threads, selected_thread_id);
|
|
self.agents_overview.visible_thread_ids = view.thread_ids();
|
|
self.chat_widget.show_bottom_pane_view(Box::new(view));
|
|
if self.reconnect.offline {
|
|
self.reconnect.presentation = reconnect::ReconnectPresentation::Overview;
|
|
let mut state = self
|
|
.agents_overview
|
|
.view_state
|
|
.lock()
|
|
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
|
state.loading = false;
|
|
state.connection_notice = Some(if self.reconnect.failed {
|
|
"Reconnect failed — agent list is stale; relaunch to retry"
|
|
} else {
|
|
"Reconnecting — agent list is stale"
|
|
});
|
|
}
|
|
self.refresh_agents_overview_threads(app_server);
|
|
}
|
|
|
|
pub(super) fn apply_agents_overview_thread_refresh(
|
|
&mut self,
|
|
app_server: &AppServerSession,
|
|
request_id: Uuid,
|
|
result: Result<AgentsOverviewThreadRefresh, String>,
|
|
) {
|
|
let Some((_, refresh_backend_id)) = self
|
|
.agents_overview
|
|
.active_refresh
|
|
.take_if(|(id, _)| *id == request_id)
|
|
else {
|
|
return;
|
|
};
|
|
self.agents_overview.refresh_show_more = false;
|
|
self.agents_overview.active_refresh_thread_ids.clear();
|
|
self.agents_overview.refresh_task = None;
|
|
let refill_succeeded = result
|
|
.as_ref()
|
|
.is_ok_and(|refresh| refresh.recent_seed_complete);
|
|
if !refill_succeeded {
|
|
self.agents_overview
|
|
.refresh_failed_backends
|
|
.insert(refresh_backend_id);
|
|
} else if result
|
|
.as_ref()
|
|
.is_ok_and(|refresh| refresh.discovery.is_some())
|
|
{
|
|
self.agents_overview
|
|
.refresh_failed_backends
|
|
.remove(&refresh_backend_id);
|
|
}
|
|
{
|
|
let mut state = self
|
|
.agents_overview
|
|
.view_state
|
|
.lock()
|
|
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
|
state.loading = false;
|
|
state.refresh_failed = self
|
|
.agents_overview
|
|
.refresh_failed_backends
|
|
.contains(&app_server.backend_id());
|
|
}
|
|
match result {
|
|
Ok(mut refresh) => {
|
|
for id in refresh.cleared_unread {
|
|
self.agents_overview.unread.remove(&id);
|
|
}
|
|
if let Some(pinned_thread_ids) = refresh.pinned_thread_ids {
|
|
let pins = pinned_thread_ids.map(|ids| {
|
|
let mut seen = HashSet::new();
|
|
ids.into_iter()
|
|
.filter(|id| {
|
|
self.backend_registry.observe(refresh_backend_id, *id)
|
|
&& seen.insert(*id)
|
|
})
|
|
.collect()
|
|
});
|
|
self.agents_overview
|
|
.pins_by_backend
|
|
.insert(refresh_backend_id, pins);
|
|
}
|
|
if refresh.recent_seed_complete {
|
|
self.agents_overview.initialized.insert(refresh_backend_id);
|
|
}
|
|
if let Some(discovery) = refresh.discovery {
|
|
if !discovery.has_more() {
|
|
self.agents_overview
|
|
.refill_by_backend
|
|
.remove(&refresh_backend_id);
|
|
self.agents_overview
|
|
.show_more_backends
|
|
.remove(&refresh_backend_id);
|
|
}
|
|
self.agents_overview
|
|
.discovery
|
|
.insert(refresh_backend_id, discovery);
|
|
let has_more = self
|
|
.agents_overview
|
|
.has_more_for(&self.backend_registry, app_server.backend_id());
|
|
self.agents_overview
|
|
.view_state
|
|
.lock()
|
|
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
|
.has_more = has_more;
|
|
}
|
|
for (thread_id, thread) in refresh.threads {
|
|
if self.agents_overview.removed_threads.contains(&thread_id) {
|
|
continue;
|
|
}
|
|
if thread.is_some()
|
|
&& !self.backend_registry.observe(refresh_backend_id, thread_id)
|
|
{
|
|
continue;
|
|
}
|
|
if let Some(message) = refresh.last_messages.remove(&thread_id) {
|
|
self.agents_overview
|
|
.last_messages
|
|
.insert(thread_id, message);
|
|
}
|
|
if let Some((mut thread, unread, latest_prompt)) = thread {
|
|
self.agents_overview.search_matches.remove(&thread_id);
|
|
if unread {
|
|
self.agents_overview.unread.insert(thread_id);
|
|
} else {
|
|
self.agents_overview.unread.remove(&thread_id);
|
|
}
|
|
if thread.ephemeral {
|
|
self.agents_overview.threads.remove(&thread_id);
|
|
self.agents_overview.last_messages.remove(&thread_id);
|
|
self.agents_overview.activity.remove(&thread_id);
|
|
self.agents_overview.usage.remove(&thread_id);
|
|
continue;
|
|
}
|
|
if !self.agents_overview.threads.contains_key(&thread_id)
|
|
&& !self.agents_overview.hidden_threads.contains(&thread_id)
|
|
&& is_overview_root(&thread)
|
|
&& let Some(refill) = self
|
|
.agents_overview
|
|
.refill_by_backend
|
|
.get_mut(&refresh_backend_id)
|
|
{
|
|
*refill = refill.saturating_sub(1);
|
|
}
|
|
if thread.history_mode == ThreadHistoryMode::Paginated {
|
|
self.agents_overview
|
|
.activity
|
|
.entry(thread_id)
|
|
.or_default()
|
|
.latest_prompt = latest_prompt;
|
|
}
|
|
thread.turns.clear();
|
|
self.agents_overview.threads.insert(thread_id, Some(thread));
|
|
} else {
|
|
self.agents_overview.threads.entry(thread_id).or_default();
|
|
}
|
|
}
|
|
}
|
|
Err(error) => {
|
|
tracing::warn!(%error, "failed to refresh agents overview");
|
|
}
|
|
}
|
|
for notifications in
|
|
std::mem::take(&mut self.agents_overview.refresh_notifications).into_values()
|
|
{
|
|
for notification in notifications {
|
|
if let ServerNotification::ThreadReverted(reverted) = ¬ification
|
|
&& let Ok(thread_id) = ThreadId::from_string(&reverted.thread_id)
|
|
{
|
|
// Discard stale read results without clearing activity received after the revert.
|
|
if self
|
|
.agents_overview
|
|
.threads
|
|
.get(&thread_id)
|
|
.and_then(Option::as_ref)
|
|
.is_some_and(|thread| thread.history_mode == ThreadHistoryMode::Paginated)
|
|
&& let Some(activity) = self.agents_overview.activity.get_mut(&thread_id)
|
|
{
|
|
activity.latest_prompt = None;
|
|
}
|
|
self.agents_overview.last_messages.remove(&thread_id);
|
|
if let Some(usage) = self.agents_overview.usage.get_mut(&thread_id) {
|
|
usage.tokens = None;
|
|
}
|
|
continue;
|
|
}
|
|
self.track_agents_overview_notification(¬ification);
|
|
}
|
|
}
|
|
let overview = &mut self.agents_overview;
|
|
if refill_succeeded {
|
|
for (&owner, discovery) in &overview.discovery {
|
|
if owner == app_server.backend_id()
|
|
&& discovery.has_more()
|
|
&& (overview.refill_count(owner) > 0
|
|
|| overview.show_more_backends.contains(&owner))
|
|
&& !overview.pending_refresh_backends.contains(&owner)
|
|
{
|
|
overview.pending_refresh_backends.push_back(owner);
|
|
}
|
|
}
|
|
}
|
|
self.drain_agents_overview_refresh_queue();
|
|
self.repaint_agents_overview();
|
|
}
|
|
|
|
pub(super) fn drain_agents_overview_refresh_queue(&mut self) {
|
|
if self.agents_overview.active_refresh.is_some() || self.reconnect.offline {
|
|
return;
|
|
}
|
|
let visible = self
|
|
.chat_widget
|
|
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
|
.is_some();
|
|
if let Some((backend_id, handle)) = self
|
|
.agents_overview
|
|
.pending_refresh_backends
|
|
.iter()
|
|
.copied()
|
|
.filter(|&backend_id| {
|
|
self.app_server_backend_id
|
|
.is_none_or(|owner| owner == backend_id)
|
|
&& (visible || !self.agents_overview.initialized.contains(&backend_id))
|
|
})
|
|
.find_map(|backend_id| {
|
|
self.backend_registry
|
|
.request_handle(backend_id)
|
|
.map(|handle| (backend_id, handle))
|
|
})
|
|
{
|
|
self.start_agents_overview_refresh_for_backend(backend_id, handle);
|
|
}
|
|
}
|
|
|
|
pub(super) fn reset_agents_overview_discovery(&mut self, backend_id: BackendId) {
|
|
let overview = &mut self.agents_overview;
|
|
overview.initialized.remove(&backend_id);
|
|
overview.discovery.remove(&backend_id);
|
|
overview
|
|
.removed_threads
|
|
.retain(|thread_id| self.backend_registry.owner(*thread_id) != Some(backend_id));
|
|
overview
|
|
.view_state
|
|
.lock()
|
|
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
|
.has_more = self
|
|
.app_server_backend_id
|
|
.is_some_and(|owner| overview.has_more_for(&self.backend_registry, owner));
|
|
}
|
|
|
|
pub(super) fn cancel_agents_overview_refresh(&mut self, backend_id: BackendId) {
|
|
let overview = &mut self.agents_overview;
|
|
if overview
|
|
.active_refresh
|
|
.is_some_and(|(_, owner)| owner == backend_id)
|
|
{
|
|
if let Some(task) = overview.refresh_task.take() {
|
|
task.abort();
|
|
}
|
|
overview.active_refresh = None;
|
|
overview.refresh_notifications.clear();
|
|
if std::mem::take(&mut overview.refresh_show_more) {
|
|
overview.show_more_backends.insert(backend_id);
|
|
}
|
|
let removed_threads = &overview.removed_threads;
|
|
overview.refresh_thread_ids.extend(
|
|
overview
|
|
.active_refresh_thread_ids
|
|
.drain()
|
|
.filter(|id| !removed_threads.contains(id)),
|
|
);
|
|
overview
|
|
.view_state
|
|
.lock()
|
|
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
|
.loading = false;
|
|
}
|
|
overview
|
|
.pending_refresh_backends
|
|
.retain(|id| *id != backend_id);
|
|
if self.backend_registry.request_handle(backend_id).is_none() {
|
|
overview.refresh_failed_backends.remove(&backend_id);
|
|
}
|
|
self.drain_agents_overview_refresh_queue();
|
|
{
|
|
let mut state = self
|
|
.agents_overview
|
|
.view_state
|
|
.lock()
|
|
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
|
state.has_more = self.app_server_backend_id.is_some_and(|owner| {
|
|
self.agents_overview
|
|
.has_more_for(&self.backend_registry, owner)
|
|
});
|
|
state.refresh_failed = self.app_server_backend_id.is_some_and(|owner| {
|
|
self.agents_overview
|
|
.refresh_failed_backends
|
|
.contains(&owner)
|
|
});
|
|
}
|
|
self.repaint_agents_overview();
|
|
}
|
|
|
|
pub(super) fn repaint_agents_overview(&mut self) {
|
|
let Some(selected) = self
|
|
.chat_widget
|
|
.selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)
|
|
else {
|
|
return;
|
|
};
|
|
let previous_thread_id = self
|
|
.agents_overview
|
|
.visible_thread_ids
|
|
.get(selected)
|
|
.copied();
|
|
let selected_thread_id = self
|
|
.agents_overview
|
|
.view_state
|
|
.lock()
|
|
.unwrap_or_else(std::sync::PoisonError::into_inner)
|
|
.rename_target
|
|
.filter(|id| {
|
|
self.agents_overview.threads.contains_key(id)
|
|
&& !self.agents_overview.hidden_threads.contains(id)
|
|
})
|
|
.or(self.agents_overview.selection_after_removal.take())
|
|
.or(previous_thread_id);
|
|
let threads = self
|
|
.agents_overview
|
|
.threads
|
|
.values()
|
|
.flatten()
|
|
.cloned()
|
|
.collect();
|
|
let view = self.agents_overview_view(threads, selected_thread_id);
|
|
let matches = &mut self.agents_overview.search_matches;
|
|
if !matches.is_empty() {
|
|
let visible: HashSet<_> = view
|
|
.visible_indices()
|
|
.into_iter()
|
|
.map(|i| view.rows[i].thread_id)
|
|
.collect();
|
|
matches.retain(|id, _| {
|
|
visible.contains(id)
|
|
|| self.agents_overview.hidden_threads.contains(id)
|
|
|| self.agents_overview.pending_archives.contains_key(id)
|
|
});
|
|
}
|
|
view.load_search_matches(/*additional*/ 0);
|
|
self.agents_overview.visible_thread_ids = view.thread_ids();
|
|
let next_thread_id = view
|
|
.selected_index()
|
|
.and_then(|index| self.agents_overview.visible_thread_ids.get(index).copied());
|
|
if (previous_thread_id.is_none() || previous_thread_id != next_thread_id)
|
|
&& self
|
|
.chat_widget
|
|
.selected_index_for_active_view(AGENTS_OVERVIEW_VIEW_ID)
|
|
.is_some()
|
|
{
|
|
self.cancel_pending_key_chord();
|
|
}
|
|
if let Ok(mut state) = self.agents_overview.view_state.lock()
|
|
&& state
|
|
.rename_target
|
|
.is_some_and(|id| !self.agents_overview.visible_thread_ids.contains(&id))
|
|
{
|
|
self.chat_widget.add_info_message(
|
|
format!(
|
|
"The rename target disappeared. Unsubmitted title: {}",
|
|
state.input.text()
|
|
),
|
|
/*hint*/ None,
|
|
);
|
|
state.rename_target = None;
|
|
state.input.set_text_clearing_elements("");
|
|
}
|
|
self.chat_widget
|
|
.replace_bottom_pane_view_if_present(AGENTS_OVERVIEW_VIEW_ID, Box::new(view));
|
|
}
|
|
|
|
pub(super) fn agents_overview_view(
|
|
&self,
|
|
mut threads: Vec<Thread>,
|
|
selected_thread_id: Option<ThreadId>,
|
|
) -> AgentsOverviewView {
|
|
{
|
|
let overview = &self.agents_overview;
|
|
let mut state = overview
|
|
.view_state
|
|
.lock()
|
|
.unwrap_or_else(std::sync::PoisonError::into_inner);
|
|
state.vim_enabled = self.chat_widget.composer_is_vim_enabled();
|
|
if state
|
|
.history
|
|
.as_ref()
|
|
.is_some_and(|search| search.id == overview.search_id)
|
|
{
|
|
let query = state.search.to_lowercase();
|
|
threads.extend(
|
|
overview
|
|
.search_matches
|
|
.values()
|
|
.filter(|thread| {
|
|
super::agents_overview_discovery::matches_query(thread, &query)
|
|
})
|
|
.cloned(),
|
|
);
|
|
} else if let Some(target) = state
|
|
.rename_target
|
|
.and_then(|id| overview.search_matches.get(&id))
|
|
{
|
|
threads.push(target.clone());
|
|
}
|
|
}
|
|
threads.retain(|thread| {
|
|
is_visible_in_agents_overview(thread)
|
|
&& !ThreadId::from_string(&thread.id)
|
|
.is_ok_and(|id| self.agents_overview.pending_archives.contains_key(&id))
|
|
});
|
|
for thread in &mut threads {
|
|
if thread.parent_thread_id.is_none()
|
|
&& let SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
|
|
parent_thread_id, ..
|
|
}) = &thread.source
|
|
{
|
|
thread.parent_thread_id = Some(parent_thread_id.to_string());
|
|
}
|
|
}
|
|
let mut children: HashMap<String, Vec<&Thread>> = HashMap::new();
|
|
for thread in &threads {
|
|
if let Some(parent_thread_id) = &thread.parent_thread_id {
|
|
children
|
|
.entry(parent_thread_id.clone())
|
|
.or_default()
|
|
.push(thread);
|
|
}
|
|
}
|
|
|
|
let voice_owner = self.voice_owner_thread_id().map(|id| id.to_string());
|
|
let voice_session = threads
|
|
.iter()
|
|
.find(|thread| Some(&thread.id) == voice_owner.as_ref())
|
|
.map(|thread| &thread.session_id);
|
|
let mut roots = threads
|
|
.iter()
|
|
.filter(|thread| thread.parent_thread_id.is_none())
|
|
.map(|root| (root, agents_overview_group(root, &children)))
|
|
.collect::<Vec<_>>();
|
|
roots.sort_by(|(left, left_group), (right, right_group)| {
|
|
left_group
|
|
.cmp(right_group)
|
|
.then_with(|| right.updated_at.cmp(&left.updated_at))
|
|
.then_with(|| left.id.cmp(&right.id))
|
|
});
|
|
let mut rows = Vec::new();
|
|
for (root, group) in roots {
|
|
let Ok(thread_id) = ThreadId::from_string(&root.id) else {
|
|
continue;
|
|
};
|
|
if self.agents_overview.hidden_threads.contains(&thread_id) {
|
|
continue;
|
|
}
|
|
let backend_id = self
|
|
.backend_registry
|
|
.owner(thread_id)
|
|
.or(self.app_server_backend_id);
|
|
rows.push(AgentsOverviewRow {
|
|
backend_id,
|
|
label_style: backend_id
|
|
.map(|owner| self.backend_registry.thread_label_style(owner))
|
|
.unwrap_or_default(),
|
|
search_id: self
|
|
.agents_overview
|
|
.search_matches
|
|
.contains_key(&thread_id)
|
|
.then_some(self.agents_overview.search_id),
|
|
unread: self.agents_overview.unread.contains(&thread_id),
|
|
details: self.agents_overview_details(root, &children),
|
|
thread: root.clone(),
|
|
thread_id,
|
|
group,
|
|
is_current: self.primary_thread_id == Some(thread_id),
|
|
has_voice: voice_session == Some(&root.session_id),
|
|
});
|
|
}
|
|
|
|
let mut view = AgentsOverviewView::new(
|
|
rows,
|
|
selected_thread_id,
|
|
!crate::uses_remote_workspace_or_environment(
|
|
&self.app_server_target,
|
|
self.environment_manager.as_ref(),
|
|
),
|
|
self.local_settings.tui.status_line_use_colors,
|
|
self.app_event_tx.clone(),
|
|
self.keymap.clone(),
|
|
Arc::clone(&self.agents_overview.view_state),
|
|
);
|
|
let pins = &self.agents_overview.pins_by_backend;
|
|
view.pinned_thread_ranks = pins.values().any(Option::is_some).then(|| {
|
|
pins.values()
|
|
.flatten()
|
|
.flatten()
|
|
.copied()
|
|
.enumerate()
|
|
.map(|(rank, id)| (id, rank))
|
|
.collect()
|
|
});
|
|
view.can_return_to_chat =
|
|
self.pending_startup_thread_start || self.current_displayed_thread_id().is_some();
|
|
view.pin_action_supported = self
|
|
.displayed_conversation_backend_id()
|
|
.and_then(|owner| pins.get(&owner))
|
|
.map(Option::is_some)
|
|
.unwrap_or(true);
|
|
view.pin_action_pending = self.agents_overview.pending_pin_change.is_some();
|
|
view
|
|
}
|
|
|
|
pub(super) async fn select_agents_overview_thread(
|
|
&mut self,
|
|
tui: &mut tui::Tui,
|
|
app_server: &mut AppServerSession,
|
|
thread_id: ThreadId,
|
|
) -> Result<AppRunControl> {
|
|
// Selecting an already visible chat can just dismiss the overview.
|
|
let viewing_task = self.current_displayed_thread_id() == Some(thread_id)
|
|
&& (!self.thread_unavailable(thread_id) || self.chat_widget.is_external_writer_view());
|
|
if let Some(owner) = self.backend_registry.owner(thread_id)
|
|
&& (owner != app_server.backend_id()
|
|
|| (app_server.thread_params_mode()
|
|
== crate::app_server_session::ThreadParamsMode::Cloud
|
|
&& !self.chat_widget.fork_in_progress
|
|
&& !viewing_task))
|
|
{
|
|
let Some(thread) = self
|
|
.agents_overview
|
|
.threads
|
|
.get(&thread_id)
|
|
.and_then(Option::as_ref)
|
|
.or_else(|| self.agents_overview.search_matches.get(&thread_id))
|
|
else {
|
|
self.add_agents_overview_error(format!(
|
|
"Agent session {thread_id} is unavailable. Refresh Command Center and try again."
|
|
));
|
|
return Ok(AppRunControl::Continue);
|
|
};
|
|
self.app_event_tx
|
|
.send(AppEvent::ResumeBackendSession(SessionTarget {
|
|
backend_id: owner,
|
|
path: thread.path.clone(),
|
|
thread_id,
|
|
cwd: Some(thread.cwd.to_path_buf()),
|
|
history_mode: Some(thread.history_mode),
|
|
}));
|
|
return Ok(AppRunControl::Continue);
|
|
}
|
|
Box::pin(self.attach_agents_overview_thread(
|
|
tui, app_server, thread_id, /*started*/ None, /*startup_draft*/ None,
|
|
))
|
|
.await
|
|
}
|
|
|
|
async fn attach_agents_overview_thread(
|
|
&mut self,
|
|
tui: &mut tui::Tui,
|
|
app_server: &mut AppServerSession,
|
|
root_thread_id: ThreadId,
|
|
started: Option<(Config, crate::app_server_session::AppServerStartedThread)>,
|
|
mut startup_draft: Option<&mut StartupDraftPump>,
|
|
) -> color_eyre::Result<AppRunControl> {
|
|
if self.windows_sandbox_blocks_thread_switch() {
|
|
return Ok(AppRunControl::Continue);
|
|
}
|
|
let is_new_session = started.is_some();
|
|
if self.current_displayed_thread_id() == Some(root_thread_id)
|
|
&& (!self.thread_unavailable(root_thread_id) || self.chat_widget.is_read_only_view())
|
|
{
|
|
// Keep the displayed read-only snapshot frozen; R explicitly retries attachment.
|
|
if let Ok(mut state) = self.agents_overview.view_state.lock() {
|
|
state.completion = Some(crate::bottom_pane::ViewCompletion::Accepted);
|
|
}
|
|
self.chat_widget.pre_draw_tick();
|
|
return Ok(AppRunControl::Continue);
|
|
}
|
|
if self.reject_pending_permission_root_switch() {
|
|
return Ok(AppRunControl::Continue);
|
|
}
|
|
if startup_draft.is_none() {
|
|
loading::draw(tui)?;
|
|
}
|
|
let mut restored_blank_session = false;
|
|
let mut resumed_mode = None;
|
|
let mut provider_resume_checked = false;
|
|
if self.primary_thread_id != Some(root_thread_id) {
|
|
let previous_displayed_thread_id = self.current_displayed_thread_id();
|
|
if let Some(id) = previous_displayed_thread_id
|
|
&& let Some(blank) = self.agents_overview.blank_sessions.get_mut(&id)
|
|
&& let Some(channel) = self.thread_event_channels.get(&id)
|
|
&& let Some(session) = channel.store.lock().await.session.as_ref()
|
|
{
|
|
blank.session = session.clone();
|
|
}
|
|
let mut previous_thread_ids =
|
|
Vec::from_iter(self.thread_event_channels.keys().copied());
|
|
previous_thread_ids.extend(
|
|
self.agent_navigation
|
|
.tracked_thread_ids()
|
|
.into_iter()
|
|
.filter(|thread_id| !self.thread_event_channels.contains_key(thread_id)),
|
|
);
|
|
let mut previous_running_thread_ids = Vec::new();
|
|
let mut previous_pending_requests = Vec::new();
|
|
for thread_id in &previous_thread_ids {
|
|
if self.side_threads.contains_key(thread_id) {
|
|
continue;
|
|
}
|
|
if let Some(channel) = self.thread_event_channels.get(thread_id) {
|
|
let store = channel.store.lock().await;
|
|
if store.active_turn_id().is_some() {
|
|
previous_running_thread_ids.push(*thread_id);
|
|
}
|
|
if let Some(input_state) = store.input_state.clone() {
|
|
self.agents_overview
|
|
.input_states
|
|
.insert(*thread_id, input_state);
|
|
}
|
|
let requests: Vec<_> = store
|
|
.pending_replay_requests()
|
|
.into_iter()
|
|
.filter_map(|request| {
|
|
self.pending_app_server_requests.buffered_request(request)
|
|
})
|
|
.collect();
|
|
if !requests.is_empty() {
|
|
previous_pending_requests.push((*thread_id, requests));
|
|
}
|
|
} else if self
|
|
.agent_navigation
|
|
.get(thread_id)
|
|
.is_some_and(|entry| entry.is_running)
|
|
{
|
|
previous_running_thread_ids.push(*thread_id);
|
|
}
|
|
}
|
|
if let Some(active_thread_id) = self.current_displayed_thread_id()
|
|
&& let Some(input_state) = self.chat_widget.capture_thread_input_state()
|
|
{
|
|
self.agents_overview
|
|
.input_states
|
|
.insert(active_thread_id, input_state);
|
|
}
|
|
|
|
let target_thread = match StartupDraftPump::run_with_optional_draft(
|
|
startup_draft.as_deref_mut(),
|
|
tui,
|
|
app_server.thread_read(root_thread_id, /*include_turns*/ false),
|
|
)
|
|
.await
|
|
{
|
|
Ok(thread) => thread,
|
|
Err(error) => {
|
|
self.add_agents_overview_error(format!(
|
|
"Agent session {root_thread_id} is unavailable: {error}"
|
|
));
|
|
return Ok(AppRunControl::Continue);
|
|
}
|
|
};
|
|
let unloaded = matches!(
|
|
target_thread.status,
|
|
codex_app_server_protocol::ThreadStatus::NotLoaded
|
|
);
|
|
let preserve_explicit_permissions = unloaded || started.is_some();
|
|
let (mut resume_config, mut local_settings) = if let Some((config, _)) = &started {
|
|
(config.clone(), self.local_settings.reloaded(config))
|
|
} else if unloaded {
|
|
let target_session = SessionTarget {
|
|
backend_id: app_server.backend_id(),
|
|
path: target_thread.path.clone(),
|
|
thread_id: root_thread_id,
|
|
cwd: Some(target_thread.cwd.to_path_buf()),
|
|
history_mode: Some(target_thread.history_mode),
|
|
};
|
|
match self
|
|
.resume_config_for_target(
|
|
tui,
|
|
app_server,
|
|
&target_session,
|
|
super::resume_preparation::ResumeSource::Active,
|
|
)
|
|
.await
|
|
{
|
|
Ok(config) => config,
|
|
Err(control) => return Ok(control),
|
|
}
|
|
} else {
|
|
let config_cwd = if self.app_server_target.uses_remote_workspace() {
|
|
self.config.cwd.to_path_buf()
|
|
} else {
|
|
target_thread.cwd.to_path_buf()
|
|
};
|
|
let current_cwd = self.config.cwd.to_path_buf();
|
|
match self
|
|
.rebuild_config_for_resume_or_fallback(
|
|
¤t_cwd,
|
|
config_cwd,
|
|
(&self.config, &self.local_settings),
|
|
&self.app_server_target,
|
|
)
|
|
.await
|
|
{
|
|
Ok(config) => config,
|
|
Err(error) => {
|
|
self.add_agents_overview_error(format!(
|
|
"Failed to load task settings: {error}"
|
|
));
|
|
return Ok(AppRunControl::Continue);
|
|
}
|
|
}
|
|
};
|
|
if !unloaded && started.is_none() {
|
|
match self
|
|
.confirm_directory_trust(
|
|
tui,
|
|
app_server,
|
|
&mut resume_config,
|
|
target_thread.cwd.as_path(),
|
|
crate::onboarding::DirectoryTrustOptions {
|
|
resumed_thread: Some(&target_thread),
|
|
..Default::default()
|
|
},
|
|
/*startup_draft*/ None,
|
|
)
|
|
.await
|
|
{
|
|
Ok(Some(reloaded)) => local_settings = reloaded,
|
|
Ok(None) => {}
|
|
Err(control) => return Ok(control),
|
|
}
|
|
}
|
|
// Folder selection and trust prompts can replace or clear the loading frame.
|
|
if startup_draft.is_none() {
|
|
loading::draw(tui)?;
|
|
}
|
|
let baseline_approval = resume_config.permissions.approval_policy.value();
|
|
let baseline_reviewer = resume_config.approvals_reviewer;
|
|
let baseline_permissions =
|
|
RuntimePermissionProfileOverride::from_config(&resume_config);
|
|
let resume_model_settings = match target_thread.status {
|
|
codex_app_server_protocol::ThreadStatus::NotLoaded => {
|
|
if let Err(error) = self.apply_runtime_policy_overrides(
|
|
&mut resume_config,
|
|
RuntimePolicyOverrideScope::ExplicitOnly,
|
|
) {
|
|
self.add_agents_overview_error(format!("{error:#}"));
|
|
return Ok(AppRunControl::Continue);
|
|
}
|
|
if matches!(self.runtime_approval_policy_override,
|
|
Some(RuntimeApprovalPolicyOverride::Explicit(policy))
|
|
if policy.to_core() != resume_config.permissions.approval_policy.value())
|
|
|| self
|
|
.runtime_permission_profile_override
|
|
.as_ref()
|
|
.is_some_and(|profile| {
|
|
profile.turn_override
|
|
== RuntimePermissionProfileTurnOverride::LegacySandbox
|
|
&& !profile.matches_config(&resume_config)
|
|
})
|
|
{
|
|
self.add_agents_overview_error(
|
|
"Cannot resume task without preserving the selected permissions."
|
|
.to_string(),
|
|
);
|
|
return Ok(AppRunControl::Continue);
|
|
}
|
|
self.resume_model_settings()
|
|
}
|
|
codex_app_server_protocol::ThreadStatus::Idle
|
|
| codex_app_server_protocol::ThreadStatus::Active { .. }
|
|
| codex_app_server_protocol::ThreadStatus::SystemError => {
|
|
crate::app_server_session::ResumeModelSettings::PreserveExistingThread
|
|
}
|
|
};
|
|
let mut history_notice = None;
|
|
let mut provider_error = None;
|
|
let presentation = if startup_draft.is_some() {
|
|
ThreadAttachPresentation::FreshWithDraft
|
|
} else if started.is_some() {
|
|
ThreadAttachPresentation::Fresh
|
|
} else {
|
|
ThreadAttachPresentation::SessionLineage
|
|
};
|
|
let (resumed, read_only) = if let Some((_, started)) = started {
|
|
(started, false)
|
|
} else if let Some(blank) = self
|
|
.live_blank_session(app_server, root_thread_id, &target_thread)
|
|
.await
|
|
{
|
|
restored_blank_session = true;
|
|
(blank, false)
|
|
} else {
|
|
match app_server
|
|
.resume_thread_with_permission_overrides(
|
|
&local_settings,
|
|
resume_config.clone(),
|
|
root_thread_id,
|
|
resume_model_settings,
|
|
self.resume_permission_overrides(&resume_config),
|
|
)
|
|
.await
|
|
{
|
|
Ok(resumed) => {
|
|
provider_resume_checked = true;
|
|
resumed_mode = Some(resumed.session.collaboration_mode.is_some());
|
|
(resumed, false)
|
|
}
|
|
Err(error)
|
|
if crate::app_server_session::is_active_writer_error(&error)
|
|
|| crate::app_server_session::model_provider_error(&error)
|
|
.is_some() =>
|
|
{
|
|
provider_resume_checked = true;
|
|
provider_error = crate::app_server_session::model_provider_error(&error);
|
|
match app_server
|
|
.read_thread_for_viewing(
|
|
&resume_config,
|
|
&local_settings,
|
|
root_thread_id,
|
|
)
|
|
.await
|
|
{
|
|
Ok((thread, notice)) => {
|
|
history_notice = notice;
|
|
(thread, true)
|
|
}
|
|
Err(_) => {
|
|
tracing::warn!("Failed to load read-only conversation history");
|
|
self.add_agents_overview_error(
|
|
"Couldn't load this conversation. Please try again."
|
|
.to_string(),
|
|
);
|
|
return Ok(AppRunControl::Continue);
|
|
}
|
|
}
|
|
}
|
|
Err(error) => {
|
|
self.add_agents_overview_error(format!(
|
|
"Failed to attach to task: {error}"
|
|
));
|
|
return Ok(AppRunControl::Continue);
|
|
}
|
|
}
|
|
};
|
|
for (thread_id, requests) in previous_pending_requests {
|
|
self.agents_overview
|
|
.dispatched_requests
|
|
.entry(thread_id)
|
|
.or_default()
|
|
.extend(requests);
|
|
}
|
|
if !previous_running_thread_ids.is_empty() {
|
|
for thread_id in &previous_thread_ids {
|
|
if !self.side_threads.contains_key(thread_id) {
|
|
self.agents_overview
|
|
.dispatched_requests
|
|
.entry(*thread_id)
|
|
.or_default();
|
|
}
|
|
}
|
|
}
|
|
if previous_running_thread_ids.is_empty()
|
|
&& !previous_displayed_thread_id
|
|
.is_some_and(|id| self.agents_overview.blank_sessions.contains_key(&id))
|
|
{
|
|
match startup_draft.as_deref_mut() {
|
|
Some(draft) => {
|
|
draft
|
|
.run_until(
|
|
tui,
|
|
self.detach_current_thread_for_navigation(
|
|
app_server,
|
|
Some(root_thread_id),
|
|
),
|
|
)
|
|
.await?
|
|
}
|
|
None => {
|
|
self.detach_current_thread_for_navigation(app_server, Some(root_thread_id))
|
|
.await
|
|
}
|
|
}
|
|
}
|
|
// Read-only views retain explicit choices but never another task's restored state.
|
|
let preserve_explicit_permissions = preserve_explicit_permissions || read_only;
|
|
self.runtime_approvals_reviewer_override = self
|
|
.runtime_approvals_reviewer_override
|
|
.filter(|_| preserve_explicit_permissions);
|
|
self.runtime_approval_policy_override =
|
|
self.runtime_approval_policy_override.filter(|policy| {
|
|
preserve_explicit_permissions
|
|
&& matches!(policy, RuntimeApprovalPolicyOverride::Explicit(_))
|
|
});
|
|
self.runtime_permission_profile_override = self
|
|
.runtime_permission_profile_override
|
|
.take()
|
|
.filter(|profile| {
|
|
preserve_explicit_permissions
|
|
&& profile.turn_override
|
|
== RuntimePermissionProfileTurnOverride::LegacySandbox
|
|
});
|
|
self.local_settings = local_settings;
|
|
self.refresh_server_version_overview_notice(CODEX_CLI_VERSION);
|
|
self.config = resume_config;
|
|
tui.set_notification_settings(
|
|
self.local_settings.tui.notification_settings.method,
|
|
self.local_settings.tui.notification_settings.condition,
|
|
);
|
|
self.file_search
|
|
.update_search_dir(self.config.cwd.to_path_buf());
|
|
if let Err(error) = self
|
|
.replace_chat_widget_with_app_server_thread(
|
|
tui,
|
|
resumed,
|
|
presentation,
|
|
/*initial_user_message*/ None,
|
|
)
|
|
.await
|
|
{
|
|
self.add_agents_overview_error(format!("Failed to attach to task: {error}"));
|
|
return Ok(AppRunControl::Continue);
|
|
}
|
|
if !is_new_session && !restored_blank_session {
|
|
self.agents_overview.blank_sessions.remove(&root_thread_id);
|
|
}
|
|
// Replacing the widget clears the terminal before the remaining server requests.
|
|
if startup_draft.is_none() {
|
|
loading::draw(tui)?;
|
|
}
|
|
if let Some(error) = provider_error {
|
|
self.chat_widget
|
|
.show_provider_error(error, /*rejected_message_id*/ None);
|
|
} else if read_only {
|
|
self.ensure_thread_channel(root_thread_id)
|
|
.mark_external_writer();
|
|
self.chat_widget.show_external_writer_thread();
|
|
}
|
|
if let Some(notice) = history_notice {
|
|
self.chat_widget
|
|
.add_info_message(notice.to_string(), /*hint*/ None);
|
|
}
|
|
let mut destination_config = self.chat_widget.config_ref().clone();
|
|
if self.app_server_target.uses_remote_workspace() {
|
|
destination_config.cwd.clone_from(&self.config.cwd);
|
|
destination_config
|
|
.workspace_roots
|
|
.clone_from(&self.config.workspace_roots);
|
|
destination_config
|
|
.permissions
|
|
.set_workspace_roots(self.config.permissions.workspace_roots().to_vec());
|
|
}
|
|
self.config = destination_config;
|
|
if is_new_session {
|
|
self.remember_launch_permissions();
|
|
}
|
|
if !read_only {
|
|
let approval = self.config.permissions.approval_policy.value();
|
|
if self
|
|
.runtime_approval_policy_override
|
|
.is_none_or(|policy| policy.policy().to_core() != approval)
|
|
{
|
|
self.runtime_approval_policy_override = (approval != baseline_approval)
|
|
.then_some(RuntimeApprovalPolicyOverride::Restored(approval.into()));
|
|
}
|
|
if self
|
|
.runtime_permission_profile_override
|
|
.as_ref()
|
|
.is_none_or(|profile| !profile.matches_config(&self.config))
|
|
{
|
|
self.runtime_permission_profile_override = (!baseline_permissions
|
|
.matches_config(&self.config)
|
|
|| baseline_reviewer != self.config.approvals_reviewer)
|
|
.then(|| {
|
|
RuntimePermissionProfileOverride::from_restored_config(&self.config)
|
|
});
|
|
}
|
|
}
|
|
// A new session has no descendants. Scanning every loaded thread here
|
|
// adds a serial round trip per agent before the composer can render.
|
|
if !is_new_session
|
|
&& !self
|
|
.backfill_loaded_subagent_threads(app_server)
|
|
.await
|
|
.completed
|
|
{
|
|
self.backfill_loaded_subagent_threads(app_server).await;
|
|
}
|
|
for thread_id in previous_thread_ids {
|
|
if previous_running_thread_ids.is_empty()
|
|
&& thread_id != root_thread_id
|
|
&& !self.side_threads.contains_key(&thread_id)
|
|
&& self.voice_owner_thread_id() != Some(thread_id)
|
|
&& Some(thread_id) != previous_displayed_thread_id
|
|
&& !self.agents_overview.blank_sessions.contains_key(&thread_id)
|
|
&& let Err(error) = StartupDraftPump::run_with_optional_draft(
|
|
startup_draft.as_deref_mut(),
|
|
tui,
|
|
app_server.thread_unsubscribe(thread_id),
|
|
)
|
|
.await
|
|
{
|
|
tracing::warn!(%thread_id, %error, "failed to unsubscribe previous agent thread");
|
|
}
|
|
}
|
|
}
|
|
|
|
if self.current_displayed_thread_id() != Some(root_thread_id)
|
|
|| (self.thread_unavailable(root_thread_id) && !self.chat_widget.is_read_only_view())
|
|
{
|
|
self.select_agent_thread(tui, app_server, root_thread_id)
|
|
.await?;
|
|
}
|
|
if self.current_displayed_thread_id() == Some(root_thread_id) {
|
|
self.remember_attached_host_project(app_server);
|
|
}
|
|
let read_only = self.chat_widget.is_read_only_view();
|
|
if !read_only {
|
|
self.replay_agents_overview_requests(app_server, root_thread_id)
|
|
.await;
|
|
}
|
|
if self.current_displayed_thread_id() == Some(root_thread_id)
|
|
&& let Some(mut input_state) = self.agents_overview.input_states.remove(&root_thread_id)
|
|
{
|
|
// A fresh server result supersedes the saved rejection, but not the draft.
|
|
if provider_resume_checked {
|
|
input_state.provider_error = None;
|
|
}
|
|
if let Some(has_resumed_mode) = resumed_mode {
|
|
self.chat_widget
|
|
.update_input_collaboration_mode(&mut input_state, has_resumed_mode);
|
|
}
|
|
// A saved draft includes model settings, so apply newer server settings after it.
|
|
let pending_settings = restored_blank_session
|
|
.then(|| input_state.pending_thread_settings.take())
|
|
.flatten();
|
|
self.restore_session_draft(root_thread_id, input_state, pending_settings)
|
|
.await;
|
|
}
|
|
if !read_only && !is_new_session && !self.chat_widget.fork_in_progress {
|
|
self.maybe_prompt_resume_paused_goal_after_resume(app_server, root_thread_id)
|
|
.await;
|
|
}
|
|
|
|
Ok(AppRunControl::Continue)
|
|
}
|
|
|
|
pub(super) async fn restore_session_draft(
|
|
&mut self,
|
|
thread_id: ThreadId,
|
|
mut input: ThreadInputState,
|
|
pending_settings: Option<codex_app_server_protocol::ThreadSettingsUpdatedNotification>,
|
|
) {
|
|
let preserve_in_flight_turn = !self.chat_widget.is_read_only_view()
|
|
&& self.active_turn_id_for_thread(thread_id).await.is_some();
|
|
self.reconcile_saved_session_input(thread_id, &mut input)
|
|
.await;
|
|
// Missing receipts must not turn a previously submitted steer into unsent input.
|
|
input.reconnect_pending |= !preserve_in_flight_turn && !input.pending_steers.is_empty();
|
|
self.chat_widget.restore_thread_input_state(
|
|
Some(input),
|
|
ThreadInputStateRestoreMode {
|
|
preserve_in_flight_turn,
|
|
},
|
|
);
|
|
if let Some(settings) = pending_settings {
|
|
self.chat_widget.on_thread_settings_updated(settings);
|
|
}
|
|
if !preserve_in_flight_turn {
|
|
self.chat_widget.maybe_send_next_queued_input();
|
|
}
|
|
}
|
|
|
|
pub(super) async fn replay_agents_overview_requests(
|
|
&mut self,
|
|
app_server: &AppServerSession,
|
|
root_thread_id: ThreadId,
|
|
) {
|
|
let requests = self
|
|
.agents_overview
|
|
.dispatched_requests
|
|
.extract_if(|id, _| *id == root_thread_id || self.agent_navigation.get(id).is_some())
|
|
.flat_map(|(_, requests)| requests)
|
|
.collect::<Vec<_>>();
|
|
for request in requests {
|
|
self.handle_server_request_event(app_server, request).await;
|
|
}
|
|
}
|
|
|
|
async fn agents_overview_session_config(
|
|
&mut self,
|
|
tui: &mut tui::Tui,
|
|
app_server: &mut AppServerSession,
|
|
cwd: Option<AbsolutePathBuf>,
|
|
mut startup_draft: Option<&mut StartupDraftPump>,
|
|
) -> Option<(Config, Option<PathBuf>)> {
|
|
if self
|
|
.chat_widget
|
|
.thread_id()
|
|
.is_some_and(|thread_id| self.pending_server_profiles.contains_key(&thread_id))
|
|
{
|
|
self.add_agents_overview_error(
|
|
"Wait for permissions to update before starting a session.".into(),
|
|
);
|
|
return None;
|
|
}
|
|
let remote = app_server.uses_remote_workspace();
|
|
let remote_cwd = cwd
|
|
.as_ref()
|
|
.filter(|_| remote)
|
|
.map(AbsolutePathBuf::to_path_buf);
|
|
let local_cwd = if remote {
|
|
self.config.cwd.to_path_buf()
|
|
} else {
|
|
cwd.map_or_else(
|
|
|| self.chat_widget.config_ref().cwd.to_path_buf(),
|
|
|cwd| cwd.to_path_buf(),
|
|
)
|
|
};
|
|
let mut config = match StartupDraftPump::run_with_optional_draft(
|
|
startup_draft.as_deref_mut(),
|
|
tui,
|
|
self.rebuild_config_for_cwd(local_cwd),
|
|
)
|
|
.await
|
|
{
|
|
Ok(config) => config,
|
|
Err(error) => {
|
|
self.add_agents_overview_error(format!("Failed to load project settings: {error}"));
|
|
return None;
|
|
}
|
|
};
|
|
let trust_cwd = config.cwd.to_path_buf();
|
|
if self
|
|
.confirm_directory_trust(
|
|
tui,
|
|
app_server,
|
|
&mut config,
|
|
&trust_cwd,
|
|
crate::onboarding::DirectoryTrustOptions::default(),
|
|
startup_draft.as_deref_mut(),
|
|
)
|
|
.await
|
|
.is_err()
|
|
{
|
|
return None;
|
|
}
|
|
if let Some(profile) = self.runtime_permission_profile_override.as_ref()
|
|
&& profile.turn_override == RuntimePermissionProfileTurnOverride::LegacySandbox
|
|
&& profile
|
|
.active_permission_profile
|
|
.as_ref()
|
|
.is_some_and(|active| !active.id.starts_with(':'))
|
|
&& self.chat_widget.thread_id().is_none_or(|thread_id| {
|
|
self.agents_overview
|
|
.selected_permission_profiles
|
|
.get(&thread_id)
|
|
!= profile
|
|
.active_permission_profile
|
|
.as_ref()
|
|
.map(|active| &active.id)
|
|
})
|
|
&& (!profile.matches_config(&config)
|
|
|| config.permissions.profile_workspace_roots()
|
|
!= self.config.permissions.profile_workspace_roots())
|
|
{
|
|
self.add_agents_overview_error(
|
|
"Permission profile has different settings.".to_string(),
|
|
);
|
|
return None;
|
|
}
|
|
let defaults_cwd = match app_server.thread_params_mode() {
|
|
crate::app_server_session::ThreadParamsMode::Embedded => config.cwd.as_path(),
|
|
crate::app_server_session::ThreadParamsMode::Remote
|
|
| crate::app_server_session::ThreadParamsMode::Cloud => remote_cwd
|
|
.as_deref()
|
|
.or_else(|| app_server.remote_cwd_override())
|
|
.unwrap_or(Path::new(".")),
|
|
}
|
|
.to_path_buf();
|
|
if let Some(draft) = startup_draft.as_deref_mut() {
|
|
draft.apply_settings(
|
|
&crate::local_settings::LocalSettings::from(&config),
|
|
config.cwd.as_path(),
|
|
);
|
|
}
|
|
let mut server_model_cleared = false;
|
|
match StartupDraftPump::run_with_optional_draft(
|
|
startup_draft,
|
|
tui,
|
|
crate::config_update::read_effective_config_if_supported(
|
|
app_server.request_handle(),
|
|
&defaults_cwd,
|
|
),
|
|
)
|
|
.await
|
|
{
|
|
Ok(Some(defaults)) => {
|
|
crate::projectless::apply_defaults(
|
|
&mut config,
|
|
&self.harness_overrides,
|
|
app_server,
|
|
&self.environment_manager,
|
|
&defaults,
|
|
);
|
|
let defaults = defaults.config;
|
|
server_model_cleared = defaults.model.is_none();
|
|
let use_server_provider = matches!(
|
|
app_server.thread_params_mode(),
|
|
crate::app_server_session::ThreadParamsMode::Embedded
|
|
) && self.harness_overrides.model.is_none()
|
|
&& !super::new_session::has_launch_setting(
|
|
&config,
|
|
&self.cli_kv_overrides,
|
|
"model",
|
|
)
|
|
&& self.harness_overrides.model_provider.is_none()
|
|
&& !super::new_session::has_launch_setting(
|
|
&config,
|
|
&self.cli_kv_overrides,
|
|
"model_provider",
|
|
);
|
|
super::new_session::overlay_new_session_defaults(
|
|
&mut config,
|
|
&defaults,
|
|
&self.cli_kv_overrides,
|
|
&self.harness_overrides,
|
|
);
|
|
// Embedded thread/start sends a provider ID alongside the selected model.
|
|
if use_server_provider {
|
|
config.model_provider_id = defaults
|
|
.model_provider
|
|
.unwrap_or_else(|| "openai".to_string());
|
|
}
|
|
}
|
|
Ok(None) => {}
|
|
Err(error) => {
|
|
self.add_agents_overview_error(format!(
|
|
"Failed to load new session settings: {error}"
|
|
));
|
|
return None;
|
|
}
|
|
}
|
|
// New sessions inherit explicit choices, not permissions restored from another task.
|
|
if let Err(error) = self
|
|
.apply_runtime_policy_overrides(&mut config, RuntimePolicyOverrideScope::ExplicitOnly)
|
|
{
|
|
self.add_agents_overview_error(format!("{error:#}"));
|
|
return None;
|
|
}
|
|
apply_managed_new_thread_defaults(
|
|
&mut config,
|
|
app_server.managed_new_thread_defaults(),
|
|
&self.cli_kv_overrides,
|
|
&self.harness_overrides,
|
|
);
|
|
if server_model_cleared
|
|
&& config.model.is_none()
|
|
&& (config.features.enabled(Feature::FastMode)
|
|
|| config.features.enabled(Feature::UltrafastMode))
|
|
{
|
|
// Bootstrap's fallback model may be seeded from the client. Resolve tiers
|
|
// against the server catalog when config/read cleared the model.
|
|
config.model = self
|
|
.model_catalog
|
|
.models
|
|
.iter()
|
|
.find(|model| model.is_default)
|
|
.or_else(|| self.model_catalog.models.first())
|
|
.map(|model| model.model.clone());
|
|
}
|
|
Some((config, remote_cwd))
|
|
}
|
|
|
|
pub(super) async fn stop_agents_overview_thread(
|
|
&mut self,
|
|
app_server: &mut AppServerSession,
|
|
thread_id: ThreadId,
|
|
) {
|
|
let active_turn_id = match self.active_turn_id_for_thread(thread_id).await {
|
|
Some(turn_id) => Some(turn_id),
|
|
None => match async {
|
|
let thread = app_server
|
|
.thread_read(thread_id, /*include_turns*/ false)
|
|
.await?;
|
|
let turns = match thread.history_mode {
|
|
ThreadHistoryMode::Paginated if app_server.supports_paginated_history() => {
|
|
app_server
|
|
.thread_turns_page(
|
|
thread_id,
|
|
/*cursor*/ None,
|
|
crate::app_server_session::INITIAL_HISTORY_TURN_LIMIT,
|
|
)
|
|
.await?
|
|
.data
|
|
}
|
|
ThreadHistoryMode::Legacy | ThreadHistoryMode::Paginated => {
|
|
app_server
|
|
.thread_read(thread_id, /*include_turns*/ true)
|
|
.await?
|
|
.turns
|
|
}
|
|
};
|
|
Ok::<_, color_eyre::Report>(
|
|
turns
|
|
.into_iter()
|
|
.find(|turn| turn.status == TurnStatus::InProgress)
|
|
.map(|turn| turn.id),
|
|
)
|
|
}
|
|
.await
|
|
{
|
|
Ok(turn_id) => turn_id,
|
|
Err(error) => {
|
|
self.add_agents_overview_error(format!(
|
|
"Failed to stop background task: {error}"
|
|
));
|
|
self.refresh_agents_overview_threads(app_server);
|
|
return;
|
|
}
|
|
},
|
|
};
|
|
let Some(turn_id) = active_turn_id else {
|
|
return;
|
|
};
|
|
if let Err(error) = app_server.turn_interrupt(thread_id, turn_id).await {
|
|
self.add_agents_overview_error(format!("Failed to stop background task: {error}"));
|
|
self.refresh_agents_overview_threads(app_server);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[path = "agents_overview_tests.rs"]
|
|
pub(super) mod tests;
|
|
|
|
fn agents_overview_group(
|
|
thread: &Thread,
|
|
children: &HashMap<String, Vec<&Thread>>,
|
|
) -> AgentsOverviewGroup {
|
|
children
|
|
.get(&thread.id)
|
|
.into_iter()
|
|
.flatten()
|
|
.fold(AgentsOverviewGroup::for_thread(thread), |group, child| {
|
|
group.min(agents_overview_group(child, children))
|
|
})
|
|
}
|