mirror of
https://github.com/openai/codex.git
synced 2026-11-19 22:30:42 +00:00
## What changed - Save side chats as attachments to their parent conversation when local workspace history supports them, and let users reopen them from the sidebar after a restart. - Show chat names or first-prompt previews in sidebar labels, and allow saved side chats to be renamed with `/rename`. - Add tab close buttons, middle-click closing, and the configurable `close_sidebar_tab` shortcut, defaulting to `Ctrl-X W`. Closing a saved chat keeps it available in the picker; archiving removes it from Side chats. - Confirm actions that stop running work, discard unsent input, or lose temporary history. Delete saved TUI side chats when deleting their parent conversation. ## Testing Add coverage for reopening saved side chats after restart, archive handling, close confirmations, and preventing close-confirmation keys from accepting a replacement approval dialog. GitOrigin-RevId: 3d47533d007286a7354660c08df13a83dd48d5d7
1548 lines
59 KiB
Rust
1548 lines
59 KiB
Rust
use super::*;
|
|
use crate::app::safety_buffering::SafetyBufferedRetry;
|
|
use crate::app::session_lifecycle::ThreadAttachPresentation;
|
|
use crate::chatwidget::UserMessage;
|
|
use crate::chatwidget::tests::helpers::normalize_completion_timestamps;
|
|
use codex_app_server_client::AppServerEvent;
|
|
use codex_app_server_protocol::ModelSafetyBufferingUpdatedNotification;
|
|
use codex_app_server_protocol::ThreadSettingsUpdateParams;
|
|
use codex_model_provider_info::ModelProviderInfo;
|
|
use codex_protocol::models::ManagedFileSystemPermissions;
|
|
use codex_protocol::openai_models::ModelAccessPrograms;
|
|
use codex_protocol::openai_models::ToolMode;
|
|
use codex_protocol::permissions::FileSystemAccessMode;
|
|
use codex_protocol::permissions::FileSystemPath;
|
|
use codex_protocol::permissions::FileSystemSandboxEntry;
|
|
use codex_protocol::permissions::FileSystemSpecialPath;
|
|
use codex_protocol::permissions::NetworkSandboxPolicy;
|
|
use codex_protocol::turn_input::CyberAccessProgram;
|
|
use codex_utils_absolute_path::test_support::PathExt;
|
|
use core_test_support::context_snapshot;
|
|
use core_test_support::context_snapshot::ContextSnapshotOptions;
|
|
use core_test_support::responses;
|
|
use core_test_support::responses::ev_assistant_message;
|
|
use core_test_support::responses::ev_completed;
|
|
use core_test_support::responses::ev_completed_with_tokens;
|
|
use core_test_support::responses::ev_response_created;
|
|
use core_test_support::streaming_sse::StreamingSseChunk;
|
|
use core_test_support::streaming_sse::StreamingSseServer;
|
|
use core_test_support::streaming_sse::start_streaming_sse_server;
|
|
use pretty_assertions::assert_eq;
|
|
use serde_json::Value;
|
|
use tokio::sync::oneshot;
|
|
|
|
const CURRENT_MODEL: &str = "gpt-5.6-terra";
|
|
const FASTER_MODEL: &str = "gpt-5.6-luna";
|
|
const MODEL_PROVIDER_ID: &str = "safety-retry-test";
|
|
const PREVIOUS_PROMPT: &str = "Establish context";
|
|
const RETRY_PROMPT: &str = "Handle the safety-buffered request";
|
|
const COMMITTED_STEER: &str = "Keep the accepted steer";
|
|
const UNSENT_DRAFT: &str = "Keep this unsent draft";
|
|
const RETRY_GOAL: &str = "Preserve this goal across the retry";
|
|
const SAFETY_RETRY_THREAD_NAME: &str = "Safety retry source";
|
|
|
|
#[derive(Clone, Copy, PartialEq, Eq)]
|
|
enum SafetyRetryScenario {
|
|
Once,
|
|
RetryTwice,
|
|
PendingPermissions,
|
|
InterruptedPrevious,
|
|
UnsupportedPermissions,
|
|
}
|
|
|
|
fn response_chunks(response_id: &str) -> Vec<StreamingSseChunk> {
|
|
[
|
|
ev_response_created(response_id),
|
|
ev_assistant_message(&format!("message-{response_id}"), "done"),
|
|
ev_completed(response_id),
|
|
]
|
|
.into_iter()
|
|
.map(|event| StreamingSseChunk {
|
|
gate: None,
|
|
body: responses::sse(vec![event]),
|
|
})
|
|
.collect()
|
|
}
|
|
|
|
fn gated_response_chunks(
|
|
response_id: &str,
|
|
completed: Value,
|
|
) -> (Vec<StreamingSseChunk>, oneshot::Sender<()>) {
|
|
let (release_tx, release_rx) = oneshot::channel();
|
|
(
|
|
vec![
|
|
StreamingSseChunk {
|
|
gate: None,
|
|
body: responses::sse(vec![ev_response_created(response_id)]),
|
|
},
|
|
StreamingSseChunk {
|
|
gate: Some(release_rx),
|
|
body: responses::sse(vec![completed]),
|
|
},
|
|
],
|
|
release_tx,
|
|
)
|
|
}
|
|
|
|
fn next_user_turn_event(
|
|
app_event_rx: &mut tokio::sync::mpsc::UnboundedReceiver<AppEvent>,
|
|
) -> AppCommand {
|
|
while let Ok(event) = app_event_rx.try_recv() {
|
|
if let AppEvent::CodexOp(turn @ AppCommand::UserTurn { .. }) = event {
|
|
return turn;
|
|
}
|
|
}
|
|
panic!("expected UserTurn app event");
|
|
}
|
|
|
|
fn submit_prompt(app: &mut App, prompt: &str) {
|
|
app.chat_widget.apply_external_edit(prompt.to_string());
|
|
app.chat_widget
|
|
.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
}
|
|
|
|
fn drain_active_thread_events(app: &mut App) {
|
|
while let Some(event) = app
|
|
.active_thread_rx
|
|
.as_mut()
|
|
.and_then(|receiver| receiver.try_recv().ok())
|
|
{
|
|
app.handle_thread_event_now(event);
|
|
}
|
|
}
|
|
|
|
async fn next_turn_started(
|
|
app: &mut App,
|
|
app_server: &mut AppServerSession,
|
|
thread_id: ThreadId,
|
|
) -> String {
|
|
loop {
|
|
let event = tokio::time::timeout(
|
|
std::time::Duration::from_secs(/*secs*/ 5),
|
|
app_server.next_event(),
|
|
)
|
|
.await
|
|
.expect("app-server should emit a turn/start event")
|
|
.expect("app-server event stream should remain open");
|
|
let started_turn_id = if let AppServerEvent::ServerNotification(notification) = &event.event
|
|
&& let ServerNotification::TurnStarted(notification) = notification.as_ref()
|
|
&& notification.thread_id == thread_id.to_string()
|
|
{
|
|
Some(notification.turn.id.clone())
|
|
} else {
|
|
None
|
|
};
|
|
app.handle_backend_event(app_server, event).await;
|
|
drain_active_thread_events(app);
|
|
if let Some(turn_id) = started_turn_id {
|
|
return turn_id;
|
|
}
|
|
}
|
|
}
|
|
|
|
pub(super) async fn wait_for_turn_completed(
|
|
app: &mut App,
|
|
app_server: &mut AppServerSession,
|
|
thread_id: ThreadId,
|
|
) {
|
|
loop {
|
|
let event = tokio::time::timeout(
|
|
std::time::Duration::from_secs(/*secs*/ 5),
|
|
app_server.next_event(),
|
|
)
|
|
.await
|
|
.expect("app-server should emit a turn/completed event")
|
|
.expect("app-server event stream should remain open");
|
|
let completed = matches!(
|
|
&event.event,
|
|
AppServerEvent::ServerNotification(notification)
|
|
if matches!(
|
|
notification.as_ref(),
|
|
ServerNotification::TurnCompleted(notification)
|
|
if notification.thread_id == thread_id.to_string()
|
|
)
|
|
);
|
|
app.handle_backend_event(app_server, event).await;
|
|
drain_active_thread_events(app);
|
|
if completed {
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn safety_recourse_handles_a_policy_block() -> Result<()> {
|
|
let (mut app, mut events, _) = make_test_app_with_channels().await;
|
|
let model = responses::start_mock_server().await;
|
|
app_test_support::MockResponsesConfig::new(&model.uri())
|
|
.with_root_config("instructions = 'Help the user.'")
|
|
.write(app.config.codex_home.as_path())?;
|
|
app.config = app
|
|
.rebuild_config_for_cwd(app.config.cwd.to_path_buf())
|
|
.await?;
|
|
let mut server = crate::start_embedded_app_server_for_picker(&app.config).await?;
|
|
let mut tui = crate::tui::test_support::make_test_tui()?;
|
|
for (domain, error_domain) in [("cyber", "cyber"), ("bio", "bio"), ("cyber", "bio")] {
|
|
let topic = if domain == "cyber" {
|
|
"unauthorized_account_or_system_access"
|
|
} else {
|
|
"risky_biological_activities"
|
|
};
|
|
let bio_message = "This request has been flagged for possible biological risk.";
|
|
let before_block = if domain == "bio" {
|
|
ev_assistant_message("partial", "Checking the request.")
|
|
} else {
|
|
serde_json::json!({"type": "response.metadata", "metadata": {
|
|
"type": "safety_buffering", "use_cases": [domain], "reasons": ["policy-check"]
|
|
}})
|
|
};
|
|
let _model_requests = responses::mount_sse_once(
|
|
&model,
|
|
responses::sse(vec![
|
|
ev_response_created("blocked"),
|
|
before_block,
|
|
serde_json::json!({"type": "response.metadata", "metadata": {
|
|
"openai_chatgpt_moderation_metadata": {"safety_block": {
|
|
"schema_version": 1, "domain": domain, "status": "loading"
|
|
}}
|
|
}}),
|
|
serde_json::json!({"type": "response.metadata", "metadata": {
|
|
"openai_chatgpt_moderation_metadata": {"safety_recourse": {
|
|
"schema_version": 1, "domain": domain, "source": "user_request",
|
|
"source_message": {"id": format!("{}🔒", "a".repeat(255)), "kind": "ordinary_message", "role": "user"},
|
|
"topic": topic,
|
|
"suggestions": [
|
|
{"label": "Recover an account", "prompt_text": "Help me recover my account safely."},
|
|
{"label": "Protect a system", "prompt_text": "Explain system protection."},
|
|
{"label": "Understand risks", "prompt_text": "Explain account security risks."}
|
|
]
|
|
}}
|
|
}}),
|
|
serde_json::json!({"type": "response.failed", "response": {
|
|
"id": "blocked", "status": "failed",
|
|
"error": {"code": format!("{error_domain}_policy"), "message": (error_domain == "bio").then_some(bio_message)}
|
|
}}),
|
|
]),
|
|
)
|
|
.await;
|
|
let started = server.start_thread(&app.config).await?;
|
|
let source_id = started.session.thread_id;
|
|
app.replace_chat_widget_with_app_server_thread(
|
|
&mut tui,
|
|
started,
|
|
ThreadAttachPresentation::SessionLineage,
|
|
/*initial_user_message*/ None,
|
|
)
|
|
.await?;
|
|
let selected_model = "gpt-5.1";
|
|
app.chat_widget.set_model(selected_model);
|
|
submit_prompt(&mut app, "Blocked original prompt");
|
|
app.submit_thread_op(&mut server, source_id, next_user_turn_event(&mut events))
|
|
.await?;
|
|
app.chat_widget
|
|
.apply_external_edit(UNSENT_DRAFT.to_string());
|
|
loop {
|
|
let event = server.next_event().await.expect("moderation metadata");
|
|
let is_metadata = matches!(&event.event, AppServerEvent::ServerNotification(notification)
|
|
if matches!(notification.as_ref(), ServerNotification::TurnModerationMetadata(_)));
|
|
app.handle_backend_event(&server, event).await;
|
|
drain_active_thread_events(&mut app);
|
|
if is_metadata {
|
|
break;
|
|
}
|
|
}
|
|
let loading = render_bottom_popup(&app.chat_widget, /*width*/ 80);
|
|
let loading = loading
|
|
.split(" (")
|
|
.next()
|
|
.unwrap_or_default()
|
|
.replace('◦', "•");
|
|
while let Ok(event) = events.try_recv() {
|
|
if let AppEvent::InsertHistoryCell(cell) = event {
|
|
assert!(!cell.as_any().is::<history_cell::SafetyAccessBlockCell>());
|
|
}
|
|
}
|
|
wait_for_turn_completed(&mut app, &mut server, source_id).await;
|
|
let notice = next_history_message(&mut events);
|
|
assert!(!render_bottom_popup(&app.chat_widget, /*width*/ 80).contains("This content can"));
|
|
if domain != error_domain {
|
|
let generic =
|
|
history_cell::new_safety_access_block_event().display_lines(/*width*/ 80);
|
|
assert_eq!(notice, lines_to_single_string(&generic));
|
|
continue;
|
|
}
|
|
if domain == "bio" {
|
|
assert!(loading.contains("Finding an explanation and safer ways to continue…"));
|
|
assert!(notice.contains("research and safety considerations."));
|
|
continue;
|
|
}
|
|
insta::assert_snapshot!("safety_recourse", format!("{loading}\n\n{notice}"));
|
|
let picker = render_bottom_popup(&app.chat_widget, /*width*/ 80);
|
|
let goal = server
|
|
.thread_goal_set(
|
|
source_id,
|
|
Some("Excluded objective".into()),
|
|
Some(codex_app_server_protocol::ThreadGoalStatus::Paused),
|
|
/*token_budget*/ None,
|
|
)
|
|
.await?
|
|
.goal;
|
|
responses::mount_sse_once(&model, responses::sse_completed("rewrite")).await;
|
|
let draft = app.chat_widget.capture_thread_input_state().unwrap();
|
|
app.chat_widget.handle_key_event(KeyCode::Enter.into());
|
|
assert_eq!(render_bottom_popup(&app.chat_widget, /*width*/ 80), picker);
|
|
let selection = std::iter::from_fn(|| events.try_recv().ok())
|
|
.find(|event| matches!(event, AppEvent::ContinueSafetyRecourse { .. }))
|
|
.expect("rewrite selection");
|
|
app.handle_event(&mut tui, &mut server, selection).await?;
|
|
let fork_id = app.active_thread_id.expect("forked thread");
|
|
assert_eq!(server.thread_goal_get(fork_id).await?.goal, None);
|
|
assert_eq!(server.thread_goal_get(source_id).await?.goal, Some(goal));
|
|
assert_eq!(app.agents_overview.input_states[&source_id], draft);
|
|
wait_for_turn_completed(&mut app, &mut server, fork_id).await;
|
|
let requests = responses::received_responses_requests(&model).await;
|
|
assert_eq!(requests[1].body_json()["model"], selected_model);
|
|
insta::assert_snapshot!(
|
|
"safety_recourse_request_history",
|
|
context_snapshot::format_request_history_snapshot(
|
|
"The fork excludes the blocked turn and submits the selected rewrite.",
|
|
&requests,
|
|
&ContextSnapshotOptions::default().rewrite_known_segments(),
|
|
)
|
|
);
|
|
let header = requests[1].header("x-codex-turn-metadata").unwrap();
|
|
let metadata: Value = serde_json::from_str(&header)?;
|
|
assert_eq!(metadata["turn_trigger"], "safety_recourse_follow_up");
|
|
}
|
|
server.shutdown().await?;
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn active_turn_interrupt_is_nonblocking_and_coalesces_repeated_requests() -> Result<()> {
|
|
Box::pin(interrupt_after_inactive_steer(SteerSwitch::WithinTask)).await
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn agents_overview_acknowledges_inactive_steer_before_interrupt() -> Result<()> {
|
|
Box::pin(interrupt_after_inactive_steer(SteerSwitch::BetweenTasks)).await
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn embedded_session_switch_routes_background_approval_and_restores_draft() -> Result<()> {
|
|
use app_test_support::MockResponsesConfig;
|
|
|
|
core_test_support::skip_if_no_network!(Ok(()));
|
|
let (release_command, gate) = oneshot::channel();
|
|
let (model, _) = start_streaming_sse_server(vec![
|
|
vec![StreamingSseChunk {
|
|
gate: Some(gate),
|
|
body: responses::sse(vec![
|
|
responses::ev_response_created("first"),
|
|
responses::ev_function_call("command", "exec_command",
|
|
r#"{"cmd":"echo embedded","sandbox_permissions":"require_escalated","justification":"Test background approval"}"#),
|
|
responses::ev_completed("first"),
|
|
]),
|
|
}],
|
|
response_chunks("finished"),
|
|
]).await;
|
|
let (mut app, mut events, _ops) = make_test_app_with_channels().await;
|
|
let folder = tempdir()?;
|
|
let cwd = folder.path().canonicalize()?;
|
|
MockResponsesConfig::new(model.uri())
|
|
.with_approval_policy("on-request")
|
|
.with_extra_config(&format!(
|
|
"[projects.{}]\ntrust_level = 'trusted'",
|
|
serde_json::to_string(&cwd)?
|
|
))
|
|
.write(&app.config.codex_home)?;
|
|
app.config = app.rebuild_config_for_cwd(cwd.clone()).await?;
|
|
let mut server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
|
let mut tui = crate::tui::test_support::make_test_tui()?;
|
|
tui.pause_events();
|
|
app.start_agents_overview_session(
|
|
&mut tui,
|
|
&mut server,
|
|
Some(cwd.clone().abs()),
|
|
/*managed_worktree*/ None,
|
|
/*startup_draft*/ None,
|
|
)
|
|
.await?;
|
|
let first = app.chat_widget.thread_id().expect("first session");
|
|
submit_prompt(&mut app, "Run the command");
|
|
app.submit_thread_op(&mut server, first, next_user_turn_event(&mut events))
|
|
.await?;
|
|
next_turn_started(&mut app, &mut server, first).await;
|
|
|
|
app.open_agents_overview(&server);
|
|
app.start_agents_overview_session(
|
|
&mut tui,
|
|
&mut server,
|
|
Some(cwd.abs()),
|
|
/*managed_worktree*/ None,
|
|
/*startup_draft*/ None,
|
|
)
|
|
.await?;
|
|
let second = app.chat_widget.thread_id().expect("second session");
|
|
assert_ne!(first, second);
|
|
app.chat_widget.insert_str("Draft for the second session");
|
|
release_command.send(()).unwrap();
|
|
loop {
|
|
let event = server.next_event().await.expect("connected");
|
|
let approval = match &event.event {
|
|
AppServerEvent::ServerRequest(request) => matches!(
|
|
request.as_ref(),
|
|
ServerRequest::CommandExecutionRequestApproval { .. }
|
|
),
|
|
AppServerEvent::ServerNotification(n) if matches!(n.as_ref(), ServerNotification::TurnCompleted(done) if done.thread_id == first.to_string()) =>
|
|
{
|
|
panic!("turn ended before approval")
|
|
}
|
|
_ => false,
|
|
};
|
|
app.handle_backend_event(&server, event).await;
|
|
if approval {
|
|
break;
|
|
}
|
|
}
|
|
let quit = AppEvent::Exit(ExitMode::ShutdownFirst);
|
|
assert!(matches!(
|
|
boxed_future!(app.handle_event(&mut tui, &mut server, quit)).await?,
|
|
AppRunControl::Continue
|
|
));
|
|
assert!(render_bottom_popup(&app.chat_widget, /*width*/ 90).contains("Stop sessions and quit"));
|
|
app.chat_widget.handle_key_event(KeyCode::Esc.into());
|
|
app.select_agents_overview_thread(&mut tui, &mut server, first)
|
|
.await?;
|
|
drain_active_thread_events(&mut app);
|
|
app.chat_widget.handle_key_event(KeyCode::Esc.into());
|
|
while let Ok(event) = events.try_recv() {
|
|
boxed_future!(app.handle_event(&mut tui, &mut server, event)).await?;
|
|
}
|
|
wait_for_turn_completed(&mut app, &mut server, first).await;
|
|
app.select_agents_overview_thread(&mut tui, &mut server, second)
|
|
.await?;
|
|
assert_eq!(
|
|
app.chat_widget.composer_text_with_pending(),
|
|
"Draft for the second session"
|
|
);
|
|
server.shutdown().await?;
|
|
model.shutdown().await;
|
|
Ok(())
|
|
}
|
|
|
|
enum SteerSwitch {
|
|
WithinTask,
|
|
BetweenTasks,
|
|
}
|
|
|
|
async fn interrupt_after_inactive_steer(switch: SteerSwitch) -> Result<()> {
|
|
let via_overview = matches!(switch, SteerSwitch::BetweenTasks);
|
|
let (chunks, release_response) =
|
|
gated_response_chunks("interrupt-response", ev_completed("interrupt-response"));
|
|
let (steered_chunks, release_steered_response) =
|
|
gated_response_chunks("steered-response", ev_completed("steered-response"));
|
|
let (server, _completions) = start_streaming_sse_server(vec![chunks, steered_chunks]).await;
|
|
let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;
|
|
let codex_home = tempdir()?;
|
|
std::fs::write(
|
|
codex_home.path().join("config.toml"),
|
|
format!(
|
|
r#"
|
|
model = "{CURRENT_MODEL}"
|
|
model_provider = "{MODEL_PROVIDER_ID}"
|
|
|
|
[model_providers.{MODEL_PROVIDER_ID}]
|
|
name = "Interrupt test"
|
|
base_url = "{}/v1"
|
|
wire_api = "responses"
|
|
request_max_retries = 0
|
|
stream_max_retries = 0
|
|
"#,
|
|
server.uri()
|
|
),
|
|
)?;
|
|
app.config.codex_home = codex_home.path().to_path_buf().abs();
|
|
app.config.sqlite = codex_state::SqliteConfig::new_for_testing(codex_home.path().abs());
|
|
app.config.model = Some(CURRENT_MODEL.to_string());
|
|
app.config.model_provider_id = MODEL_PROVIDER_ID.to_string();
|
|
app.config.model_provider = ModelProviderInfo {
|
|
name: "Interrupt test".to_string(),
|
|
base_url: Some(format!("{}/v1", server.uri())),
|
|
request_max_retries: Some(0),
|
|
stream_max_retries: Some(0),
|
|
..ModelProviderInfo::default()
|
|
};
|
|
|
|
let mut tui = crate::tui::test_support::make_test_tui()?;
|
|
let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
|
let started = app_server.start_thread(&app.config).await?;
|
|
let thread_id = started.session.thread_id;
|
|
app.replace_chat_widget_with_app_server_thread(
|
|
&mut tui,
|
|
started,
|
|
ThreadAttachPresentation::SessionLineage,
|
|
/*initial_user_message*/ None,
|
|
)
|
|
.await?;
|
|
while app_event_rx.try_recv().is_ok() {}
|
|
|
|
submit_prompt(&mut app, COMMITTED_STEER);
|
|
let turn = next_user_turn_event(&mut app_event_rx);
|
|
app.submit_thread_op(&mut app_server, thread_id, turn)
|
|
.await?;
|
|
let turn_id = next_turn_started(&mut app, &mut app_server, thread_id).await;
|
|
// Leave the original message's completion queued until after submitting the identical steer.
|
|
tokio::time::timeout(
|
|
std::time::Duration::from_secs(/*secs*/ 5),
|
|
server.wait_for_request_count(/*count*/ 1),
|
|
)
|
|
.await?;
|
|
|
|
let acknowledged_input = app.chat_widget.capture_thread_input_state();
|
|
submit_prompt(&mut app, COMMITTED_STEER);
|
|
let steer = next_user_turn_event(&mut app_event_rx);
|
|
let AppCommand::UserTurn {
|
|
client_user_message_id,
|
|
..
|
|
} = &steer
|
|
else {
|
|
unreachable!("user turn");
|
|
};
|
|
let expected_client_id = client_user_message_id.clone();
|
|
// The server reports the current turn. The retried steer must keep this message ID.
|
|
app.ensure_thread_channel(thread_id)
|
|
.store
|
|
.lock()
|
|
.await
|
|
.set_active_turn_id("stale".into());
|
|
app.submit_thread_op(&mut app_server, thread_id, steer)
|
|
.await?;
|
|
let pending_input = app.chat_widget.capture_thread_input_state();
|
|
let other_id = ThreadId::from_string(
|
|
&app_test_support::create_fake_rollout(
|
|
app.config.codex_home.as_path(),
|
|
"2025-01-05T12-00-00",
|
|
"2025-01-05T12:00:00Z",
|
|
"Other task",
|
|
Some(MODEL_PROVIDER_ID),
|
|
/*git_info*/ None,
|
|
)
|
|
.expect("materialize other task"),
|
|
)?;
|
|
let other = app_server
|
|
.resume_thread(
|
|
&app.local_settings,
|
|
app.config.clone(),
|
|
other_id,
|
|
crate::app_server_session::ResumeModelSettings::PreserveExistingThread,
|
|
)
|
|
.await?;
|
|
for cwd in [&app.config.cwd, &other.session.cwd] {
|
|
crate::legacy_core::config::set_project_trust_level(
|
|
app.config.codex_home.as_path(),
|
|
cwd.as_path(),
|
|
codex_protocol::config_types::TrustLevel::Trusted,
|
|
)
|
|
.map_err(std::io::Error::other)?;
|
|
}
|
|
app.thread_event_channels.insert(
|
|
other_id,
|
|
ThreadEventChannel::new_with_session(
|
|
THREAD_EVENT_CHANNEL_CAPACITY,
|
|
other.session,
|
|
other.turns,
|
|
),
|
|
);
|
|
// Receive the real commit while another thread is visible, with no replay capacity.
|
|
if via_overview {
|
|
Box::pin(app.select_agents_overview_thread(&mut tui, &mut app_server, other_id)).await?;
|
|
} else {
|
|
Box::pin(app.select_agent_thread(&mut tui, &mut app_server, other_id)).await?;
|
|
app.thread_event_channels[&thread_id]
|
|
.store
|
|
.lock()
|
|
.await
|
|
.capacity = 0;
|
|
}
|
|
assert_eq!(app.current_displayed_thread_id(), Some(other_id));
|
|
let mut release_response = Some(release_response);
|
|
loop {
|
|
let event = tokio::time::timeout(
|
|
std::time::Duration::from_secs(/*secs*/ 5),
|
|
app_server.next_event(),
|
|
)
|
|
.await?
|
|
.expect("app-server remains open");
|
|
let committed_id = if let AppServerEvent::ServerNotification(notification) = &event.event
|
|
&& let ServerNotification::ItemCompleted(item) = notification.as_ref()
|
|
&& let ThreadItemPayload::UserMessage {
|
|
content, client_id, ..
|
|
} = &item.item.payload
|
|
&& ChatWidget::user_message_display_from_inputs(content).message == COMMITTED_STEER
|
|
{
|
|
Some(client_id.clone().expect("receipt echoes the submission ID"))
|
|
} else {
|
|
None
|
|
};
|
|
app.handle_backend_event(&app_server, event).await;
|
|
if let Some(client_id) = committed_id {
|
|
let saved_input = if via_overview {
|
|
assert!(!app.thread_event_channels.contains_key(&thread_id));
|
|
app.agents_overview.input_states.get(&thread_id).cloned()
|
|
} else {
|
|
let store = app.thread_event_channels[&thread_id].store.lock().await;
|
|
assert!(store.buffer.is_empty());
|
|
store.input_state.clone()
|
|
};
|
|
if let Some(release_response) = release_response.take() {
|
|
assert_ne!(client_id, expected_client_id);
|
|
assert_eq!(saved_input, pending_input);
|
|
let _ = release_response.send(());
|
|
} else {
|
|
assert_eq!(client_id, expected_client_id);
|
|
assert_eq!(saved_input, acknowledged_input);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if via_overview {
|
|
Box::pin(app.select_agents_overview_thread(&mut tui, &mut app_server, thread_id)).await?;
|
|
} else {
|
|
Box::pin(app.select_agent_thread(&mut tui, &mut app_server, thread_id)).await?;
|
|
}
|
|
assert_eq!(app.active_thread_id, Some(thread_id));
|
|
|
|
let interrupt = AppCommand::interrupt();
|
|
assert!(
|
|
app.try_submit_active_thread_op_via_app_server(&mut app_server, thread_id, &interrupt)
|
|
.await?
|
|
);
|
|
let AppServerRequestId::Integer(next_request_id) = app_server.next_request_id() else {
|
|
unreachable!("embedded app-server request IDs are integers");
|
|
};
|
|
assert!(
|
|
app.try_submit_active_thread_op_via_app_server(&mut app_server, thread_id, &interrupt)
|
|
.await?
|
|
);
|
|
assert_eq!(
|
|
app_server.next_request_id(),
|
|
AppServerRequestId::Integer(next_request_id + 1)
|
|
);
|
|
{
|
|
let store = app.thread_event_channels[&thread_id].store.lock().await;
|
|
assert_eq!(store.active_turn_id.as_deref(), Some(turn_id.as_str()));
|
|
assert_eq!(
|
|
store.pending_interrupt_turn_id.as_deref(),
|
|
Some(turn_id.as_str())
|
|
);
|
|
}
|
|
|
|
while app_event_rx.try_recv().is_ok() {}
|
|
app.handle_thread_event_now(ThreadBufferedEvent::Notification(Box::new(
|
|
ServerNotification::Warning(WarningNotification {
|
|
thread_id: Some(thread_id.to_string()),
|
|
message: "event handled while interrupt is pending".to_string(),
|
|
}),
|
|
)));
|
|
assert!(matches!(
|
|
app_event_rx.try_recv(),
|
|
Ok(AppEvent::InsertHistoryCell(_))
|
|
));
|
|
|
|
wait_for_turn_completed(&mut app, &mut app_server, thread_id).await;
|
|
assert_eq!(
|
|
app.thread_event_channels[&thread_id]
|
|
.store
|
|
.lock()
|
|
.await
|
|
.pending_interrupt_turn_id,
|
|
None
|
|
);
|
|
|
|
insta::assert_snapshot!(app.chat_widget.composer_text_with_pending(), @"");
|
|
assert!(
|
|
std::iter::from_fn(|| app_event_rx.try_recv().ok())
|
|
.all(|event| !matches!(event, AppEvent::CodexOp(AppCommand::UserTurn { .. })))
|
|
);
|
|
let source = app_server
|
|
.thread_read(thread_id, /*include_turns*/ true)
|
|
.await?;
|
|
assert_eq!(user_message_count(&source, COMMITTED_STEER), 2);
|
|
let _ = release_steered_response.send(());
|
|
app_server.shutdown().await?;
|
|
server.shutdown().await;
|
|
Ok(())
|
|
}
|
|
|
|
async fn drive_until_request_count(
|
|
app: &mut App,
|
|
app_server: &mut AppServerSession,
|
|
server: &StreamingSseServer,
|
|
expected_request_count: usize,
|
|
) {
|
|
let timeout = tokio::time::sleep(std::time::Duration::from_secs(/*secs*/ 5));
|
|
tokio::pin!(timeout);
|
|
loop {
|
|
tokio::select! {
|
|
() = server.wait_for_request_count(expected_request_count) => return,
|
|
event = app_server.next_event() => {
|
|
let event = event.expect("app-server event stream should remain open");
|
|
app.handle_backend_event(app_server, event).await;
|
|
drain_active_thread_events(app);
|
|
}
|
|
() = &mut timeout => {
|
|
panic!("expected {expected_request_count} Responses API requests");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn user_input_texts(body: &Value) -> Vec<String> {
|
|
body.get("input")
|
|
.and_then(Value::as_array)
|
|
.into_iter()
|
|
.flatten()
|
|
.filter(|item| item.get("type").and_then(Value::as_str) == Some("message"))
|
|
.filter(|item| item.get("role").and_then(Value::as_str) == Some("user"))
|
|
.filter_map(|item| item.get("content").and_then(Value::as_array))
|
|
.flatten()
|
|
.filter(|span| span.get("type").and_then(Value::as_str) == Some("input_text"))
|
|
.filter_map(|span| span.get("text").and_then(Value::as_str).map(str::to_owned))
|
|
.collect()
|
|
}
|
|
|
|
fn user_message_count(thread: &Thread, prompt: &str) -> usize {
|
|
thread
|
|
.turns
|
|
.iter()
|
|
.flat_map(Turn::item_payloads)
|
|
.filter_map(|item| match item {
|
|
ThreadItemPayload::UserMessage { content, .. } => Some(content),
|
|
_ => None,
|
|
})
|
|
.filter(|content| {
|
|
content
|
|
.iter()
|
|
.filter_map(|item| match item {
|
|
AppServerUserInput::Text { text, .. } => Some(text.as_str()),
|
|
_ => None,
|
|
})
|
|
.collect::<String>()
|
|
== prompt
|
|
})
|
|
.count()
|
|
}
|
|
|
|
async fn run_safety_retry(
|
|
previous_prompt: Option<&str>,
|
|
failing_draft: Option<&str>,
|
|
committed_steer: Option<&str>,
|
|
scenario: SafetyRetryScenario,
|
|
) -> Result<()> {
|
|
let (active_chunks, release_active_response) = gated_response_chunks(
|
|
"active-response",
|
|
ev_completed_with_tokens("active-response", /*total_tokens*/ 100),
|
|
);
|
|
let mut release_active_response = Some(release_active_response);
|
|
let (steered_chunks, release_steered_response) =
|
|
gated_response_chunks("steered-response", ev_completed("steered-response"));
|
|
let (previous_chunks, release_previous_response) =
|
|
gated_response_chunks("previous-response", ev_completed("previous-response"));
|
|
let (retry_chunks, release_retry_response) =
|
|
gated_response_chunks("retry-response", ev_completed("retry-response"));
|
|
let mut response_sequences = Vec::new();
|
|
if previous_prompt.is_some() {
|
|
if scenario == SafetyRetryScenario::InterruptedPrevious {
|
|
response_sequences.push(previous_chunks);
|
|
} else {
|
|
response_sequences.push(response_chunks("previous-response"));
|
|
}
|
|
}
|
|
response_sequences.push(active_chunks);
|
|
if committed_steer.is_some() {
|
|
response_sequences.push(steered_chunks);
|
|
}
|
|
if scenario == SafetyRetryScenario::RetryTwice {
|
|
response_sequences.push(retry_chunks);
|
|
response_sequences.push(response_chunks("second-retry-response"));
|
|
} else {
|
|
response_sequences.push(response_chunks("retry-response"));
|
|
}
|
|
response_sequences.push(vec![StreamingSseChunk {
|
|
gate: None,
|
|
body: responses::sse(vec![
|
|
ev_response_created("goal-continuation-response"),
|
|
ev_assistant_message("goal-continuation-message", "done"),
|
|
ev_completed_with_tokens("goal-continuation-response", /*total_tokens*/ 1_000),
|
|
]),
|
|
}]);
|
|
let expected_request_count = response_sequences.len();
|
|
let (server, _completions) = start_streaming_sse_server(response_sequences).await;
|
|
|
|
let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;
|
|
let codex_home = tempdir()?;
|
|
// Keep text-only retry fixtures independent of the optional Code Mode host.
|
|
let mut model_catalog = codex_models_manager::bundled_models_response()?;
|
|
for model in model_catalog
|
|
.models
|
|
.iter_mut()
|
|
.filter(|model| matches!(model.slug.as_str(), CURRENT_MODEL | FASTER_MODEL))
|
|
{
|
|
model.tool_mode = Some(ToolMode::Direct);
|
|
if scenario == SafetyRetryScenario::UnsupportedPermissions && model.slug == FASTER_MODEL {
|
|
model.available_access_programs = Some(ModelAccessPrograms {
|
|
cyber: vec![CyberAccessProgram::Standard],
|
|
});
|
|
}
|
|
}
|
|
let model_catalog_path = codex_home.path().join("models.json");
|
|
std::fs::write(&model_catalog_path, serde_json::to_vec(&model_catalog)?)?;
|
|
let model_catalog_path = toml::Value::String(model_catalog_path.display().to_string());
|
|
// The committed-steer case counts usage from the response that finishes before steering.
|
|
let instant_interrupt_config = if committed_steer.is_some() {
|
|
"instant_interrupt = false"
|
|
} else {
|
|
""
|
|
};
|
|
std::fs::write(
|
|
codex_home.path().join("config.toml"),
|
|
format!(
|
|
r#"
|
|
model = "{CURRENT_MODEL}"
|
|
model_provider = "{MODEL_PROVIDER_ID}"
|
|
model_catalog_json = {model_catalog_path}
|
|
|
|
[model_providers.{MODEL_PROVIDER_ID}]
|
|
name = "Safety retry test"
|
|
base_url = "{}/v1"
|
|
wire_api = "responses"
|
|
request_max_retries = 0
|
|
stream_max_retries = 0
|
|
|
|
[features]
|
|
goals = true
|
|
{instant_interrupt_config}
|
|
"#,
|
|
server.uri()
|
|
),
|
|
)?;
|
|
app.config.codex_home = codex_home.path().to_path_buf().abs();
|
|
app.config.sqlite = codex_state::SqliteConfig::new_for_testing(codex_home.path().abs());
|
|
app.config.model = Some(CURRENT_MODEL.to_string());
|
|
if scenario == SafetyRetryScenario::UnsupportedPermissions {
|
|
app.model_catalog = Arc::new(ModelCatalog::new(
|
|
model_catalog
|
|
.models
|
|
.iter()
|
|
.cloned()
|
|
.map(Into::into)
|
|
.collect(),
|
|
));
|
|
}
|
|
app.config.model_catalog = Some(model_catalog);
|
|
app.config.model_provider_id = MODEL_PROVIDER_ID.to_string();
|
|
app.config.model_provider = ModelProviderInfo {
|
|
name: "Safety retry test".to_string(),
|
|
base_url: Some(format!("{}/v1", server.uri())),
|
|
request_max_retries: Some(0),
|
|
stream_max_retries: Some(0),
|
|
..ModelProviderInfo::default()
|
|
};
|
|
app.config
|
|
.features
|
|
.enable(Feature::Goals)
|
|
.expect("test config should allow goals");
|
|
|
|
if scenario == SafetyRetryScenario::PendingPermissions {
|
|
app.config
|
|
.permissions
|
|
.set_permission_profile_from_session_snapshot(
|
|
PermissionProfileSnapshot::from_session_snapshot(
|
|
PermissionProfile::Disabled,
|
|
Some(ActivePermissionProfile::new(":danger-full-access")),
|
|
),
|
|
)?;
|
|
}
|
|
let mut tui = crate::tui::test_support::make_test_tui()?;
|
|
let mut app_server = Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await?;
|
|
let mut started = app_server.start_thread(&app.config).await?;
|
|
let source_thread_id = started.session.thread_id;
|
|
// Keep ordered response fixtures focused on safety retries, not background naming.
|
|
app_server
|
|
.thread_set_name(source_thread_id, SAFETY_RETRY_THREAD_NAME.to_string())
|
|
.await?;
|
|
started.session.thread_name = Some(SAFETY_RETRY_THREAD_NAME.to_string());
|
|
app.replace_chat_widget_with_app_server_thread(
|
|
&mut tui,
|
|
started,
|
|
ThreadAttachPresentation::SessionLineage,
|
|
/*initial_user_message*/ None,
|
|
)
|
|
.await?;
|
|
while app_event_rx.try_recv().is_ok() {}
|
|
|
|
if let Some(previous_prompt) = previous_prompt {
|
|
submit_prompt(&mut app, previous_prompt);
|
|
let previous_turn = next_user_turn_event(&mut app_event_rx);
|
|
app.submit_thread_op(&mut app_server, source_thread_id, previous_turn)
|
|
.await?;
|
|
if scenario == SafetyRetryScenario::InterruptedPrevious {
|
|
let previous_turn_id =
|
|
next_turn_started(&mut app, &mut app_server, source_thread_id).await;
|
|
drive_until_request_count(
|
|
&mut app,
|
|
&mut app_server,
|
|
&server,
|
|
/*expected_request_count*/ 1,
|
|
)
|
|
.await;
|
|
app_server
|
|
.turn_interrupt(source_thread_id, previous_turn_id)
|
|
.await?;
|
|
} else {
|
|
wait_for_turn_completed(&mut app, &mut app_server, source_thread_id).await;
|
|
}
|
|
}
|
|
|
|
let state_db = codex_state::StateRuntime::init(
|
|
app.config.sqlite.clone(),
|
|
app.config.model_provider_id.clone(),
|
|
)
|
|
.await
|
|
.expect("state db should initialize");
|
|
state_db
|
|
.thread_goals()
|
|
.replace_thread_goal(
|
|
source_thread_id,
|
|
RETRY_GOAL,
|
|
codex_state::ThreadGoalStatus::Active,
|
|
/*token_budget*/ Some(1_000),
|
|
)
|
|
.await
|
|
.expect("source goal should be stored");
|
|
let source_goal_id = state_db
|
|
.thread_goals()
|
|
.get_thread_goal(source_thread_id)
|
|
.await
|
|
.expect("source goal should be readable")
|
|
.expect("source goal")
|
|
.goal_id;
|
|
state_db
|
|
.thread_goals()
|
|
.account_thread_goal_usage(
|
|
source_thread_id,
|
|
/*time_delta_seconds*/ 12,
|
|
/*token_delta*/ 50,
|
|
codex_state::GoalAccountingMode::ActiveOrStopped,
|
|
Some(source_goal_id.as_str()),
|
|
)
|
|
.await
|
|
.expect("source goal usage should be recorded");
|
|
|
|
submit_prompt(&mut app, RETRY_PROMPT);
|
|
let mut active_turn = next_user_turn_event(&mut app_event_rx);
|
|
app.submit_thread_op(&mut app_server, source_thread_id, active_turn.clone())
|
|
.await?;
|
|
let active_turn_id = next_turn_started(&mut app, &mut app_server, source_thread_id).await;
|
|
drive_until_request_count(
|
|
&mut app,
|
|
&mut app_server,
|
|
&server,
|
|
usize::from(previous_prompt.is_some()) + 1,
|
|
)
|
|
.await;
|
|
|
|
if let Some(committed_steer) = committed_steer {
|
|
submit_prompt(&mut app, committed_steer);
|
|
let steer = next_user_turn_event(&mut app_event_rx);
|
|
app.submit_thread_op(&mut app_server, source_thread_id, steer)
|
|
.await?;
|
|
let _ = release_active_response
|
|
.take()
|
|
.expect("active response should still be gated")
|
|
.send(());
|
|
drive_until_request_count(
|
|
&mut app,
|
|
&mut app_server,
|
|
&server,
|
|
usize::from(previous_prompt.is_some()) + 2,
|
|
)
|
|
.await;
|
|
let source = app_server
|
|
.thread_read(source_thread_id, /*include_turns*/ true)
|
|
.await?;
|
|
assert_eq!(user_message_count(&source, committed_steer), 1);
|
|
}
|
|
|
|
app.handle_app_server_event(
|
|
&app_server,
|
|
AppServerEvent::ServerNotification(Box::new(
|
|
ServerNotification::ModelSafetyBufferingUpdated(
|
|
ModelSafetyBufferingUpdatedNotification {
|
|
thread_id: source_thread_id.to_string(),
|
|
turn_id: active_turn_id.clone(),
|
|
model: CURRENT_MODEL.to_string(),
|
|
use_cases: Vec::new(),
|
|
reasons: Vec::new(),
|
|
show_buffering_ui: true,
|
|
faster_model: Some(FASTER_MODEL.to_string()),
|
|
},
|
|
),
|
|
)),
|
|
)
|
|
.await;
|
|
drain_active_thread_events(&mut app);
|
|
assert!(
|
|
app.chat_widget
|
|
.can_retry_safety_buffered_turn(&active_turn_id)
|
|
);
|
|
if let Some(draft) = failing_draft {
|
|
app.chat_widget.apply_external_edit(draft.to_string());
|
|
let source = app_server
|
|
.thread_read(source_thread_id, /*include_turns*/ true)
|
|
.await?;
|
|
std::fs::remove_file(
|
|
source
|
|
.path
|
|
.expect("source thread should have a rollout path"),
|
|
)?;
|
|
}
|
|
|
|
let primary_thread_id = ThreadId::new();
|
|
app.primary_thread_id = Some(primary_thread_id);
|
|
let voice_owner = ThreadId::new();
|
|
let (mut owner, _, _, _) = crate::chatwidget::tests::make_chatwidget_manual_with_sender().await;
|
|
crate::chatwidget::activate_voice_for_thread(&mut owner, voice_owner);
|
|
owner.park_voice();
|
|
app.background_voice = Some(Box::new(owner));
|
|
Box::pin(app.retry_safety_buffered_turn(
|
|
&mut tui,
|
|
&mut app_server,
|
|
SafetyBufferedRetry {
|
|
thread_id: source_thread_id,
|
|
turn_id: active_turn_id.clone(),
|
|
model: FASTER_MODEL.to_string(),
|
|
turn: active_turn.clone(),
|
|
prompt: UserMessage::from(RETRY_PROMPT),
|
|
},
|
|
))
|
|
.await;
|
|
|
|
assert_eq!(app.primary_thread_id, Some(primary_thread_id));
|
|
assert_eq!(app.active_thread_id, Some(source_thread_id));
|
|
assert_eq!(app.chat_widget.thread_id(), Some(source_thread_id));
|
|
app.primary_thread_id = Some(source_thread_id);
|
|
while app_event_rx.try_recv().is_ok() {}
|
|
|
|
if scenario == SafetyRetryScenario::UnsupportedPermissions {
|
|
app_server
|
|
.thread_settings_update(ThreadSettingsUpdateParams {
|
|
thread_id: source_thread_id.to_string(),
|
|
effort: Some(ReasoningEffortConfig::Low),
|
|
..Default::default()
|
|
})
|
|
.await?;
|
|
let mut settings = next_thread_settings_updated(&mut app_server, source_thread_id).await;
|
|
settings.thread_settings.model_provider = "openai".to_string();
|
|
app.chat_widget.on_thread_settings_updated(settings);
|
|
app.chat_widget.update_account_state(
|
|
/*status_account_display*/ None, /*plan_type*/ None,
|
|
/*has_chatgpt_account*/ true, /*has_codex_backend_auth*/ false,
|
|
);
|
|
app.chat_widget
|
|
.set_feature_enabled(Feature::CliDaybreak, /*enabled*/ true);
|
|
app.chat_widget.set_daybreak_enabled(/*enabled*/ true);
|
|
Box::pin(app.retry_safety_buffered_turn(
|
|
&mut tui,
|
|
&mut app_server,
|
|
SafetyBufferedRetry {
|
|
thread_id: source_thread_id,
|
|
turn_id: active_turn_id.clone(),
|
|
model: FASTER_MODEL.to_string(),
|
|
turn: active_turn.clone(),
|
|
prompt: UserMessage::from(RETRY_PROMPT),
|
|
},
|
|
))
|
|
.await;
|
|
assert_eq!(app.chat_widget.thread_id(), Some(source_thread_id));
|
|
let source = app_server
|
|
.thread_read(source_thread_id, /*include_turns*/ true)
|
|
.await?;
|
|
assert_eq!(
|
|
source.turns.last().map(|turn| &turn.status),
|
|
Some(&TurnStatus::InProgress)
|
|
);
|
|
let error_cell = std::iter::from_fn(|| app_event_rx.try_recv().ok())
|
|
.find_map(|event| match event {
|
|
AppEvent::InsertHistoryCell(cell) => Some(cell),
|
|
_ => None,
|
|
})
|
|
.expect("unsupported Daybreak model should be added to history");
|
|
insta::assert_snapshot!(
|
|
lines_to_single_string(&error_cell.display_lines(/*width*/ 200)),
|
|
@"■ Daybreak support for model gpt-5.6-luna could not be confirmed by the connected server. Use /daybreak to turn it off, or choose a compatible model and server."
|
|
);
|
|
app.chat_widget.set_daybreak_enabled(/*enabled*/ false);
|
|
|
|
let extra_root =
|
|
AbsolutePathBuf::resolve_path_against_base("extra", app.config.cwd.as_path());
|
|
let permission_profile = PermissionProfile::Managed {
|
|
network: NetworkSandboxPolicy::Restricted,
|
|
file_system: ManagedFileSystemPermissions::Restricted {
|
|
entries: vec![
|
|
FileSystemSandboxEntry {
|
|
path: FileSystemPath::Special {
|
|
value: FileSystemSpecialPath::Root,
|
|
},
|
|
access: FileSystemAccessMode::Read,
|
|
missing_path_behavior: None,
|
|
},
|
|
FileSystemSandboxEntry {
|
|
path: FileSystemPath::Path {
|
|
path: extra_root.into(),
|
|
},
|
|
access: FileSystemAccessMode::Write,
|
|
missing_path_behavior: None,
|
|
},
|
|
],
|
|
glob_scan_max_depth: None,
|
|
},
|
|
};
|
|
app.config
|
|
.permissions
|
|
.set_permission_profile(permission_profile.clone())?;
|
|
app.chat_widget.set_permission_profile_with_active_profile(
|
|
permission_profile,
|
|
/*active_permission_profile*/ None,
|
|
)?;
|
|
app.runtime_permission_profile_override =
|
|
Some(RuntimePermissionProfileOverride::from_config(&app.config));
|
|
if let AppCommand::UserTurn {
|
|
active_permission_profile,
|
|
..
|
|
} = &mut active_turn
|
|
{
|
|
*active_permission_profile = None;
|
|
}
|
|
}
|
|
|
|
if scenario == SafetyRetryScenario::PendingPermissions {
|
|
app.runtime_permission_profile_override = Some(
|
|
RuntimePermissionProfileOverride::from_config(app.chat_widget.config_ref()),
|
|
);
|
|
app.select_permission_profile(
|
|
&mut app_server,
|
|
PermissionProfileSelection {
|
|
profile_id: ":read-only".into(),
|
|
approval_policy: Some(AskForApproval::OnRequest),
|
|
approvals_reviewer: Some(ApprovalsReviewer::User),
|
|
display_label: "Read Only".into(),
|
|
},
|
|
)
|
|
.await;
|
|
}
|
|
|
|
Box::pin(app.retry_safety_buffered_turn(
|
|
&mut tui,
|
|
&mut app_server,
|
|
SafetyBufferedRetry {
|
|
thread_id: source_thread_id,
|
|
turn_id: active_turn_id.clone(),
|
|
model: FASTER_MODEL.to_string(),
|
|
turn: active_turn,
|
|
prompt: UserMessage::from(RETRY_PROMPT),
|
|
},
|
|
))
|
|
.await;
|
|
assert_eq!(app.voice_owner_thread_id(), Some(voice_owner));
|
|
|
|
if scenario == SafetyRetryScenario::UnsupportedPermissions {
|
|
assert_eq!(app.active_thread_id, Some(source_thread_id));
|
|
assert_eq!(app.primary_thread_id, Some(source_thread_id));
|
|
assert_eq!(app.chat_widget.thread_id(), Some(source_thread_id));
|
|
assert!(
|
|
app.chat_widget
|
|
.can_retry_safety_buffered_turn(&active_turn_id)
|
|
);
|
|
let source = app_server
|
|
.thread_read(source_thread_id, /*include_turns*/ true)
|
|
.await?;
|
|
assert_eq!(
|
|
source.turns.last().map(|turn| &turn.status),
|
|
Some(&TurnStatus::InProgress)
|
|
);
|
|
let error_cell = std::iter::from_fn(|| app_event_rx.try_recv().ok())
|
|
.find_map(|event| match event {
|
|
AppEvent::InsertHistoryCell(cell) => Some(cell),
|
|
_ => None,
|
|
})
|
|
.expect("unsupported permissions should be added to history");
|
|
insta::assert_snapshot!(
|
|
lines_to_single_string(&error_cell.display_lines(/*width*/ 200)),
|
|
@"■ Failed to retry with a faster model: the selected permission profile cannot be safely represented by the legacy app-server sandbox policy; select a named or legacy-compatible permission profile"
|
|
);
|
|
if let Some(release_active_response) = release_active_response.take() {
|
|
let _ = release_active_response.send(());
|
|
}
|
|
let _ = release_steered_response.send(());
|
|
let _ = release_previous_response.send(());
|
|
let _ = release_retry_response.send(());
|
|
app_server.shutdown().await?;
|
|
server.shutdown().await;
|
|
return Ok(());
|
|
}
|
|
|
|
let first_retry_thread_id = app.chat_widget.thread_id().expect("first retry thread id");
|
|
if scenario == SafetyRetryScenario::RetryTwice {
|
|
let first_retry_turn_id =
|
|
next_turn_started(&mut app, &mut app_server, first_retry_thread_id).await;
|
|
drive_until_request_count(
|
|
&mut app,
|
|
&mut app_server,
|
|
&server,
|
|
/*expected_request_count*/ 2,
|
|
)
|
|
.await;
|
|
app.handle_app_server_event(
|
|
&app_server,
|
|
AppServerEvent::ServerNotification(Box::new(
|
|
ServerNotification::ModelSafetyBufferingUpdated(
|
|
ModelSafetyBufferingUpdatedNotification {
|
|
thread_id: first_retry_thread_id.to_string(),
|
|
turn_id: first_retry_turn_id.clone(),
|
|
model: FASTER_MODEL.to_string(),
|
|
use_cases: Vec::new(),
|
|
reasons: Vec::new(),
|
|
show_buffering_ui: true,
|
|
faster_model: Some(FASTER_MODEL.to_string()),
|
|
},
|
|
),
|
|
)),
|
|
)
|
|
.await;
|
|
drain_active_thread_events(&mut app);
|
|
assert!(
|
|
app.chat_widget
|
|
.can_retry_safety_buffered_turn(&first_retry_turn_id)
|
|
);
|
|
app.chat_widget
|
|
.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
let second_retry = loop {
|
|
match app_event_rx.try_recv() {
|
|
Ok(event @ AppEvent::ConfirmSafetyBufferedRetry { .. }) => {
|
|
Box::pin(app.handle_event(&mut tui, &mut app_server, event)).await?;
|
|
app.chat_widget
|
|
.handle_key_event(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
|
|
app.chat_widget
|
|
.handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
|
|
}
|
|
Ok(AppEvent::RetrySafetyBufferedTurn {
|
|
thread_id,
|
|
turn_id,
|
|
model,
|
|
turn,
|
|
prompt,
|
|
}) => {
|
|
break SafetyBufferedRetry {
|
|
thread_id,
|
|
turn_id,
|
|
model,
|
|
turn,
|
|
prompt,
|
|
};
|
|
}
|
|
Ok(_) => continue,
|
|
Err(err) => panic!("expected second safety-buffering retry event: {err}"),
|
|
}
|
|
};
|
|
let AppCommand::UserTurn { items, .. } = &second_retry.turn else {
|
|
panic!("second safety-buffering retry should retain the user turn");
|
|
};
|
|
assert!(items.iter().any(
|
|
|item| matches!(item, AppServerUserInput::Text { text, .. } if text == RETRY_PROMPT)
|
|
));
|
|
Box::pin(app.retry_safety_buffered_turn(&mut tui, &mut app_server, second_retry)).await;
|
|
}
|
|
|
|
if let Some(draft) = failing_draft {
|
|
assert_eq!(
|
|
app.chat_widget.composer_text_with_pending(),
|
|
format!("{RETRY_PROMPT}\n{draft}")
|
|
);
|
|
assert_eq!(app.chat_widget.thread_id(), Some(source_thread_id));
|
|
if let Some(release_active_response) = release_active_response.take() {
|
|
let _ = release_active_response.send(());
|
|
}
|
|
let _ = release_steered_response.send(());
|
|
app_server.shutdown().await?;
|
|
server.shutdown().await;
|
|
return Ok(());
|
|
}
|
|
|
|
let retry_thread_id = app.chat_widget.thread_id().expect("retry thread id");
|
|
// Capture the completed retry before processing its automatic goal continuation.
|
|
wait_for_turn_completed(&mut app, &mut app_server, retry_thread_id).await;
|
|
if scenario == SafetyRetryScenario::PendingPermissions {
|
|
assert_eq!(
|
|
app.chat_widget
|
|
.config_ref()
|
|
.permissions
|
|
.permission_profile(),
|
|
&PermissionProfile::read_only()
|
|
);
|
|
}
|
|
let mut replayed_history = String::new();
|
|
while let Ok(event) = app_event_rx.try_recv() {
|
|
if let AppEvent::InsertHistoryCell(cell) = event {
|
|
let rendered = lines_to_single_string(&cell.transcript_lines(/*width*/ 80));
|
|
if cell
|
|
.as_any()
|
|
.is::<crate::history_cell::FinalMessageSeparator>()
|
|
{
|
|
replayed_history
|
|
.push_str(&normalize_completion_timestamps(cell.as_ref(), rendered));
|
|
} else {
|
|
replayed_history.push_str(&rendered);
|
|
}
|
|
}
|
|
}
|
|
assert_eq!(
|
|
replayed_history.contains("Conversation interrupted"),
|
|
scenario == SafetyRetryScenario::InterruptedPrevious
|
|
);
|
|
let forked_history = replayed_history
|
|
.rsplit_once("Thread forked from")
|
|
.expect("safety retry should render fork lineage")
|
|
.1;
|
|
assert_eq!(
|
|
forked_history.matches(RETRY_PROMPT).count(),
|
|
1,
|
|
"the fork should render the retried prompt once: {forked_history}"
|
|
);
|
|
if committed_steer.is_some() {
|
|
let rendered_retry = forked_history
|
|
.lines()
|
|
.skip_while(|line| !line.contains(RETRY_PROMPT))
|
|
.collect::<Vec<_>>()
|
|
.join("\n");
|
|
insta::assert_snapshot!("safety_retry_committed_steer_history", rendered_retry);
|
|
}
|
|
|
|
drive_until_request_count(&mut app, &mut app_server, &server, expected_request_count).await;
|
|
let source = app_server
|
|
.thread_read(source_thread_id, /*include_turns*/ true)
|
|
.await?;
|
|
let retry = app_server
|
|
.thread_read(retry_thread_id, /*include_turns*/ true)
|
|
.await?;
|
|
assert_ne!(retry_thread_id, source_thread_id);
|
|
assert_eq!(
|
|
source.turns.last().map(|turn| &turn.status),
|
|
Some(&TurnStatus::Interrupted)
|
|
);
|
|
assert_eq!(
|
|
retry.forked_from_id.as_deref(),
|
|
Some(
|
|
if scenario == SafetyRetryScenario::RetryTwice {
|
|
first_retry_thread_id
|
|
} else {
|
|
source_thread_id
|
|
}
|
|
.to_string()
|
|
)
|
|
.as_deref()
|
|
);
|
|
let expected_retry_prompt = match committed_steer {
|
|
Some(committed_steer) => format!("{RETRY_PROMPT}\n{committed_steer}"),
|
|
None => RETRY_PROMPT.to_string(),
|
|
};
|
|
assert_eq!(user_message_count(&source, RETRY_PROMPT), 1);
|
|
assert_eq!(user_message_count(&retry, &expected_retry_prompt), 1);
|
|
if let Some(committed_steer) = committed_steer {
|
|
assert_eq!(user_message_count(&source, committed_steer), 1);
|
|
}
|
|
if let Some(previous_prompt) = previous_prompt {
|
|
assert_eq!(user_message_count(&source, previous_prompt), 1);
|
|
assert_eq!(user_message_count(&retry, previous_prompt), 1);
|
|
}
|
|
|
|
let source_goal = app_server
|
|
.thread_goal_get(source_thread_id)
|
|
.await?
|
|
.goal
|
|
.expect("source goal");
|
|
let retry_goal = app_server
|
|
.thread_goal_get(retry_thread_id)
|
|
.await?
|
|
.goal
|
|
.expect("retry goal");
|
|
let expected_source_tokens = if committed_steer.is_some() { 150 } else { 50 };
|
|
assert_eq!(source_goal.objective, RETRY_GOAL);
|
|
assert_eq!(source_goal.tokens_used, expected_source_tokens);
|
|
assert!(source_goal.time_used_seconds >= 12);
|
|
assert_eq!(retry_goal.objective, RETRY_GOAL);
|
|
assert!(retry_goal.tokens_used >= expected_source_tokens);
|
|
assert!(retry_goal.time_used_seconds >= source_goal.time_used_seconds);
|
|
|
|
let request_bodies = server
|
|
.requests()
|
|
.await
|
|
.iter()
|
|
.map(|request| serde_json::from_slice::<Value>(request))
|
|
.collect::<serde_json::Result<Vec<_>>>()?;
|
|
let retry_request_index =
|
|
usize::from(previous_prompt.is_some()) + usize::from(committed_steer.is_some()) + 1;
|
|
let retry_request = request_bodies
|
|
.get(retry_request_index)
|
|
.expect("retry should issue a Responses API request");
|
|
assert_eq!(retry_request["model"].as_str(), Some(FASTER_MODEL));
|
|
assert_eq!(retry_request["reasoning"]["effort"].as_str(), Some("low"));
|
|
let relevant_prompts = user_input_texts(retry_request)
|
|
.into_iter()
|
|
.filter(|text| {
|
|
text == PREVIOUS_PROMPT
|
|
|| text == RETRY_PROMPT
|
|
|| committed_steer.is_some_and(|steer| text == steer)
|
|
})
|
|
.collect::<Vec<_>>();
|
|
let mut expected_prompts = match previous_prompt {
|
|
Some(previous_prompt) => vec![previous_prompt.to_string(), RETRY_PROMPT.to_string()],
|
|
None => vec![RETRY_PROMPT.to_string()],
|
|
};
|
|
expected_prompts.extend(committed_steer.map(str::to_string));
|
|
assert_eq!(relevant_prompts, expected_prompts);
|
|
if previous_prompt.is_none() {
|
|
assert!(
|
|
!user_input_texts(retry_request)
|
|
.iter()
|
|
.any(|text| text.contains("<turn_aborted>")),
|
|
"first-turn safety retry should not inherit an interruption marker"
|
|
);
|
|
}
|
|
let goal_continuation_request_index = if scenario == SafetyRetryScenario::RetryTwice {
|
|
let second_retry_request = request_bodies
|
|
.get(retry_request_index + 1)
|
|
.expect("second retry should issue a Responses API request");
|
|
assert!(
|
|
user_input_texts(second_retry_request)
|
|
.iter()
|
|
.any(|text| text == RETRY_PROMPT),
|
|
"second safety retry should submit the original prompt"
|
|
);
|
|
assert!(
|
|
!user_input_texts(second_retry_request)
|
|
.iter()
|
|
.any(|text| text.contains("<turn_aborted>")),
|
|
"second safety retry should not inherit an interruption marker"
|
|
);
|
|
retry_request_index + 2
|
|
} else {
|
|
retry_request_index + 1
|
|
};
|
|
assert!(
|
|
user_input_texts(&request_bodies[goal_continuation_request_index])
|
|
.iter()
|
|
.any(|text| text.contains(RETRY_GOAL)),
|
|
"inherited goal continuation should resume after the explicit retry"
|
|
);
|
|
|
|
if let Some(release_active_response) = release_active_response.take() {
|
|
let _ = release_active_response.send(());
|
|
}
|
|
let _ = release_steered_response.send(());
|
|
let _ = release_previous_response.send(());
|
|
let _ = release_retry_response.send(());
|
|
app_server.shutdown().await?;
|
|
server.shutdown().await;
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn safety_retry_forks_after_the_previous_turn_and_uses_faster_settings() -> Result<()> {
|
|
run_safety_retry(
|
|
Some(PREVIOUS_PROMPT),
|
|
/*failing_draft*/ None,
|
|
/*committed_steer*/ None,
|
|
SafetyRetryScenario::Once,
|
|
)
|
|
.await
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn safety_retry_preserves_a_committed_steer_from_the_interrupted_turn() -> Result<()> {
|
|
run_safety_retry(
|
|
Some(PREVIOUS_PROMPT),
|
|
/*failing_draft*/ None,
|
|
Some(COMMITTED_STEER),
|
|
SafetyRetryScenario::Once,
|
|
)
|
|
.await
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn safety_retry_forks_first_turn_and_continues_without_duplicating_prompt() -> Result<()> {
|
|
run_safety_retry(
|
|
/*previous_prompt*/ None,
|
|
/*failing_draft*/ None,
|
|
/*committed_steer*/ None,
|
|
SafetyRetryScenario::Once,
|
|
)
|
|
.await
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn safety_retry_can_retry_a_first_turn_a_second_time() -> Result<()> {
|
|
run_safety_retry(
|
|
/*previous_prompt*/ None,
|
|
/*failing_draft*/ None,
|
|
/*committed_steer*/ None,
|
|
SafetyRetryScenario::RetryTwice,
|
|
)
|
|
.await
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn safety_retry_replays_older_interruption_notices() -> Result<()> {
|
|
run_safety_retry(
|
|
Some(PREVIOUS_PROMPT),
|
|
/*failing_draft*/ None,
|
|
/*committed_steer*/ None,
|
|
SafetyRetryScenario::InterruptedPrevious,
|
|
)
|
|
.await
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn safety_retry_branch_failure_preserves_unsent_draft() -> Result<()> {
|
|
run_safety_retry(
|
|
Some(PREVIOUS_PROMPT),
|
|
Some(UNSENT_DRAFT),
|
|
/*committed_steer*/ None,
|
|
SafetyRetryScenario::Once,
|
|
)
|
|
.await
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn safety_retry_rejects_unsupported_permissions_before_interrupting() -> Result<()> {
|
|
run_safety_retry(
|
|
/*previous_prompt*/ None,
|
|
/*failing_draft*/ None,
|
|
/*committed_steer*/ None,
|
|
SafetyRetryScenario::UnsupportedPermissions,
|
|
)
|
|
.await
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn safety_retry_preserves_unconfirmed_permissions_on_its_first_turn() -> Result<()> {
|
|
run_safety_retry(
|
|
/*previous_prompt*/ None,
|
|
/*failing_draft*/ None,
|
|
/*committed_steer*/ None,
|
|
SafetyRetryScenario::PendingPermissions,
|
|
)
|
|
.await
|
|
}
|