mirror of
https://github.com/openai/codex.git
synced 2026-11-19 22:30:42 +00:00
## What changed - Show a refusal status while preparing alternative suggestions and remove the pending notice above the composer. - Clarify that choosing a rewrite starts a new chat with earlier context, and update overview suggestions to explicitly say users can ask Codex. - Add an option to report safety-check concerns through the consent flow when reporting is enabled. ## Testing Update safety recourse snapshots and extend coverage for reporting consent, returning to the picker, and Daybreak notices when enabled or unavailable for the selected model. GitOrigin-RevId: 99f565ebec7064ec55d388e73acede2dfe639474
1564 lines
60 KiB
Rust
1564 lines
60 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 =
|
||
tokio::time::timeout(std::time::Duration::from_secs(5), server.next_event())
|
||
.await
|
||
.unwrap_or_else(|_| {
|
||
panic!("timed out waiting for {domain} moderation metadata")
|
||
})
|
||
.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("I can’t help with this request. Preparing alternative suggestions…")
|
||
);
|
||
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!(
|
||
request_bodies[goal_continuation_request_index]["input"]
|
||
.as_array()
|
||
.expect("goal continuation model input")
|
||
.iter()
|
||
.any(|item| {
|
||
item["type"] == "function_call_output"
|
||
&& item["namespace"] == "agent"
|
||
&& item["name"] == "goal_objective"
|
||
&& item["output"] == 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
|
||
}
|