mirror of
https://github.com/openai/codex.git
synced 2026-11-15 21:50:46 +00:00
## Why Command-center navigation required a shared app server, leaving embedded sessions without the same way to switch between chats. Archiving or deleting an embedded session also exited the TUI. ## What changed - Enable command-center navigation and session listing for embedded sessions, including navigation from read-only conversations and the safety precaution menu. - Return to the command center after archiving or deleting a session. - Retain thread subscriptions when forking, including on embedded servers. - Confirm before quitting an embedded server would stop running sessions or side conversations. - Construct large startup and event-loop futures outside their callers' stack frames before boxing them. ## Testing Add regression coverage for embedded session switching with background approvals and draft restoration, plus confirmation before quitting with a running side conversation. Update navigation, archive/delete, fork, and UI snapshot tests for the new behavior. GitOrigin-RevId: 96bac48cccf85b685b58934d23dd1db93b663751
249 lines
9.2 KiB
Rust
249 lines
9.2 KiB
Rust
//! Block ordinary input after a misalignment failure. Live findings can be reviewed and
|
||
//! explicitly acknowledged; review identity prevents stale UI actions from authorizing a turn.
|
||
|
||
use super::*;
|
||
use codex_app_server_protocol::MisalignmentErrorDetails;
|
||
|
||
const PRECAUTION_VIEW: &str = "misalignment_precaution";
|
||
|
||
#[derive(Debug)]
|
||
pub(crate) struct MisalignmentReview {
|
||
pub(crate) thread_id: ThreadId,
|
||
pub(crate) turn_id: String,
|
||
pub(crate) details: MisalignmentErrorDetails,
|
||
}
|
||
|
||
impl MisalignmentReview {
|
||
pub(crate) fn continuation_message(&self) -> Option<&str> {
|
||
self.details
|
||
.steer
|
||
.as_ref()
|
||
.map(|steer| steer.message.as_str())
|
||
.filter(|message| !message.trim().is_empty() && message.len() <= 1024)
|
||
}
|
||
}
|
||
|
||
pub(super) struct MisalignmentViolation {
|
||
turn_id: Option<String>,
|
||
review: Option<Arc<MisalignmentReview>>,
|
||
retired_voice: bool,
|
||
}
|
||
|
||
#[derive(Clone, Copy, Eq, PartialEq)]
|
||
pub(crate) enum MisalignmentTurnSource {
|
||
ServerNotification,
|
||
AcknowledgedContinuation,
|
||
}
|
||
|
||
const MISALIGNMENT_POLICY_TITLE: &str = "Chat stopped as a precaution";
|
||
const MISALIGNMENT_POLICY_DESCRIPTION: &str = "We couldn’t confirm the agent was acting safely and following your instructions. To continue working, start or resume another chat.";
|
||
|
||
impl ChatWidget {
|
||
pub(crate) fn has_misalignment_policy_violation(&self) -> bool {
|
||
self.misalignment_policy_violation.is_some()
|
||
}
|
||
|
||
pub(crate) fn rejects_misalignment_policy_op(&self, op: &AppCommand) -> bool {
|
||
self.misalignment_policy_violation.is_some()
|
||
&& !matches!(
|
||
op,
|
||
AppCommand::Interrupt
|
||
| AppCommand::RealtimeConversationStop { .. }
|
||
| AppCommand::CleanBackgroundTerminals
|
||
| AppCommand::OverrideTurnContext { .. }
|
||
| AppCommand::ReloadUserConfig
|
||
| AppCommand::ListSkills { .. }
|
||
| AppCommand::SetThreadName { .. }
|
||
)
|
||
}
|
||
|
||
pub(crate) fn on_misalignment_policy_violation(&mut self) {
|
||
self.on_misalignment_error(/*turn_id*/ None, /*details*/ None);
|
||
}
|
||
|
||
pub(super) fn on_misalignment_error(
|
||
&mut self,
|
||
turn_id: Option<String>,
|
||
details: Option<MisalignmentErrorDetails>,
|
||
) {
|
||
if let (Some(turn_id), Some(latest)) = (&turn_id, &self.turn_lifecycle.last_turn_id)
|
||
&& turn_id != latest
|
||
{
|
||
return;
|
||
}
|
||
// Bound memory-only findings and newly submitted model input. Never truncate a steer.
|
||
let missing_details = details.is_none();
|
||
let details = details.filter(|details| {
|
||
details
|
||
.detailed_explanation
|
||
.as_ref()
|
||
.is_some_and(|text| !text.trim().is_empty() && text.len() <= 64 * 1024)
|
||
});
|
||
if let Some(current) = &self.misalignment_policy_violation
|
||
// A parent-thread precaution cannot become a continuable side-thread warning.
|
||
&& (current.turn_id.is_none()
|
||
|| (current.turn_id == turn_id
|
||
&& (missing_details
|
||
|| current.review.as_ref().map(|review| &review.details) == details.as_ref())))
|
||
{
|
||
return;
|
||
}
|
||
let retired_voice = self.realtime_conversation_is_running();
|
||
if retired_voice {
|
||
self.stop_realtime_conversation();
|
||
}
|
||
let review = self.thread_id.zip(turn_id.clone()).zip(details).map(
|
||
|((thread_id, turn_id), details)| {
|
||
Arc::new(MisalignmentReview {
|
||
thread_id,
|
||
turn_id,
|
||
details,
|
||
})
|
||
},
|
||
);
|
||
self.misalignment_policy_violation = Some(MisalignmentViolation {
|
||
turn_id,
|
||
review,
|
||
retired_voice,
|
||
});
|
||
self.input_queue.clear();
|
||
self.finalize_turn();
|
||
self.refresh_pending_input_preview();
|
||
self.bottom_pane.drain_pending_submission_state();
|
||
self.bottom_pane
|
||
.set_composer_text(String::new(), Vec::new(), Vec::new());
|
||
self.bottom_pane.set_composer_input_enabled(
|
||
/*enabled*/ false,
|
||
Some(MISALIGNMENT_POLICY_TITLE.to_string()),
|
||
);
|
||
|
||
self.show_misalignment_policy_precaution();
|
||
}
|
||
|
||
pub(crate) fn show_misalignment_policy_precaution(&mut self) {
|
||
if !self.has_misalignment_policy_violation() {
|
||
return;
|
||
}
|
||
self.bottom_pane.dismiss_view_by_id(PRECAUTION_VIEW);
|
||
let mut items = vec![
|
||
SelectionItem {
|
||
name: "New chat".to_string(),
|
||
actions: vec![Box::new(|tx| tx.send(AppEvent::NewSession { name: None }))],
|
||
dismiss_on_select: true,
|
||
..Default::default()
|
||
},
|
||
SelectionItem {
|
||
name: "Resume another chat".to_string(),
|
||
actions: vec![Box::new(|tx| tx.send(AppEvent::OpenResumePicker))],
|
||
..Default::default()
|
||
},
|
||
];
|
||
let review = self
|
||
.misalignment_policy_violation
|
||
.as_ref()
|
||
.and_then(|violation| violation.review.clone());
|
||
if let Some(review) = &review {
|
||
let review = Arc::clone(review);
|
||
items.insert(
|
||
0,
|
||
SelectionItem {
|
||
name: "Review findings".to_string(),
|
||
actions: vec![Box::new(move |tx| {
|
||
tx.send(AppEvent::ReviewMisalignment(Arc::clone(&review)));
|
||
})],
|
||
..Default::default()
|
||
},
|
||
);
|
||
}
|
||
items.insert(
|
||
1,
|
||
SelectionItem {
|
||
name: "Agent command center".to_string(),
|
||
actions: vec![Box::new(|tx| tx.send(AppEvent::OpenAgentsOverview))],
|
||
..Default::default()
|
||
},
|
||
);
|
||
self.bottom_pane.show_selection_view(SelectionViewParams {
|
||
view_id: Some(PRECAUTION_VIEW),
|
||
header: Box::new(
|
||
Paragraph::new(vec![
|
||
Line::from(if review.is_some() { "Chat paused as a precaution" } else { MISALIGNMENT_POLICY_TITLE }).bold(),
|
||
Line::from(if review.is_some() {
|
||
"We couldn’t confirm the agent was interpreting your instructions correctly. Review what we detected before deciding to continue."
|
||
} else { MISALIGNMENT_POLICY_DESCRIPTION }).dim(),
|
||
])
|
||
.wrap(Wrap { trim: false }),
|
||
),
|
||
items,
|
||
allow_cancel: false,
|
||
..SelectionViewParams::picker()
|
||
});
|
||
}
|
||
|
||
pub(crate) fn is_current_misalignment_review(&self, review: &Arc<MisalignmentReview>) -> bool {
|
||
let current = self
|
||
.misalignment_policy_violation
|
||
.as_ref()
|
||
.and_then(|violation| violation.review.as_ref());
|
||
let turn_id = self.turn_lifecycle.last_turn_id.as_ref();
|
||
self.thread_id == Some(review.thread_id)
|
||
&& turn_id.is_none_or(|id| id == &review.turn_id)
|
||
&& current.is_some_and(|current| Arc::ptr_eq(current, review))
|
||
}
|
||
|
||
pub(crate) fn show_misalignment_review_confirmation(
|
||
&mut self,
|
||
review: Arc<MisalignmentReview>,
|
||
) {
|
||
if !self.is_current_misalignment_review(&review) {
|
||
return;
|
||
}
|
||
let can_continue = review.continuation_message().is_some();
|
||
self.bottom_pane.dismiss_view_by_id(PRECAUTION_VIEW);
|
||
self.bottom_pane.show_selection_view(SelectionViewParams {
|
||
view_id: Some(PRECAUTION_VIEW),
|
||
title: Some("Chat paused as a precaution".to_string()),
|
||
items: vec![
|
||
SelectionItem {
|
||
name: "Acknowledge findings and continue".to_string(),
|
||
is_disabled: !can_continue,
|
||
actions: vec![Box::new(move |tx| {
|
||
tx.send(AppEvent::ContinueMisalignment(Arc::clone(&review)));
|
||
})],
|
||
require_explicit_confirmation: true,
|
||
dismiss_on_select: true,
|
||
..Default::default()
|
||
},
|
||
SelectionItem {
|
||
name: "Back".to_string(),
|
||
actions: vec![Box::new(|tx| tx.send(AppEvent::CloseMisalignmentReview))],
|
||
..Default::default()
|
||
},
|
||
],
|
||
allow_cancel: false,
|
||
..SelectionViewParams::confirmation()
|
||
});
|
||
}
|
||
|
||
pub(crate) fn clear_misalignment_for_new_turn(
|
||
&mut self,
|
||
turn_id: &str,
|
||
source: MisalignmentTurnSource,
|
||
) {
|
||
if self
|
||
.misalignment_policy_violation
|
||
.as_ref()
|
||
.is_some_and(|violation| {
|
||
violation.turn_id.as_ref().is_some_and(|id| id != turn_id)
|
||
&& (!violation.retired_voice
|
||
|| source == MisalignmentTurnSource::AcknowledgedContinuation)
|
||
})
|
||
{
|
||
self.misalignment_policy_violation = None;
|
||
self.bottom_pane.dismiss_view_by_id(PRECAUTION_VIEW);
|
||
self.bottom_pane
|
||
.set_composer_input_enabled(/*enabled*/ true, /*placeholder*/ None);
|
||
}
|
||
}
|
||
}
|