Make TUI thread titles resilient to generation failures (#60842)

## Why

Threads need a visible title while automatic generation is pending or fails. Hidden title-generation requests must also stay out of the foreground conversation, including during skill installation prompts.

## What changed

- Immediately display a Markdown-stripped, single-line excerpt of the first message, capped at 60 characters. Replace it with the generated title, or save the excerpt if generation fails or returns an invalid title.
- Give title threads explicit read-only permissions and request the `never` approval policy, subject to managed policy constraints. Keep blocking input requests on the hidden thread until timeout.
- Interrupt timed-out temporary structured turns before detaching them.

## Testing

Add coverage for provisional title replacement, fallback persistence, managed permission and approval policies, and hidden input requests. Add a terminal integration test that verifies title generation after choosing “Continue anyway” on a skill installation prompt.

GitOrigin-RevId: f408f3061e5e7f0d9d6bc1f2f9674303e9e68400
This commit is contained in:
Eric Traut
2026-11-11 18:59:32 +00:00
committed by copyberry
parent ed7ca22bb6
commit 54b90f98a5
16 changed files with 369 additions and 118 deletions
+7 -1
View File
@@ -656,7 +656,13 @@ pub(crate) struct App {
realtime_replay_order: VecDeque<ThreadId>,
background_voice: Option<Box<ChatWidget>>,
background_voice_error: Option<(ThreadId, String)>,
temporary_structured_requests: HashMap<ThreadId, mpsc::UnboundedSender<ServerNotification>>,
temporary_structured_requests: HashMap<
ThreadId,
(
crate::temporary_structured_request::TemporaryThreadKind,
mpsc::UnboundedSender<ServerNotification>,
),
>,
/// Track title generation across thread switches and deduplicate automatic requests.
pending_thread_titles: HashMap<(ThreadId, ThreadTitleDestination), CancellationToken>,
thread_event_listener_tasks: HashMap<ThreadId, JoinHandle<()>>,
+10 -3
View File
@@ -228,7 +228,7 @@ impl App {
// Hidden helper threads must not enter visible thread routing or overview refreshes.
let target = server_notification_thread_target(&notification);
if let ServerNotificationThreadTarget::Thread(thread_id) = target
&& let Some(sender) = self.temporary_structured_requests.get(&thread_id)
&& let Some((_, sender)) = self.temporary_structured_requests.get(&thread_id)
{
if matches!(
&notification,
@@ -597,9 +597,16 @@ impl App {
) {
let request = &buffered_request.request;
let thread_id = server_request_thread_id(request);
if thread_id
.is_some_and(|thread_id| self.temporary_structured_requests.contains_key(&thread_id))
if let Some((kind, _)) =
thread_id.and_then(|id| self.temporary_structured_requests.get(&id))
{
// Managed policy can allow a title turn to ask a question. Keep it on
// the hidden thread until the structured turn times out, as on desktop.
if *kind == crate::temporary_structured_request::TemporaryThreadKind::Title
&& matches!(request, ServerRequest::ToolRequestUserInput { params, .. } if params.is_blocking)
{
return;
}
self.reject_unsupported_app_server_request(
super::app_server_requests::UnsupportedAppServerRequest {
request_id: request.id().clone(),
+3 -1
View File
@@ -3278,7 +3278,7 @@ impl App {
AppEvent::RenameAgentsOverviewThread { thread_id, name } => {
match app_server.thread_set_name(thread_id, name.clone()).await {
Ok(()) => {
self.chat_widget.expect_manual_thread_name(thread_id, name);
self.chat_widget.display_thread_name(thread_id, name);
self.cancel_thread_title_generation(thread_id);
}
Err(error) => {
@@ -3316,6 +3316,7 @@ impl App {
thread_id,
destination,
prompt,
fallback_title,
effort,
result,
} => {
@@ -3324,6 +3325,7 @@ impl App {
thread_id,
destination,
prompt,
fallback_title,
effort,
result,
cancellation,
+9 -7
View File
@@ -15,10 +15,10 @@ use crate::history_cell::ThreadRecapHistoryCell;
use crate::history_cell::ThreadRecapLoadingCell;
use crate::pager_overlay::Overlay;
use crate::temporary_structured_request::TemporaryStructuredThreadOptions;
use crate::temporary_structured_request::TemporaryThreadKind;
use crate::temporary_structured_request::run_temporary_structured_turn;
use crate::temporary_structured_request::start_temporary_thread;
use crate::temporary_structured_request::unsubscribe_temporary_thread;
use codex_app_server_protocol::ThreadSource;
use codex_app_server_protocol::Turn;
use codex_app_server_protocol::TurnStatus;
use codex_context_fragments::ContextualUserFragment;
@@ -237,7 +237,7 @@ impl App {
config.cwd.display().to_string()
};
let options = TemporaryStructuredThreadOptions {
thread_source: ThreadSource::Feature("system".to_string()),
kind: TemporaryThreadKind::Recap,
model,
model_provider: config.model_provider_id.clone(),
cwd,
@@ -337,17 +337,19 @@ impl App {
let (sender, receiver) = mpsc::unbounded_channel();
self.temporary_structured_requests
.insert(temporary_thread_id, sender);
.insert(temporary_thread_id, (TemporaryThreadKind::Recap, sender));
let request_handle = app_server.request_handle();
let event_sender = self.app_event_tx.clone();
let task = tokio::spawn(async move {
let result = run_temporary_structured_turn(
request_handle,
temporary_thread_id_text,
recap_prompt(&history),
recap_output_schema(),
/*effort*/ None,
TemporaryThreadKind::Recap.turn_params(
temporary_thread_id_text,
recap_prompt(&history),
recap_output_schema(),
/*effort*/ None,
),
receiver,
CancellationToken::new(),
)
@@ -1,11 +1,10 @@
---
source: tui/src/app/thread_title_tests.rs
assertion_line: 302
expression: "normalize_snapshot_paths(format!(\"terminal title: {}\\nfooter:\\n{}\",\napp.chat_widget.last_terminal_title.as_deref().unwrap_or_default(),\nrender_bottom_popup(&app.chat_widget, 120)))"
---
terminal title: project
terminal title: Fix the login timeout | project
footer:
› Ask Codex to do anything
gpt-5.2 default · /tmp/project
gpt-5.2 default · /tmp/project · Fix the login timeout
← for agents · ? for shortcuts
@@ -3,6 +3,7 @@ use crate::app::session_lifecycle::ThreadAttachPresentation;
use crate::app::tests::session_lifecycle_requests::recorded_params;
use crate::app::tests::session_lifecycle_requests::start_recording_remote_app_server;
use crate::app_event::RecapTrigger;
use crate::temporary_structured_request::TemporaryThreadKind;
use codex_app_server_client::AppServerClient;
use codex_model_provider_info::ModelProviderInfo;
use core_test_support::responses;
@@ -493,7 +494,7 @@ async fn temporary_recap_threads_disable_memories_and_remote_mcp_servers() -> Re
let config = app.chat_widget.config_ref();
let options = crate::temporary_structured_request::TemporaryStructuredThreadOptions {
thread_source: codex_app_server_protocol::ThreadSource::Feature("system".to_string()),
kind: TemporaryThreadKind::Recap,
model: app.chat_widget.current_model().to_string(),
model_provider: config.model_provider_id.clone(),
cwd: config.cwd.display().to_string(),
@@ -509,7 +510,8 @@ async fn temporary_recap_threads_disable_memories_and_remote_mcp_servers() -> Re
.await?;
let thread_id = ThreadId::from_string(&response.thread.id)?;
let (sender, _receiver) = tokio::sync::mpsc::unbounded_channel();
app.temporary_structured_requests.insert(thread_id, sender);
app.temporary_structured_requests
.insert(thread_id, (TemporaryThreadKind::Recap, sender));
// Even if a hidden thread reaches visible routing, it must not prompt.
app.primary_thread_id = Some(thread_id);
app.active_thread_id = Some(thread_id);
@@ -528,6 +530,23 @@ async fn temporary_recap_threads_disable_memories_and_remote_mcp_servers() -> Re
);
}
// A managed policy can also cause an ephemeral title to ask for input.
// Its request stays unanswered and never enters the visible chat.
let title_id = ThreadId::new();
let (sender, _receiver) = tokio::sync::mpsc::unbounded_channel();
app.temporary_structured_requests
.insert(title_id, (TemporaryThreadKind::Title, sender));
let question = request_user_input_request(title_id, "title-turn", "question");
app.handle_app_server_event(
&app_server,
codex_app_server_client::AppServerEvent::ServerRequest(Box::new(question.clone())),
)
.await;
assert!(
!app.pending_app_server_requests
.contains_server_request(&question)
);
let starts = recorded_params(&requests, "thread/start");
assert_eq!(starts.len(), 1);
assert_eq!(starts[0]["sandbox"], "read-only");
+2 -2
View File
@@ -857,7 +857,7 @@ impl App {
AppCommand::SetThreadName { name } => {
let name = name.to_string();
app_server.thread_set_name(thread_id, name.clone()).await?;
self.chat_widget.expect_manual_thread_name(thread_id, name);
self.chat_widget.display_thread_name(thread_id, name);
self.cancel_thread_title_generation(thread_id);
Ok(true)
}
@@ -2206,7 +2206,7 @@ impl App {
app_server,
thread_id,
ThreadTitleDestination::Automatic,
super::thread_title::thread_title_prompt(&user_message),
&user_message,
);
}
if !had_active_modal
+73 -25
View File
@@ -1,6 +1,6 @@
//! Structured-output schema and normalization for generated TUI thread titles.
//!
//! Automatic titles are persisted only after generation, including for inactive threads;
//! Automatic titles use the first message until generation completes and as a fallback;
//! the originating thread's saved name takes precedence over an automatic result. Manual
//! renames cancel pending requests; canceled events cannot affect newer requests.
@@ -11,17 +11,20 @@ use crate::app_event::ThreadTitleDestination;
use crate::app_server_session::AppServerSession;
use crate::app_server_session::ThreadSettingsOwner;
use crate::temporary_structured_request::TemporaryStructuredThreadOptions;
use crate::temporary_structured_request::TemporaryThreadKind;
use crate::temporary_structured_request::run_temporary_structured_turn;
use crate::temporary_structured_request::start_temporary_thread;
use crate::temporary_structured_request::unsubscribe_temporary_thread;
use codex_app_server_protocol::ServerNotification;
use codex_app_server_protocol::ThreadItemPayload;
use codex_app_server_protocol::ThreadSource;
use codex_app_server_protocol::Turn;
use codex_app_server_protocol::UserInput;
use codex_protocol::ThreadId;
use codex_protocol::models::MessagePhase;
use codex_protocol::openai_models::ReasoningEffort;
use pulldown_cmark::Event;
use pulldown_cmark::Parser;
use pulldown_cmark::TagEnd;
use serde::Deserialize;
use serde_json::Value;
use serde_json::json;
@@ -66,7 +69,7 @@ impl App {
app_server: &AppServerSession,
thread_id: ThreadId,
destination: ThreadTitleDestination,
prompt: String,
source_text: &str,
) {
if app_server.thread_params_mode().settings_owner() == ThreadSettingsOwner::Server {
if let ThreadTitleDestination::RenameSuggestion { request_id } = destination {
@@ -81,6 +84,19 @@ impl App {
return;
};
let cancellation = entry.insert(CancellationToken::new()).clone();
let (prompt, fallback_title) = match destination {
ThreadTitleDestination::Automatic => {
let fallback = fallback_thread_title(source_text);
if let Some(title) = &fallback {
self.chat_widget
.display_thread_name(thread_id, title.clone());
}
(thread_title_prompt(source_text), fallback)
}
ThreadTitleDestination::RenameSuggestion { .. } => {
(recent_conversation_thread_title_prompt(source_text), None)
}
};
let request_handle = app_server.request_handle();
let model = if self.chat_widget.config_ref().model_provider_id == "openai"
&& self.chat_widget.has_chatgpt_account()
@@ -97,7 +113,7 @@ impl App {
let effort = (model == THREAD_TITLE_MODEL).then_some(ReasoningEffort::Low);
let config = self.chat_widget.config_ref();
let options = TemporaryStructuredThreadOptions {
thread_source: ThreadSource::Feature("thread_title".to_string()),
kind: TemporaryThreadKind::Title,
model,
model_provider: config.model_provider_id.clone(),
cwd: config.cwd.display().to_string(),
@@ -119,6 +135,7 @@ impl App {
thread_id,
destination,
prompt,
fallback_title,
effort,
result,
});
@@ -133,6 +150,7 @@ impl App {
thread_id: ThreadId,
destination: ThreadTitleDestination,
prompt: String,
fallback_title: Option<String>,
effort: Option<ReasoningEffort>,
result: Result<String, String>,
cancellation: CancellationToken,
@@ -146,11 +164,18 @@ impl App {
}
return;
}
let temporary_thread_id_text = match result {
Ok(thread_id) => thread_id,
let save_name = (destination == ThreadTitleDestination::Automatic)
.then(|| app_server.automatic_thread_name_writer(thread_id));
let temporary_thread_id = match result
.and_then(|id| ThreadId::from_string(&id).map_err(|error| error.to_string()))
{
Ok(id) => id,
Err(error) => {
tracing::debug!(%error, "failed to start title-generation thread");
self.finish_thread_title_generation(thread_id, destination);
if let (Some(writer), Some(title)) = (save_name, fallback_title) {
tokio::spawn(async move { writer.save(title, &cancellation).await });
}
if let ThreadTitleDestination::RenameSuggestion { request_id } = destination {
self.chat_widget.apply_thread_name_suggestion(
thread_id, request_id, /*suggestion*/ None,
@@ -160,30 +185,21 @@ impl App {
}
};
let Ok(temporary_thread_id) = ThreadId::from_string(&temporary_thread_id_text) else {
self.finish_thread_title_generation(thread_id, destination);
if let ThreadTitleDestination::RenameSuggestion { request_id } = destination {
self.chat_widget
.apply_thread_name_suggestion(thread_id, request_id, /*suggestion*/ None);
}
return;
};
let (sender, receiver) = mpsc::unbounded_channel();
self.temporary_structured_requests
.insert(temporary_thread_id, sender);
.insert(temporary_thread_id, (TemporaryThreadKind::Title, sender));
let save_name = (destination == ThreadTitleDestination::Automatic)
.then(|| app_server.automatic_thread_name_writer(thread_id));
let request_handle = app_server.request_handle();
let event_sender = self.app_event_tx.clone();
tokio::spawn(async move {
let result = run_temporary_structured_turn(
request_handle,
temporary_thread_id_text,
prompt,
thread_title_output_schema(),
effort,
TemporaryThreadKind::Title.turn_params(
temporary_thread_id.to_string(),
prompt,
thread_title_output_schema(),
effort,
),
receiver,
cancellation.clone(),
)
@@ -191,8 +207,11 @@ impl App {
.map_err(|error| error.to_string());
if let Some(save_name) = save_name
&& let Ok(response) = &result
&& let Some(title) = parse_thread_title(response)
&& let Some(title) = result
.as_deref()
.ok()
.and_then(parse_thread_title)
.or(fallback_title)
{
save_name.save(title, &cancellation).await;
}
@@ -258,7 +277,7 @@ impl App {
app_server,
thread_id,
ThreadTitleDestination::RenameSuggestion { request_id },
recent_conversation_thread_title_prompt(&conversation),
&conversation,
);
}
}
@@ -291,6 +310,35 @@ fn thread_title_instructions() -> String {
)
}
/// Desktop shows a single line from the first message until a generated title is available.
fn fallback_thread_title(message: &str) -> Option<String> {
const MAX_CHARS: usize = 60;
const INPUT_CHAR_LIMIT: usize = 2_000;
let excerpt: String = message.trim().chars().take(INPUT_CHAR_LIMIT).collect();
let mut text = String::new();
for event in Parser::new(&excerpt) {
match event {
Event::Text(value) | Event::Code(value) => text.push_str(&value),
Event::SoftBreak
| Event::HardBreak
| Event::Rule
| Event::End(
TagEnd::Paragraph | TagEnd::Heading(_) | TagEnd::Item | TagEnd::CodeBlock,
) => text.push(' '),
_ => {}
}
}
let mut title = text.split_whitespace().collect::<Vec<_>>().join(" ");
let mut chars = title.char_indices().skip(MAX_CHARS - 1);
if let Some((end, _)) = chars.next()
&& chars.next().is_some()
{
title.truncate(title[..end].trim_end().len());
title.push('…');
}
(!title.is_empty()).then_some(title)
}
/// Build a bounded title request without truncating a Unicode character.
pub(super) fn thread_title_prompt(user_message: &str) -> String {
let instructions = thread_title_instructions();
+39 -11
View File
@@ -108,7 +108,7 @@ async fn cloud_conversations_skip_tui_generated_titles() {
&app_server,
thread_id,
ThreadTitleDestination::Automatic,
thread_title_prompt("Fix the login timeout"),
"Fix the login timeout",
);
assert!(app.pending_thread_titles.is_empty());
@@ -210,10 +210,16 @@ async fn slash_rename_generates_editable_title_through_embedded_app_server()
}
#[tokio::test]
async fn automatic_thread_title_generates_without_a_provisional_name() -> color_eyre::Result<()> {
async fn automatic_thread_title_replaces_the_provisional_name() -> color_eyre::Result<()> {
check_thread_title_generation(TitleScenario::Automatic).await
}
#[tokio::test]
async fn automatic_thread_title_saves_the_first_message_if_generation_fails()
-> color_eyre::Result<()> {
check_thread_title_generation(TitleScenario::Fallback).await
}
#[tokio::test]
async fn manual_rename_cancels_running_thread_title() -> color_eyre::Result<()> {
check_thread_title_generation(TitleScenario::ManualRename).await
@@ -227,6 +233,7 @@ async fn overview_rename_cancels_running_thread_title() -> color_eyre::Result<()
#[derive(Clone, Copy)]
enum TitleScenario {
Automatic,
Fallback,
Suggestion,
ManualRename,
OverviewRename,
@@ -239,9 +246,19 @@ async fn check_thread_title_generation(scenario: TitleScenario) -> color_eyre::R
TitleScenario::ManualRename | TitleScenario::OverviewRename
);
let server = wiremock::MockServer::start().await;
let user_message = if matches!(scenario, TitleScenario::Fallback) {
"Fix the **login**\n[timeout](https://example.test/issue)"
} else {
"Fix the login timeout"
};
let title_message = if matches!(scenario, TitleScenario::Fallback) {
"{}"
} else {
r#"{"title":"Fix login timeout"}"#
};
let mut template = responses::sse_response(responses::sse(vec![
responses::ev_response_created("title-response"),
responses::ev_assistant_message("title-message", r#"{"title":"Fix login timeout"}"#),
responses::ev_assistant_message("title-message", title_message),
responses::ev_completed("title-response"),
]));
if cancel {
@@ -303,7 +320,7 @@ async fn check_thread_title_generation(scenario: TitleScenario) -> color_eyre::R
root_turn_id: None,
items: vec![ThreadItem::untimed(title_user_message(
"user-message",
"Fix the login timeout",
user_message,
))],
items_view: Default::default(),
status: TurnStatus::Completed,
@@ -323,7 +340,7 @@ async fn check_thread_title_generation(scenario: TitleScenario) -> color_eyre::R
ItemCompletedNotification::new(
thread_id.to_string(),
"existing-turn".to_string(),
title_user_message("user-message", "Fix the login timeout"),
title_user_message("user-message", user_message),
/*started_at_ms*/ None,
/*completed_at_ms*/ 0,
),
@@ -331,7 +348,10 @@ async fn check_thread_title_generation(scenario: TitleScenario) -> color_eyre::R
)
.await?;
}
assert_eq!(app.chat_widget.thread_name(), None);
assert_eq!(
app.chat_widget.thread_name().as_deref(),
Some("Fix the login timeout")
);
if matches!(scenario, TitleScenario::Automatic) {
app.chat_widget.refresh_status_surfaces();
insta::assert_snapshot!(
@@ -421,7 +441,9 @@ async fn check_thread_title_generation(scenario: TitleScenario) -> color_eyre::R
TitleScenario::OverviewRename => {
AppEvent::RenameAgentsOverviewThread { thread_id, name }
}
TitleScenario::Automatic | TitleScenario::Suggestion => unreachable!(),
TitleScenario::Automatic
| TitleScenario::Fallback
| TitleScenario::Suggestion => unreachable!(),
};
app.handle_event(&mut tui, &mut app_server, event).await?;
assert!(app.pending_thread_titles.is_empty());
@@ -441,7 +463,8 @@ async fn check_thread_title_generation(scenario: TitleScenario) -> color_eyre::R
}
if generated
&& (!cancel || interrupted)
&& (!automatic || app.chat_widget.thread_name().is_some())
&& (!matches!(scenario, TitleScenario::Automatic)
|| app.chat_widget.thread_name().as_deref() == Some("Fix login timeout"))
{
break;
}
@@ -450,6 +473,8 @@ async fn check_thread_title_generation(scenario: TitleScenario) -> color_eyre::R
if automatic {
let expected_name = if cancel {
"Keep this title"
} else if matches!(scenario, TitleScenario::Fallback) {
"Fix the login timeout"
} else {
"Fix login timeout"
};
@@ -483,9 +508,9 @@ async fn check_thread_title_generation(scenario: TitleScenario) -> color_eyre::R
let request = response.single_request();
assert!(
request
.body_json()
.to_string()
.contains("Fix the login timeout")
.message_input_texts("user")
.iter()
.any(|prompt| prompt.contains(user_message))
);
app_server.shutdown().await?;
@@ -533,6 +558,7 @@ async fn canceled_thread_title_ignores_late_start_and_completion() -> color_eyre
thread_id,
destination,
"prompt".to_string(),
/*fallback_title*/ None,
/*effort*/ None,
Ok(temporary_thread_id.to_string()),
cancellation.clone(),
@@ -889,6 +915,7 @@ async fn failed_thread_title_requests_are_removed() -> color_eyre::Result<()> {
thread_id,
ThreadTitleDestination::Automatic,
"prompt".to_string(),
/*fallback_title*/ None,
/*effort*/ None,
Err("startup failed".to_string()),
CancellationToken::new(),
@@ -898,6 +925,7 @@ async fn failed_thread_title_requests_are_removed() -> color_eyre::Result<()> {
thread_id,
suggestion,
"prompt".to_string(),
/*fallback_title*/ None,
/*effort*/ None,
Ok("invalid-thread-id".to_string()),
CancellationToken::new(),
+1
View File
@@ -439,6 +439,7 @@ pub(crate) enum AppEvent {
thread_id: ThreadId,
destination: ThreadTitleDestination,
prompt: String,
fallback_title: Option<String>,
effort: Option<ReasoningEffort>,
result: Result<String, String>,
},
+2 -2
View File
@@ -412,8 +412,8 @@ impl ChatWidget {
)));
}
/// Update status surfaces before a confirmed manual rename's server notification arrives.
pub(crate) fn expect_manual_thread_name(&mut self, thread_id: ThreadId, name: String) {
/// Show a provisional or manually chosen name before its server notification arrives.
pub(crate) fn display_thread_name(&mut self, thread_id: ThreadId, name: String) {
if self.thread_id == Some(thread_id) {
self.thread_name = Some(name);
self.refresh_status_surfaces();
@@ -2176,7 +2176,7 @@ async fn live_app_server_manual_thread_name_updates_status_surfaces() {
ThreadId::from_string("123e4567-e89b-12d3-a456-426614174000").expect("thread id");
chat.thread_id = Some(thread_id);
chat.expect_manual_thread_name(thread_id, "review-fix".to_string());
chat.display_thread_name(thread_id, "review-fix".to_string());
chat.handle_server_notification(
ServerNotification::ThreadNameUpdated(
@@ -2245,7 +2245,7 @@ async fn live_app_server_manual_thread_name_is_visible_before_notification() {
let thread_id = ThreadId::new();
chat.thread_id = Some(thread_id);
chat.expect_manual_thread_name(thread_id, "Manual title".to_string());
chat.display_thread_name(thread_id, "Manual title".to_string());
assert_eq!(chat.thread_name(), Some("Manual title".to_string()));
assert!(drain_insert_history(&mut rx).is_empty());
@@ -1,7 +1,7 @@
//! Run isolated structured requests through existing app-server methods.
use codex_app_server_client::AppServerRequestHandle;
use codex_app_server_client::TypedRequestError;
use codex_app_server_protocol::AskForApproval;
use codex_app_server_protocol::ClientRequest;
use codex_app_server_protocol::RequestId;
use codex_app_server_protocol::SandboxMode;
@@ -31,9 +31,15 @@ use uuid::Uuid;
const STRUCTURED_TURN_TIMEOUT: Duration = Duration::from_secs(/*secs*/ 30);
const STRUCTURED_RESPONSE_MAX_BYTES: usize = 8 * 1024;
/// Preserve the visible thread's provider, permissions, and external-tool isolation.
#[derive(Clone, Copy, PartialEq, Eq)]
pub(crate) enum TemporaryThreadKind {
Title,
Recap,
}
/// Settings for an isolated structured request using the visible thread's provider.
pub(crate) struct TemporaryStructuredThreadOptions {
pub(crate) thread_source: ThreadSource,
pub(crate) kind: TemporaryThreadKind,
pub(crate) model: String,
pub(crate) model_provider: String,
pub(crate) cwd: String,
@@ -44,20 +50,30 @@ pub(crate) struct TemporaryStructuredThreadOptions {
///
/// Structured prompts can contain untrusted transcript text, so the effective app-server config is
/// read first and every MCP server is explicitly disabled alongside built-in and extension tools.
/// Approval policy is inherited from the server; the TUI rejects unexpected interaction requests.
/// As on desktop, title threads request read-only permissions and the `never` approval policy.
pub(crate) async fn start_temporary_thread(
request_handle: &AppServerRequestHandle,
options: TemporaryStructuredThreadOptions,
) -> color_eyre::Result<ThreadStartResponse> {
let TemporaryStructuredThreadOptions {
thread_source,
kind,
model,
model_provider,
cwd,
active_permission_profile,
} = options;
let custom_permission_profile =
active_permission_profile.filter(|profile| !profile.starts_with(':'));
let (source, permissions, approval_policy) = match kind {
TemporaryThreadKind::Title => (
"thread_title",
Some(BUILT_IN_PERMISSION_PROFILE_READ_ONLY.to_string()),
Some(AskForApproval::Never),
),
TemporaryThreadKind::Recap => (
"system",
active_permission_profile.filter(|profile| !profile.starts_with(':')),
None,
),
};
let mut config = std::collections::HashMap::from([
("features.apps".to_string(), false.into()),
("features.code_mode".to_string(), false.into()),
@@ -93,7 +109,7 @@ pub(crate) async fn start_temporary_thread(
("tools.update_plan.enabled".to_string(), false.into()),
("web_search".to_string(), "disabled".into()),
]);
if custom_permission_profile.is_none() {
if permissions.is_none() {
// Managed profiles take precedence over the legacy sandbox override below.
config.insert(
"default_permissions".to_string(),
@@ -116,13 +132,12 @@ pub(crate) async fn start_temporary_thread(
model: Some(model),
model_provider: Some(model_provider),
cwd: Some(cwd),
sandbox: custom_permission_profile
.is_none()
.then_some(SandboxMode::ReadOnly),
permissions: custom_permission_profile.clone(),
approval_policy,
sandbox: permissions.is_none().then_some(SandboxMode::ReadOnly),
permissions: permissions.clone(),
runtime_workspace_roots: Some(Vec::new()),
ephemeral: Some(true),
thread_source: Some(thread_source),
thread_source: Some(ThreadSource::Feature(source.to_string())),
environments: Some(Vec::new()),
dynamic_tools: Some(Vec::new()),
selected_capability_roots: Some(Vec::new()),
@@ -136,7 +151,9 @@ pub(crate) async fn start_temporary_thread(
.await
.map_err(|_| eyre!("temporary structured thread start timed out"))??;
if let Some(expected_profile) = custom_permission_profile {
if kind == TemporaryThreadKind::Recap
&& let Some(expected_profile) = permissions
{
if response
.active_permission_profile
.as_ref()
@@ -147,6 +164,7 @@ pub(crate) async fn start_temporary_thread(
));
}
} else if !matches!(response.sandbox, SandboxPolicy::ReadOnly { .. }) {
unsubscribe_temporary_thread(request_handle, response.thread.id).await;
return Err(eyre!(
"temporary structured thread did not start with read-only permissions"
));
@@ -155,29 +173,28 @@ pub(crate) async fn start_temporary_thread(
Ok(response)
}
/// Submit a structured turn using the temporary thread's existing settings.
pub(crate) async fn start_structured_turn(
request_handle: &AppServerRequestHandle,
thread_id: String,
prompt: String,
output_schema: Value,
effort: Option<ReasoningEffort>,
) -> Result<TurnStartResponse, TypedRequestError> {
request_handle
.request_typed(ClientRequest::TurnStart {
request_id: RequestId::String(format!("temporary-structured-turn-{}", Uuid::new_v4())),
params: TurnStartParams {
thread_id,
input: vec![UserInput::Text {
text: prompt,
text_elements: Vec::new(),
}],
output_schema: Some(output_schema),
effort,
..TurnStartParams::default()
},
})
.await
impl TemporaryThreadKind {
pub(crate) fn turn_params(
self,
thread_id: String,
prompt: String,
output_schema: Value,
effort: Option<ReasoningEffort>,
) -> TurnStartParams {
let is_title = self == Self::Title;
TurnStartParams {
thread_id,
input: vec![UserInput::Text {
text: prompt,
text_elements: Vec::new(),
}],
permissions: is_title.then(|| BUILT_IN_PERMISSION_PROFILE_READ_ONLY.to_string()),
runtime_workspace_roots: is_title.then(Vec::new),
output_schema: Some(output_schema),
effort,
..Default::default()
}
}
}
/// Return the latest assistant message when the requested turn completes.
@@ -252,13 +269,11 @@ pub(crate) async fn unsubscribe_temporary_thread(
/// Run a bounded structured turn, interrupt it on cancellation, and detach the temporary thread.
pub(crate) async fn run_temporary_structured_turn(
request_handle: AppServerRequestHandle,
thread_id: String,
prompt: String,
output_schema: Value,
effort: Option<ReasoningEffort>,
params: TurnStartParams,
notifications: UnboundedReceiver<ServerNotification>,
cancellation: CancellationToken,
) -> color_eyre::Result<String> {
let thread_id = params.thread_id.clone();
let mut turn_id = None;
let result = tokio::time::timeout(STRUCTURED_TURN_TIMEOUT, async {
if cancellation.is_cancelled() {
@@ -266,14 +281,15 @@ pub(crate) async fn run_temporary_structured_turn(
}
// Wait for turn/start to return its ID before interrupting, even if cancellation
// arrives during startup. Dropping that request could leave an orphaned turn.
let turn = start_structured_turn(
&request_handle,
thread_id.clone(),
prompt,
output_schema,
effort,
)
.await?;
let turn: TurnStartResponse = request_handle
.request_typed(ClientRequest::TurnStart {
request_id: RequestId::String(format!(
"temporary-structured-turn-{}",
Uuid::new_v4()
)),
params,
})
.await?;
turn_id = Some(turn.turn.id.clone());
tokio::select! {
@@ -282,12 +298,13 @@ pub(crate) async fn run_temporary_structured_turn(
result = collect_structured_response(notifications, &turn.turn.id) => result,
}
})
.await
.unwrap_or_else(|_| Err(eyre!("temporary structured turn timed out")));
.await;
let timed_out = result.is_err();
let result = result.unwrap_or_else(|_| Err(eyre!("temporary structured turn timed out")));
// Give interruption its own deadline so cancellation near the response timeout
// still gets a chance to stop the hidden turn.
if cancellation.is_cancelled()
if (timed_out || cancellation.is_cancelled())
&& let Some(turn_id) = turn_id
{
let interrupt =
@@ -1,5 +1,6 @@
use super::STRUCTURED_RESPONSE_MAX_BYTES;
use super::TemporaryStructuredThreadOptions;
use super::TemporaryThreadKind;
use super::collect_structured_response;
use super::start_temporary_thread;
use crate::legacy_core::config::ConfigBuilder;
@@ -59,14 +60,40 @@ fn turn_completed_notification(turn_id: &str, status: TurnStatus) -> ServerNotif
#[tokio::test]
async fn managed_workspace_default_respects_read_only_availability() -> color_eyre::Result<()> {
for read_only_allowed in [true, false] {
for (kind, read_only_allowed, policies, expected_approval) in [
(
TemporaryThreadKind::Recap,
true,
r#""on-request""#,
AskForApproval::OnRequest,
),
(
TemporaryThreadKind::Recap,
false,
r#""on-request""#,
AskForApproval::OnRequest,
),
(
TemporaryThreadKind::Title,
true,
r#""on-request", "never""#,
AskForApproval::Never,
),
(
TemporaryThreadKind::Title,
true,
r#""on-request""#,
AskForApproval::OnRequest,
),
] {
let codex_home = tempdir()?;
let requirements_path = codex_home.path().join("requirements.toml");
std::fs::write(
&requirements_path,
format!(
"allowed_approval_policies = [\"on-request\"]\n\
"allowed_approval_policies = [{policies}]\n\
default_permissions = \":workspace\"\n\n\
[features]\nskill_mcp_dependency_install = true\n\n\
[allowed_permission_profiles]\n\
\":read-only\" = {read_only_allowed}\n\
\":workspace\" = true\n"
@@ -84,7 +111,7 @@ async fn managed_workspace_default_respects_read_only_availability() -> color_ey
.build()
.await?;
let options = TemporaryStructuredThreadOptions {
thread_source: ThreadSource::Feature("thread_title".to_string()),
kind,
model: "gpt-5.2".to_string(),
model_provider: config.model_provider_id.clone(),
cwd: config.cwd.to_string_lossy().into_owned(),
@@ -118,7 +145,9 @@ async fn managed_workspace_default_respects_read_only_availability() -> color_ey
continue;
};
match *notification {
ServerNotification::ConfigWarning(warning) => {
ServerNotification::ConfigWarning(warning)
if kind == TemporaryThreadKind::Recap =>
{
assert!(
!warning.summary.contains("`approval_policy`"),
"{warning:?}"
@@ -142,7 +171,7 @@ async fn managed_workspace_default_respects_read_only_availability() -> color_ey
),
(
Some(":read-only".to_string()),
AskForApproval::OnRequest,
expected_approval,
SandboxPolicy::ReadOnly {
network_access: false,
},
@@ -187,7 +216,7 @@ async fn preserves_custom_permissions_and_disables_required_mcp_servers() -> col
let response = start_temporary_thread(
&app_server.request_handle(),
TemporaryStructuredThreadOptions {
thread_source: ThreadSource::Feature("thread_title".to_string()),
kind: TemporaryThreadKind::Recap,
model: "gpt-5.2".to_string(),
model_provider: config.model_provider_id.clone(),
cwd: config.cwd.display().to_string(),
@@ -207,7 +236,7 @@ async fn preserves_custom_permissions_and_disables_required_mcp_servers() -> col
Some("title-restricted".to_string()),
config.model_provider_id,
true,
Some(ThreadSource::Feature("thread_title".to_string())),
Some(ThreadSource::Feature("system".to_string())),
)
);
+2
View File
@@ -13,6 +13,8 @@ mod resize_reflow;
#[cfg(unix)]
mod screen_reader;
mod status_indicator;
#[cfg(unix)]
mod thread_title;
mod vt100_history;
mod vt100_live_commit;
#[cfg(unix)]
+91
View File
@@ -0,0 +1,91 @@
//! Exercises automatic title generation alongside a foreground skill installation prompt.
use super::focus_palette::PtyCodex;
use super::focus_palette::write_test_config;
use anyhow::Result;
use core_test_support::responses;
use std::io::Write;
use std::time::Duration;
use std::time::Instant;
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn automatic_title_after_continue_anyway() -> Result<()> {
core_test_support::skip_if_no_network!(Ok(()));
let workspace = tempfile::tempdir()?;
let cwd = workspace.path().canonicalize()?;
let home = tempfile::tempdir()?;
write_test_config(home.path(), &cwd)?;
let skill = home.path().join("skills/ping");
std::fs::create_dir_all(skill.join("agents"))?;
std::fs::write(
skill.join("SKILL.md"),
"---\nname: ping\ndescription: Ping a service.\n---\nCheck the service.\n",
)?;
std::fs::write(
skill.join("agents/openai.yaml"),
"dependencies:
tools:
- type: mcp
value: ping
transport: streamable_http
url: http://127.0.0.1:1/mcp
",
)?;
let server = responses::start_mock_server().await;
responses::mount_response_handler(&server, |request| {
let (id, message) = if request.body_json()["text"]["format"]["type"] == "json_schema" {
("title", r#"{"title":"Check service health"}"#)
} else {
("foreground", "Foreground turn completed")
};
responses::sse_response(responses::sse(vec![
responses::ev_assistant_message(id, message),
responses::ev_completed(id),
]))
})
.await;
let mut config = std::fs::OpenOptions::new()
.append(true)
.open(home.path().join("config.toml"))?;
writeln!(
config,
"[model_providers.test]
name = 'Mock'
base_url = '{}/v1'
wire_api = 'responses'
[tui]
status_line = ['thread-title']",
server.uri(),
)?;
let mut terminal = PtyCodex::start(
&cwd,
home,
&[
"--no-daemon",
"-c",
"model_provider='test'",
"-c",
"approval_policy='on-request'",
"$ping the service",
],
)?;
terminal.wait_for_screen("Continue anyway")?;
// Startup can drain pending input after it first draws the installation prompt.
let deadline = Instant::now() + Duration::from_secs(/*secs*/ 30);
while terminal.screen_contains("1 unanswered") {
anyhow::ensure!(Instant::now() < deadline, "installation prompt stayed open");
terminal.write_input(b"2")?;
terminal.read_output(Duration::from_millis(/*millis*/ 50))?;
}
terminal.wait_for_screen("answer: Continue anyway")?;
terminal.wait_for_screen("Foreground turn completed")?;
terminal.wait_for_screen("Check service health")?;
assert!(
!terminal.screen_contains("temporary structured threads cannot request"),
"{}",
terminal.screen_contents()
);
Ok(())
}