Lightweight coding agent that runs in your terminal
Rust
Generate descriptive TUI thread titles (#40492)
Felipe Couryb3c7e1a47f01
diff --git a/codex-rs/tui/src/app.rs b/codex-rs/tui/src/app.rsindex 71213e3355..b6457a8d6e 100644--- a/codex-rs/tui/src/app.rs+++ b/codex-rs/tui/src/app.rs@@ -240,6 +240,7 @@ mod thread_goal_actions;mod thread_routing;mod thread_session_state;mod thread_settings;+mod thread_title;mod transcript_export;mod working_directory;@@ -595,6 +596,7 @@ pub(crate) struct App {windows_sandbox: WindowsSandboxState,thread_event_channels: HashMap<ThreadId, ThreadEventChannel>,+ temporary_structured_requests: HashMap<ThreadId, mpsc::UnboundedSender<ServerNotification>>,thread_event_listener_tasks: HashMap<ThreadId, JoinHandle<()>>,agent_navigation: AgentNavigationState,agents_overview: agents_overview::AgentsOverviewState,diff --git a/codex-rs/tui/src/app/app_server_events.rs b/codex-rs/tui/src/app/app_server_events.rsindex b4288f6b76..71bba070ea 100644--- a/codex-rs/tui/src/app/app_server_events.rs+++ b/codex-rs/tui/src/app/app_server_events.rs@@ -92,6 +92,22 @@ impl App {let _ = self.dynamic_tool_status_updates.send(status.clone());}+ // Hidden helper threads must not enter visible thread routing or overview refreshes.+ if let ServerNotificationThreadTarget::Thread(thread_id) =+ server_notification_thread_target(¬ification)+ && let Some(sender) = self.temporary_structured_requests.get(&thread_id)+ {+ if matches!(+ ¬ification,+ ServerNotification::ItemCompleted(_) | ServerNotification::TurnCompleted(_)+ ) && sender.send(notification).is_err()+ {+ self.temporary_structured_requests.remove(&thread_id);+ }++ return;+ }+if let ServerNotification::ThreadStarted(started) = ¬ification&& let SessionSource::SubAgent(SubAgentSource::ThreadSpawn {parent_thread_id, ..diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rsindex 9029728e6c..b2df60de4c 100644--- a/codex-rs/tui/src/app/event_dispatch.rs+++ b/codex-rs/tui/src/app/event_dispatch.rs@@ -6,6 +6,7 @@use super::resize_reflow::trailing_run_start;use super::session_lifecycle::ThreadAttachPresentation;use super::*;+use crate::app_event::ThreadTitleDestination;use crate::app_server_session::ForkGoalContinuation;use crate::app_server_session::UnsupportedLegacyPermissionProfile;use crate::app_server_session::turn_permissions_overrides;@@ -2459,13 +2460,59 @@ impl App {.await;}AppEvent::RenameAgentsOverviewThread { thread_id, name } => {- if let Err(error) = app_server.thread_set_name(thread_id, name.clone()).await {- if let Ok(mut state) = self.agents_overview.view_state.lock() {- state.input = name;- state.renaming = true;+ match app_server.thread_set_name(thread_id, name.clone()).await {+ Ok(()) => self.chat_widget.expect_manual_thread_name(thread_id, name),+ Err(error) => {+ if let Ok(mut state) = self.agents_overview.view_state.lock() {+ state.input = name;+ state.renaming = true;+ }+ self.chat_widget+ .add_error_message(format!("Failed to rename task: {error}"));+ }+ }+ }+ AppEvent::ThreadTitleStarted {+ thread_id,+ destination,+ prompt,+ effort,+ result,+ } => {+ self.on_thread_title_started(+ app_server,+ thread_id,+ destination,+ prompt,+ effort,+ result,+ );+ }+ AppEvent::GeneratedThreadTitle {+ thread_id,+ temporary_thread_id,+ destination,+ result,+ } => {+ self.temporary_structured_requests+ .remove(&temporary_thread_id);++ match destination {+ ThreadTitleDestination::Automatic { expected_title } => {+ if let Ok(response) = result+ && let Some(title) = super::thread_title::parse_thread_title(&response)+ && self.chat_widget.thread_id() == Some(thread_id)+ && self.chat_widget.thread_name().as_deref()+ == Some(expected_title.as_str())+ {+ match app_server.thread_set_name(thread_id, title.clone()).await {+ Ok(()) => self.chat_widget.expect_automatic_thread_name(title),+ Err(error) => {+ tracing::debug!(%error, "failed to apply generated thread title");+ }+ }+ }}- self.chat_widget- .add_error_message(format!("Failed to rename task: {error}"));}}AppEvent::StopAgentsOverviewThread { thread_id } => {diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rsindex 5f5b0b4de4..959ebca611 100644--- a/codex-rs/tui/src/app/startup.rs+++ b/codex-rs/tui/src/app/startup.rs@@ -507,6 +507,7 @@ See the Codex keymap documentation for supported actions and examples."pending_shutdown_exit_thread_id: None,windows_sandbox: WindowsSandboxState::default(),thread_event_channels: HashMap::new(),+ temporary_structured_requests: HashMap::new(),thread_event_listener_tasks: HashMap::new(),agent_navigation: AgentNavigationState::default(),agents_overview: Default::default(),diff --git a/codex-rs/tui/src/app/test_support.rs b/codex-rs/tui/src/app/test_support.rsindex f39be93aba..5a42a6f01e 100644--- a/codex-rs/tui/src/app/test_support.rs+++ b/codex-rs/tui/src/app/test_support.rs@@ -60,6 +60,7 @@ pub(super) async fn make_test_app() -> App {pending_shutdown_exit_thread_id: None,windows_sandbox: WindowsSandboxState::default(),thread_event_channels: HashMap::new(),+ temporary_structured_requests: HashMap::new(),thread_event_listener_tasks: HashMap::new(),agent_navigation: AgentNavigationState::default(),agents_overview: Default::default(),diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex 9ef96b70a6..ca60a1380f 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -5447,6 +5447,7 @@ async fn make_test_app() -> App {pending_shutdown_exit_thread_id: None,windows_sandbox: WindowsSandboxState::default(),thread_event_channels: HashMap::new(),+ temporary_structured_requests: HashMap::new(),thread_event_listener_tasks: HashMap::new(),agent_navigation: AgentNavigationState::default(),agents_overview: Default::default(),@@ -5526,6 +5527,7 @@ async fn make_test_app_with_channels() -> (pending_shutdown_exit_thread_id: None,windows_sandbox: WindowsSandboxState::default(),thread_event_channels: HashMap::new(),+ temporary_structured_requests: HashMap::new(),thread_event_listener_tasks: HashMap::new(),agent_navigation: AgentNavigationState::default(),agents_overview: Default::default(),diff --git a/codex-rs/tui/src/app/tests/safety_buffering.rs b/codex-rs/tui/src/app/tests/safety_buffering.rsindex 887d0bcd5f..3d5950b10e 100644--- a/codex-rs/tui/src/app/tests/safety_buffering.rs+++ b/codex-rs/tui/src/app/tests/safety_buffering.rs@@ -31,6 +31,7 @@ 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 {@@ -420,8 +421,13 @@ goals = truelet 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 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,diff --git a/codex-rs/tui/src/app/thread_routing.rs b/codex-rs/tui/src/app/thread_routing.rsindex 861fbc1396..ed7c5c3553 100644--- a/codex-rs/tui/src/app/thread_routing.rs+++ b/codex-rs/tui/src/app/thread_routing.rs@@ -6,6 +6,7 @@use super::session_lifecycle::ThreadAttachPresentation;use super::*;+use crate::app_event::ThreadTitleDestination;use crate::chatwidget::ThreadInputStateRestoreMode;use crate::session_resume::read_session_model;use codex_app_server_protocol::ThreadStartedNotification;@@ -781,9 +782,9 @@ impl App {Ok(true)}AppCommand::SetThreadName { name } => {- app_server- .thread_set_name(thread_id, name.to_string())- .await?;+ 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);Ok(true)}AppCommand::Review { target } => {@@ -1796,9 +1797,61 @@ impl App {// thread, so unrelated shutdowns cannot consume this marker.self.pending_shutdown_exit_thread_id = None;}+ let automatic_title_user_message = if self.chat_widget.thread_name().is_none()+ && let ThreadBufferedEvent::Notification(notification) = &event+ && let ServerNotification::ItemCompleted(notification) = notification.as_ref()+ && let ThreadItem::UserMessage { content, .. } = ¬ification.item+ {+ Some(+ content+ .iter()+ .filter_map(|item| match item {+ codex_app_server_protocol::UserInput::Text { text, .. } => {+ Some(crate::ide_context::extract_prompt_request_with_offset(text).0)+ }+ _ => None,+ })+ .collect::<Vec<_>>()+ .join(" "),+ )+ } else {+ None+ };let had_active_view = self.chat_widget.has_active_view();self.handle_thread_event_now_recovering_file_changes(event).await;+ if let Some(user_message) = automatic_title_user_message {+ let expected_title = user_message+ .split_whitespace()+ .collect::<Vec<_>>()+ .join(" ")+ .chars()+ .take(super::thread_title::THREAD_TITLE_MAX_CHARS)+ .collect::<String>();++ if !expected_title.is_empty()+ && let Some(thread_id) = self.active_thread_id+ {+ match app_server+ .thread_set_name(thread_id, expected_title.clone())+ .await+ {+ Ok(()) => {+ self.chat_widget+ .expect_automatic_thread_name(expected_title.clone());+ self.generate_thread_title(+ app_server,+ thread_id,+ ThreadTitleDestination::Automatic { expected_title },+ super::thread_title::thread_title_prompt(&user_message),+ );+ }+ Err(error) => {+ tracing::debug!(%error, "failed to set provisional thread title");+ }+ }+ }+ }if !had_active_view&& self.chat_widget.has_active_view()&& self.startup_protected_input_boundarydiff --git a/codex-rs/tui/src/app/thread_title.rs b/codex-rs/tui/src/app/thread_title.rsnew file mode 100644index 0000000000..57da92d087--- /dev/null+++ b/codex-rs/tui/src/app/thread_title.rs@@ -0,0 +1,201 @@+//! Structured-output schema and normalization for generated TUI thread titles.++use super::App;+use crate::app_event::AppEvent;+use crate::app_event::ThreadTitleDestination;+use crate::app_server_session::AppServerSession;+use crate::temporary_structured_request::TemporaryStructuredThreadOptions;+use crate::temporary_structured_request::run_temporary_structured_turn;+use crate::temporary_structured_request::start_temporary_thread;+use codex_protocol::ThreadId;+use codex_protocol::openai_models::ReasoningEffort;+use serde::Deserialize;+use serde_json::Value;+use serde_json::json;+use tokio::sync::mpsc;++pub(super) const THREAD_TITLE_MAX_CHARS: usize = 36;+const THREAD_TITLE_MODEL: &str = "gpt-5.6-luna";+pub(super) const THREAD_TITLE_PROMPT_MAX_BYTES: usize = 960;++#[derive(Deserialize)]+#[serde(deny_unknown_fields)]+struct GeneratedThreadTitle {+ title: String,+}++impl App {+ /// Start a hidden title-generation thread without blocking the UI loop.+ pub(super) fn generate_thread_title(+ &mut self,+ app_server: &AppServerSession,+ thread_id: ThreadId,+ destination: ThreadTitleDestination,+ prompt: String,+ ) {+ 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()+ && self+ .chat_widget+ .model_catalog()+ .try_list_models()+ .is_ok_and(|models| models.iter().any(|model| model.model == THREAD_TITLE_MODEL))+ {+ THREAD_TITLE_MODEL.to_string()+ } else {+ self.chat_widget.current_model().to_string()+ };+ let effort = (model == THREAD_TITLE_MODEL).then_some(ReasoningEffort::Low);+ let config = self.chat_widget.config_ref();+ let options = TemporaryStructuredThreadOptions {+ model,+ model_provider: config.model_provider_id.clone(),+ cwd: config.cwd.display().to_string(),+ active_permission_profile: config+ .permissions+ .active_permission_profile()+ .map(|profile| profile.id),+ mcp_server_names: config.mcp_servers.get().keys().cloned().collect(),+ };++ let event_sender = self.app_event_tx.clone();+ tokio::spawn(async move {+ let result = start_temporary_thread(&request_handle, options)+ .await+ .map(|thread| thread.thread.id)+ .map_err(|error| error.to_string());++ event_sender.send(AppEvent::ThreadTitleStarted {+ thread_id,+ destination,+ prompt,+ effort,+ result,+ });+ });+ }++ /// Register a started hidden thread and generate its structured title.+ pub(super) fn on_thread_title_started(+ &mut self,+ app_server: &AppServerSession,+ thread_id: ThreadId,+ destination: ThreadTitleDestination,+ prompt: String,+ effort: Option<ReasoningEffort>,+ result: Result<String, String>,+ ) {+ let temporary_thread_id_text = match result {+ Ok(thread_id) => thread_id,+ Err(error) => {+ tracing::debug!(%error, "failed to start title-generation thread");+ return;+ }+ };++ let Ok(temporary_thread_id) = ThreadId::from_string(&temporary_thread_id_text) else {+ return;+ };++ let (sender, receiver) = mpsc::unbounded_channel();+ self.temporary_structured_requests+ .insert(temporary_thread_id, sender);++ 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,+ receiver,+ )+ .await+ .map_err(|error| error.to_string());++ event_sender.send(AppEvent::GeneratedThreadTitle {+ thread_id,+ temporary_thread_id,+ destination,+ result,+ });+ });+ }+}++/// Constrain generated metadata to one nonempty title within the display limit.+pub(super) fn thread_title_output_schema() -> Value {+ json!({+ "type": "object",+ "properties": {+ "title": {+ "type": "string",+ "minLength": 1,+ "maxLength": THREAD_TITLE_MAX_CHARS,+ },+ },+ "required": ["title"],+ "additionalProperties": false,+ })+}++fn thread_title_instructions() -> String {+ format!(+ "Generate a concise, single-line task title of at most \+ {THREAD_TITLE_MAX_CHARS} characters and under five words where possible. \+ Start with an imperative verb. Capitalize only the first word unless the \+ user's language, proper nouns, acronyms, or code terms require otherwise. \+ Preserve ticket references exactly. Write in the user's language. \+ Do not use quotes, markdown, or trailing punctuation. \+ Do not answer the request."+ )+}++/// 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();+ let prefix = format!("{instructions}\n\nUser prompt:\n");+ let remaining_bytes = THREAD_TITLE_PROMPT_MAX_BYTES.saturating_sub(prefix.len());+ let user_message = user_message+ .trim()+ .char_indices()+ .take_while(|(index, character)| index + character.len_utf8() <= remaining_bytes)+ .map(|(_, character)| character)+ .collect::<String>();++ format!("{prefix}{user_message}")+}++/// Normalize a generated title and truncate it without splitting Unicode characters.+pub(super) fn parse_thread_title(response: &str) -> Option<String> {+ if !response.trim_start().starts_with('{') {+ return None;+ }++ let title = serde_json::from_str::<GeneratedThreadTitle>(response)+ .ok()?+ .title;++ let normalized = title+ .trim()+ .trim_matches(|character| matches!(character, '"' | '\'' | '`' | '“' | '”' | '‘' | '’'))+ .split_whitespace()+ .collect::<Vec<_>>()+ .join(" ")+ .trim_end_matches(['.', '?', '!'])+ .trim_end()+ .to_string();++ if normalized.is_empty() {+ return None;+ }++ Some(normalized.chars().take(THREAD_TITLE_MAX_CHARS).collect())+}++#[cfg(test)]+#[path = "thread_title_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/app/thread_title_tests.rs b/codex-rs/tui/src/app/thread_title_tests.rsnew file mode 100644index 0000000000..fdcaa27e21--- /dev/null+++ b/codex-rs/tui/src/app/thread_title_tests.rs@@ -0,0 +1,129 @@+use super::THREAD_TITLE_MAX_CHARS;+use super::THREAD_TITLE_PROMPT_MAX_BYTES;+use super::parse_thread_title;+use super::thread_title_prompt;+use crate::app::test_support::make_test_app;+use crate::app_command::AppCommand;+use pretty_assertions::assert_eq;++const EXPECTED_THREAD_TITLE_INSTRUCTIONS: &str = concat!(+ "Generate a concise, single-line task title of at most 36 characters ",+ "and under five words where possible. Start with an imperative verb. ",+ "Capitalize only the first word unless the user's language, proper nouns, ",+ "acronyms, or code terms require otherwise. Preserve ticket references ",+ "exactly. Write in the user's language. Do not use quotes, markdown, ",+ "or trailing punctuation. Do not answer the request."+);++#[test]+fn trims_user_message_in_title_prompt() {+ let prompt = thread_title_prompt(" Fix the login form \n");++ assert_eq!(+ prompt,+ format!("{EXPECTED_THREAD_TITLE_INSTRUCTIONS}\n\nUser prompt:\nFix the login form")+ );+}++#[test]+fn truncates_title_prompt_without_splitting_unicode() {+ let user_message = "🚀".repeat(THREAD_TITLE_PROMPT_MAX_BYTES);+ let prompt = thread_title_prompt(&user_message);+ let expected_instructions = format!("{EXPECTED_THREAD_TITLE_INSTRUCTIONS}\n\n");+ let prefix = format!("{expected_instructions}User prompt:\n");+ let available_bytes = THREAD_TITLE_PROMPT_MAX_BYTES - prefix.len();+ let expected = "🚀".repeat(available_bytes / '🚀'.len_utf8());++ assert_eq!(+ prompt.rsplit_once("User prompt:\n"),+ Some((expected_instructions.as_str(), expected.as_str()))+ );+ assert!(prompt.len() <= THREAD_TITLE_PROMPT_MAX_BYTES);+}++#[test]+fn bounds_the_entire_title_prompt_for_dense_unicode() {+ let repeated_characters = THREAD_TITLE_PROMPT_MAX_BYTES * 3;+ for message in [+ "🚀".repeat(repeated_characters),+ "漢".repeat(repeated_characters),+ "x".repeat(repeated_characters),+ ] {+ let prompt = thread_title_prompt(&message);++ assert!(+ prompt.len() <= THREAD_TITLE_PROMPT_MAX_BYTES,+ "{} bytes for {:?}",+ prompt.len(),+ message.chars().next()+ );+ }+}++#[tokio::test]+async fn manual_rename_invalidates_pending_automatic_title_before_notification()+-> color_eyre::Result<()> {+ let mut app = make_test_app().await;+ let mut app_server = 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.enqueue_primary_thread_session(started.session, started.turns)+ .await?;+ app_server+ .thread_set_name(thread_id, "Provisional title".to_string())+ .await?;+ app.chat_widget+ .expect_automatic_thread_name("Provisional title".to_string());++ app.submit_thread_op(+ &mut app_server,+ thread_id,+ AppCommand::set_thread_name("Manual title".to_string()),+ )+ .await?;++ assert_eq!(+ app.chat_widget.thread_name(),+ Some("Manual title".to_string())+ );++ app_server.shutdown().await?;+ Ok(())+}++#[test]+fn normalizes_generated_title_whitespace() {+ assert_eq!(+ parse_thread_title(r#"{"title":" Fix \n\t login errors "}"#),+ Some("Fix login errors".to_string())+ );+}++#[test]+fn rejects_invalid_or_empty_generated_titles() {+ for response in [+ "",+ "not json",+ "null",+ "true",+ "42",+ "[]",+ r#"["title"]"#,+ r#""plain title""#,+ "{}",+ r#"{"title":7}"#,+ r#"{"title":"valid","extra":true}"#,+ r#"{"title":""}"#,+ r#"{"title":" \t "}"#,+ ] {+ assert_eq!(parse_thread_title(response), None, "response: {response}");+ }+}++#[test]+fn truncates_generated_titles_without_splitting_unicode() {+ let expected = "🚀".repeat(THREAD_TITLE_MAX_CHARS);+ let response = serde_json::json!({ "title": format!("{expected}x") }).to_string();++ assert_eq!(parse_thread_title(&response), Some(expected));+}diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rsindex d8daf96451..a01a011918 100644--- a/codex-rs/tui/src/app_event.rs+++ b/codex-rs/tui/src/app_event.rs@@ -40,6 +40,7 @@ use codex_file_search::FileMatch;use codex_message_history::HistoryBatchCursor;use codex_protocol::ThreadId;use codex_protocol::openai_models::ModelPreset;+use codex_protocol::openai_models::ReasoningEffort;use codex_utils_absolute_path::AbsolutePathBuf;use codex_utils_approval_presets::ApprovalPreset;use strum_macros::IntoStaticStr;@@ -61,7 +62,6 @@ use codex_plugin::PluginCapabilitySummary;use codex_protocol::config_types::CollaborationModeMask;use codex_protocol::config_types::Personality;use codex_protocol::models::ActivePermissionProfile;-use codex_protocol::openai_models::ReasoningEffort;use crate::history_cell::HistoryCell;@@ -195,6 +195,13 @@ pub(crate) enum TranscriptExportDestination {File(PathBuf),}+/// Deliver a generated title to its originating automatic rename.+#[derive(Debug)]+pub(crate) enum ThreadTitleDestination {+ /// Replace the provisional name only if the user has not renamed the thread.+ Automatic { expected_title: String },+}+#[allow(clippy::large_enum_variant)]#[derive(Debug, IntoStaticStr)]pub(crate) enum AppEvent {@@ -219,6 +226,21 @@ pub(crate) enum AppEvent {thread_id: ThreadId,name: String,},+ /// Register a hidden title-generation thread started in the background.+ ThreadTitleStarted {+ thread_id: ThreadId,+ destination: ThreadTitleDestination,+ prompt: String,+ effort: Option<ReasoningEffort>,+ result: Result<String, String>,+ },+ /// Route a hidden title request to its automatic rename or editable prompt.+ GeneratedThreadTitle {+ thread_id: ThreadId,+ temporary_thread_id: ThreadId,+ destination: ThreadTitleDestination,+ result: Result<String, String>,+ },/// Interrupt a task directly from the shared dashboard.StopAgentsOverviewThread {thread_id: ThreadId,diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rsindex 541604a5fd..15c9b321ec 100644--- a/codex-rs/tui/src/chatwidget.rs+++ b/codex-rs/tui/src/chatwidget.rs@@ -667,6 +667,7 @@ pub(crate) struct ChatWidget {pet_image_support_override: Option<crate::pets::PetImageSupport>,thread_id: Option<ThreadId>,thread_name: Option<String>,+ pending_automatic_thread_names: HashSet<String>,thread_rename_block_message: Option<String>,active_side_conversation: bool,blocks_direct_input: bool,diff --git a/codex-rs/tui/src/chatwidget/constructor.rs b/codex-rs/tui/src/chatwidget/constructor.rsindex cb4f301b5d..0fde03a218 100644--- a/codex-rs/tui/src/chatwidget/constructor.rs+++ b/codex-rs/tui/src/chatwidget/constructor.rs@@ -199,6 +199,7 @@ impl ChatWidget {pet_image_support_override: None,thread_id: None,thread_name: None,+ pending_automatic_thread_names: HashSet::new(),thread_rename_block_message: None,active_side_conversation: false,blocks_direct_input: false,diff --git a/codex-rs/tui/src/chatwidget/session_flow.rs b/codex-rs/tui/src/chatwidget/session_flow.rsindex cbb91fef86..e4e910523b 100644--- a/codex-rs/tui/src/chatwidget/session_flow.rs+++ b/codex-rs/tui/src/chatwidget/session_flow.rs@@ -25,6 +25,7 @@ impl ChatWidget {self.bottom_pane.set_queue_submissions(/*queue_submissions*/ false);if previous_thread_id != self.thread_id {+ self.pending_automatic_thread_names.clear();self.review.recent_auto_review_denials = RecentAutoReviewDenials::default();self.clear_thread_usage_state();}@@ -245,16 +246,38 @@ impl ChatWidget {)));}+ /// Apply a persisted automatic name immediately and suppress its confirmation.+ pub(crate) fn expect_automatic_thread_name(&mut self, name: String) {+ self.thread_name = Some(name.clone());+ self.pending_automatic_thread_names.insert(name);+ }++ /// Make a confirmed manual rename visible before its queued server notification arrives.+ pub(crate) fn expect_manual_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();+ self.request_redraw();+ }+ }+pub(super) fn on_thread_name_updated(&mut self,thread_id: ThreadId,thread_name: Option<String>,) {if self.thread_id == Some(thread_id) {- if let Some(name) = thread_name.as_deref() {+ let automatic = thread_name+ .as_ref()+ .is_some_and(|name| self.pending_automatic_thread_names.remove(name));++ if let Some(name) = thread_name.as_deref()+ && !automatic+ {let cell = Self::rename_confirmation_cell(name, self.thread_id);self.add_boxed_history(Box::new(cell));}+self.thread_name = thread_name;self.refresh_status_surfaces();self.request_redraw();diff --git a/codex-rs/tui/src/chatwidget/tests/app_server.rs b/codex-rs/tui/src/chatwidget/tests/app_server.rsindex 70df67db08..b749244d02 100644--- a/codex-rs/tui/src/chatwidget/tests/app_server.rs+++ b/codex-rs/tui/src/chatwidget/tests/app_server.rs@@ -1558,6 +1558,69 @@ async fn live_app_server_thread_name_update_shows_resume_hint() {assert_chatwidget_snapshot!("thread_name_update_resume_hint", rendered);}+#[tokio::test]+async fn live_app_server_automatic_thread_name_update_is_silent() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ for title in ["Provisional title", "Generated title"] {+ chat.expect_automatic_thread_name(title.to_string());+ assert_eq!(chat.thread_name(), Some(title.to_string()));++ chat.handle_server_notification(+ ServerNotification::ThreadNameUpdated(+ codex_app_server_protocol::ThreadNameUpdatedNotification {+ thread_id: thread_id.to_string(),+ thread_name: Some(title.to_string()),+ },+ ),+ /*replay_kind*/ None,+ );++ assert_eq!(chat.thread_name, Some(title.to_string()));+ assert!(drain_insert_history(&mut rx).is_empty());+ }++ chat.handle_server_notification(+ ServerNotification::ThreadNameUpdated(+ codex_app_server_protocol::ThreadNameUpdatedNotification {+ thread_id: thread_id.to_string(),+ thread_name: Some("Manual title".to_string()),+ },+ ),+ /*replay_kind*/ None,+ );++ assert_eq!(chat.thread_name, Some("Manual title".to_string()));+ assert_eq!(drain_insert_history(&mut rx).len(), 1);+}++#[tokio::test]+async fn live_app_server_manual_thread_name_is_visible_before_notification() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;+ let thread_id = ThreadId::new();+ chat.thread_id = Some(thread_id);+ chat.expect_automatic_thread_name("Provisional title".to_string());++ chat.expect_manual_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());++ chat.handle_server_notification(+ ServerNotification::ThreadNameUpdated(+ codex_app_server_protocol::ThreadNameUpdatedNotification {+ thread_id: thread_id.to_string(),+ thread_name: Some("Manual title".to_string()),+ },+ ),+ /*replay_kind*/ None,+ );++ assert_eq!(chat.thread_name(), Some("Manual title".to_string()));+ assert_eq!(drain_insert_history(&mut rx).len(), 1);+}+#[tokio::test]async fn live_app_server_thread_closed_requests_immediate_exit() {let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await;diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rsindex c06e21f6c1..2c0a96bf02 100644--- a/codex-rs/tui/src/lib.rs+++ b/codex-rs/tui/src/lib.rs@@ -186,6 +186,7 @@ mod status_indicator_widget;mod streaming;mod style;mod task_mentions;+mod temporary_structured_request;mod terminal_hyperlinks;mod terminal_palette;mod terminal_probe;diff --git a/codex-rs/tui/src/temporary_structured_request.rs b/codex-rs/tui/src/temporary_structured_request.rsnew file mode 100644index 0000000000..047292dc97--- /dev/null+++ b/codex-rs/tui/src/temporary_structured_request.rs@@ -0,0 +1,252 @@+//! 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;+use codex_app_server_protocol::SandboxPolicy;+use codex_app_server_protocol::ServerNotification;+use codex_app_server_protocol::ThreadItem;+use codex_app_server_protocol::ThreadSource;+use codex_app_server_protocol::ThreadStartParams;+use codex_app_server_protocol::ThreadStartResponse;+use codex_app_server_protocol::ThreadUnsubscribeParams;+use codex_app_server_protocol::ThreadUnsubscribeResponse;+use codex_app_server_protocol::TurnStartParams;+use codex_app_server_protocol::TurnStartResponse;+use codex_app_server_protocol::TurnStatus;+use codex_app_server_protocol::UserInput;+use codex_protocol::openai_models::ReasoningEffort;+use color_eyre::eyre::eyre;+use serde_json::Value;+use std::time::Duration;+use tokio::sync::mpsc::UnboundedReceiver;+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.+pub(crate) struct TemporaryStructuredThreadOptions {+ pub(crate) model: String,+ pub(crate) model_provider: String,+ pub(crate) cwd: String,+ pub(crate) active_permission_profile: Option<String>,+ pub(crate) mcp_server_names: Vec<String>,+}++/// Start an ephemeral, non-interactive thread without widening its parent's permissions.+pub(crate) async fn start_temporary_thread(+ request_handle: &AppServerRequestHandle,+ options: TemporaryStructuredThreadOptions,+) -> color_eyre::Result<ThreadStartResponse> {+ let TemporaryStructuredThreadOptions {+ model,+ model_provider,+ cwd,+ active_permission_profile,+ mcp_server_names,+ } = options;+ let custom_permission_profile =+ active_permission_profile.filter(|profile| !profile.starts_with(':'));+ let mut config = std::collections::HashMap::from([+ ("features.apps".to_string(), false.into()),+ ("features.code_mode".to_string(), false.into()),+ ("features.code_mode_only".to_string(), false.into()),+ ("features.current_time_reminder".to_string(), false.into()),+ ("features.deferred_executor".to_string(), false.into()),+ ("features.enable_fanout".to_string(), false.into()),+ ("features.goals".to_string(), false.into()),+ ("features.hooks".to_string(), false.into()),+ ("features.image_generation".to_string(), false.into()),+ ("features.memories".to_string(), false.into()),+ ("features.multi_agent".to_string(), false.into()),+ ("features.multi_agent_v2".to_string(), false.into()),+ ("features.plugins".to_string(), false.into()),+ (+ "features.request_permissions_tool".to_string(),+ false.into(),+ ),+ ("features.shell_snapshot".to_string(), false.into()),+ ("features.shell_tool".to_string(), false.into()),+ ("features.standalone_web_search".to_string(), false.into()),+ ("features.tool_suggest".to_string(), false.into()),+ ("features.unified_exec".to_string(), false.into()),+ ("features.view_image".to_string(), false.into()),+ (+ "tools.experimental_request_user_input.enabled".to_string(),+ false.into(),+ ),+ ("tools.update_plan.enabled".to_string(), false.into()),+ ("web_search".to_string(), "disabled".into()),+ ]);+ for server_name in mcp_server_names {+ config.insert(format!("mcp_servers.{server_name}.enabled"), false.into());+ }++ let response: ThreadStartResponse = tokio::time::timeout(+ STRUCTURED_TURN_TIMEOUT,+ request_handle.request_typed(ClientRequest::ThreadStart {+ request_id: RequestId::String(format!("temporary-structured-{}", Uuid::new_v4())),+ params: ThreadStartParams {+ model: Some(model),+ model_provider: Some(model_provider),+ cwd: Some(cwd),+ approval_policy: Some(AskForApproval::Never),+ sandbox: custom_permission_profile+ .is_none()+ .then_some(SandboxMode::ReadOnly),+ permissions: custom_permission_profile.clone(),+ runtime_workspace_roots: Some(Vec::new()),+ ephemeral: Some(true),+ thread_source: Some(ThreadSource::Feature("system".to_string())),+ environments: Some(Vec::new()),+ dynamic_tools: Some(Vec::new()),+ selected_capability_roots: Some(Vec::new()),+ config: Some(config),+ ..ThreadStartParams::default()+ },+ }),+ )+ .await+ .map_err(|_| eyre!("temporary structured thread start timed out"))??;++ if let Some(expected_profile) = custom_permission_profile {+ if response+ .active_permission_profile+ .as_ref()+ .is_none_or(|profile| profile.id != expected_profile)+ {+ return Err(eyre!(+ "temporary structured thread did not preserve permission profile {expected_profile}"+ ));+ }+ } else if !matches!(response.sandbox, SandboxPolicy::ReadOnly { .. }) {+ return Err(eyre!(+ "temporary structured thread did not start with read-only permissions"+ ));+ }++ 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+}++/// Return the latest assistant message when the requested turn completes.+pub(crate) async fn collect_structured_response(+ mut notifications: UnboundedReceiver<ServerNotification>,+ turn_id: &str,+) -> color_eyre::Result<String> {+ let mut response = None;++ while let Some(notification) = notifications.recv().await {+ match notification {+ ServerNotification::ItemCompleted(completed) if completed.turn_id == turn_id => {+ if let ThreadItem::AgentMessage { text, .. } = completed.item {+ if text.len() > STRUCTURED_RESPONSE_MAX_BYTES {+ return Err(eyre!(+ "temporary structured response exceeds {STRUCTURED_RESPONSE_MAX_BYTES} bytes"+ ));+ }+ response = Some(text);+ }+ }+ ServerNotification::TurnCompleted(completed) if completed.turn.id == turn_id => {+ if completed.turn.status != TurnStatus::Completed {+ return Err(eyre!(+ "temporary structured turn ended with status {:?}",+ completed.turn.status,+ ));+ }++ return response.ok_or_else(|| {+ eyre!("temporary structured turn completed without a response")+ });+ }+ _ => {}+ }+ }++ Err(eyre!(+ "temporary structured turn notification channel closed"+ ))+}++/// Run a bounded structured turn and make a bounded temporary-thread cleanup attempt.+pub(crate) async fn run_temporary_structured_turn(+ request_handle: AppServerRequestHandle,+ thread_id: String,+ prompt: String,+ output_schema: Value,+ effort: Option<ReasoningEffort>,+ notifications: UnboundedReceiver<ServerNotification>,+) -> color_eyre::Result<String> {+ let result = tokio::time::timeout(STRUCTURED_TURN_TIMEOUT, async {+ let turn = start_structured_turn(+ &request_handle,+ thread_id.clone(),+ prompt,+ output_schema,+ effort,+ )+ .await?;++ collect_structured_response(notifications, &turn.turn.id).await+ })+ .await+ .unwrap_or_else(|_| Err(eyre!("temporary structured turn timed out")));++ match tokio::time::timeout(+ STRUCTURED_TURN_TIMEOUT,+ request_handle.request_typed::<ThreadUnsubscribeResponse>(+ ClientRequest::ThreadUnsubscribe {+ request_id: RequestId::String(format!(+ "temporary-structured-unsubscribe-{}",+ Uuid::new_v4()+ )),+ params: ThreadUnsubscribeParams { thread_id },+ },+ ),+ )+ .await+ {+ Ok(Ok(_)) => {}+ Ok(Err(error)) => {+ tracing::debug!(%error, "failed to unsubscribe from temporary structured thread");+ }+ Err(_) => {+ tracing::debug!("temporary structured thread unsubscribe timed out");+ }+ }++ result+}++#[cfg(test)]+#[path = "temporary_structured_request_tests.rs"]+mod tests;diff --git a/codex-rs/tui/src/temporary_structured_request_tests.rs b/codex-rs/tui/src/temporary_structured_request_tests.rsnew file mode 100644index 0000000000..b1af68a1e0--- /dev/null+++ b/codex-rs/tui/src/temporary_structured_request_tests.rs@@ -0,0 +1,199 @@+use super::STRUCTURED_RESPONSE_MAX_BYTES;+use super::TemporaryStructuredThreadOptions;+use super::collect_structured_response;+use super::start_temporary_thread;+use crate::test_support::PathBufExt;+use codex_app_server_protocol::ItemCompletedNotification;+use codex_app_server_protocol::ServerNotification;+use codex_app_server_protocol::ThreadItem;+use codex_app_server_protocol::Turn;+use codex_app_server_protocol::TurnCompletedNotification;+use codex_app_server_protocol::TurnStatus;+use pretty_assertions::assert_eq;+use tempfile::tempdir;+use tokio::sync::mpsc::unbounded_channel;++fn agent_message_notification(turn_id: &str, text: &str) -> ServerNotification {+ ServerNotification::ItemCompleted(ItemCompletedNotification {+ item: ThreadItem::AgentMessage {+ id: "message-1".to_string(),+ text: text.to_string(),+ phase: None,+ memory_citation: None,+ delivery: None,+ },+ thread_id: "thread-1".to_string(),+ turn_id: turn_id.to_string(),+ completed_at_ms: 0,+ })+}++fn turn_completed_notification(turn_id: &str, status: TurnStatus) -> ServerNotification {+ ServerNotification::TurnCompleted(TurnCompletedNotification {+ thread_id: "thread-1".to_string(),+ turn: Turn {+ id: turn_id.to_string(),+ items: Vec::new(),+ items_view: Default::default(),+ status,+ error: None,+ started_at: None,+ completed_at: None,+ duration_ms: None,+ },+ })+}++#[tokio::test]+async fn preserves_custom_permissions_and_disables_required_mcp_servers() -> color_eyre::Result<()>+{+ let (chat_widget, _, _, _) =+ crate::chatwidget::tests::make_chatwidget_manual_with_sender().await;+ let mut config = chat_widget.config_ref().clone();+ let codex_home = tempdir()?;+ let denied_path = codex_home.path().join("denied");+ let denied_key = toml::Value::String(denied_path.display().to_string());+ std::fs::write(+ codex_home.path().join("config.toml"),+ format!(+ "default_permissions = \"title-restricted\"\n\n\+ [permissions.title-restricted.filesystem]\n\+ \":root\" = \"read\"\n\+ {denied_key} = \"deny\"\n\n\+ [mcp_servers.forbidden]\n\+ command = \"codex-auto-title-missing-mcp\"\n\+ required = true\n"+ ),+ )?;+ config.codex_home = codex_home.path().to_path_buf().abs();+ config.sqlite =+ codex_state::SqliteConfig::new_for_testing(codex_home.path().to_path_buf().abs());++ let app_server = crate::start_embedded_app_server_for_picker(&config).await?;+ let response = start_temporary_thread(+ &app_server.request_handle(),+ TemporaryStructuredThreadOptions {+ model: "gpt-5.2".to_string(),+ model_provider: config.model_provider_id.clone(),+ cwd: config.cwd.display().to_string(),+ active_permission_profile: Some("title-restricted".to_string()),+ mcp_server_names: vec!["forbidden".to_string()],+ },+ )+ .await?;++ assert_eq!(+ (+ response.active_permission_profile.map(|profile| profile.id),+ response.model_provider,+ response.thread.ephemeral,+ ),+ (+ Some("title-restricted".to_string()),+ config.model_provider_id,+ true,+ )+ );++ app_server.shutdown().await?;+ Ok(())+}++#[tokio::test]+async fn returns_latest_matching_assistant_message() {+ let (sender, receiver) = unbounded_channel();+ sender+ .send(agent_message_notification("other-turn", "ignore me"))+ .expect("send unrelated assistant message");+ sender+ .send(turn_completed_notification(+ "other-turn",+ TurnStatus::Completed,+ ))+ .expect("send unrelated completion");+ sender+ .send(agent_message_notification("turn-1", "first"))+ .expect("send first assistant message");+ sender+ .send(agent_message_notification("turn-1", "final"))+ .expect("send final assistant message");+ sender+ .send(turn_completed_notification("turn-1", TurnStatus::Completed))+ .expect("send matching completion");++ let response = collect_structured_response(receiver, "turn-1")+ .await+ .expect("collect structured response");++ assert_eq!(response, "final");+}++#[tokio::test]+async fn rejects_failed_turn() {+ let (sender, receiver) = unbounded_channel();+ sender+ .send(turn_completed_notification("turn-1", TurnStatus::Failed))+ .expect("send failed completion");++ let error = collect_structured_response(receiver, "turn-1")+ .await+ .expect_err("failed turn should not produce a response");++ assert_eq!(+ error.to_string(),+ "temporary structured turn ended with status Failed"+ );+}++#[tokio::test]+async fn rejects_completion_without_assistant_message() {+ let (sender, receiver) = unbounded_channel();+ sender+ .send(turn_completed_notification("turn-1", TurnStatus::Completed))+ .expect("send completion");++ let error = collect_structured_response(receiver, "turn-1")+ .await+ .expect_err("completion without assistant message should fail");++ assert_eq!(+ error.to_string(),+ "temporary structured turn completed without a response"+ );+}++#[tokio::test]+async fn rejects_closed_notification_channel() {+ let (sender, receiver) = unbounded_channel();+ drop(sender);++ let error = collect_structured_response(receiver, "turn-1")+ .await+ .expect_err("closed notification channel should fail");++ assert_eq!(+ error.to_string(),+ "temporary structured turn notification channel closed"+ );+}++#[tokio::test]+async fn rejects_oversized_assistant_message() {+ let (sender, receiver) = unbounded_channel();+ let oversized = "x".repeat(STRUCTURED_RESPONSE_MAX_BYTES + 1);+ sender+ .send(agent_message_notification("turn-1", &oversized))+ .expect("send oversized assistant message");+ sender+ .send(turn_completed_notification("turn-1", TurnStatus::Completed))+ .expect("send matching completion");++ let error = collect_structured_response(receiver, "turn-1")+ .await+ .expect_err("oversized assistant message should be rejected");++ assert_eq!(+ error.to_string(),+ "temporary structured response exceeds 8192 bytes"+ );+}