Files
codex/codex-rs/tui/src/app/thread_title.rs
T
Benjamin Carlsson b016cd1847 Enable automatic titles for Cloud conversations (#61600)
## Why

Cloud conversations previously skipped TUI title generation, leaving them without automatically saved names.

## What changed

- Generate structured titles using the selected Cloud account and its backend routing, without agent tools or a temporary conversation.
- Read and save names outside the conversation command queue without replacing the active attachment. Preserve an existing name if it no longer matches the expected value.
- Fall back to the first-message title when generation is unavailable, and allow up to three seconds for pending saves during shutdown.
- Report a retryable error when a manual rename encounters an automatic save in progress, keeping the UI responsive.

## Testing

Add coverage for selected-account title generation, saved-name reads without attachment, first-message fallback persistence, and manual rename retries after automatic saves.

GitOrigin-RevId: 48030cc0b75e790a2004af018f54e5751665b760
2026-11-15 03:17:50 +00:00

542 lines
20 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! Structured-output schema and normalization for generated TUI thread titles.
//!
//! Automatic titles use the first message until generation completes and as a fallback;
//! a saved side chat may also replace the name it inherited at fork. Manual
//! renames cancel pending requests; canceled events cannot affect newer requests.
use super::App;
use super::thread_events::ThreadBufferedEvent;
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::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_client::AppServerRequestHandle;
use codex_app_server_protocol::ServerNotification;
use codex_app_server_protocol::ThreadItemPayload;
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;
use tokio::sync::mpsc;
use tokio_util::sync::CancellationToken;
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;
const THREAD_TITLE_RECENT_MESSAGES: usize = 8;
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct GeneratedThreadTitle {
title: String,
}
impl App {
pub(super) fn finish_thread_title_generation(
&mut self,
thread_id: ThreadId,
destination: ThreadTitleDestination,
) {
self.pending_thread_titles.remove(&(thread_id, destination));
}
/// A saved manual name supersedes any pending title generation for that thread.
pub(super) fn cancel_thread_title_generation(&mut self, thread_id: ThreadId) {
self.pending_thread_titles.retain(|(id, _), cancellation| {
if *id == thread_id {
cancellation.cancel();
false
} else {
true
}
});
}
/// Generate a title without blocking the UI loop.
pub(super) fn generate_thread_title(
&mut self,
app_server: &mut AppServerSession,
thread_id: ThreadId,
destination: ThreadTitleDestination,
source_text: &str,
expected_name: Option<String>,
) {
let request_handle = app_server.request_handle();
if let AppServerRequestHandle::Cloud(_) = &request_handle
&& let ThreadTitleDestination::RenameSuggestion { request_id } = destination
{
self.chat_widget
.apply_thread_name_suggestion(thread_id, request_id, /*suggestion*/ None);
return;
}
let std::collections::hash_map::Entry::Vacant(entry) =
self.pending_thread_titles.entry((thread_id, destination))
else {
return;
};
let cancellation = entry.insert(CancellationToken::new()).clone();
let (prompt, fallback_title) = match destination {
ThreadTitleDestination::Automatic => {
let fallback = fallback_thread_title(source_text);
if !self.side_threads.contains_key(&thread_id)
&& 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 model = if (matches!(&request_handle, AppServerRequestHandle::Cloud(_))
|| 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 event_sender = self.app_event_tx.clone();
if let AppServerRequestHandle::Cloud(handle) = request_handle {
let writer = app_server.automatic_thread_name_writer(thread_id, expected_name);
let mut shutdown = self.cloud_title_shutdown.subscribe();
tokio::spawn(async move {
let result = tokio::select! {
biased;
_ = cancellation.cancelled() => return,
_ = shutdown.changed() => Err(color_eyre::eyre::eyre!("shutting down")),
result = handle.generate_thread_title(&model, effort, prompt, thread_title_output_schema()) => result,
};
if let Some(title) = result
.as_deref()
.ok()
.and_then(parse_thread_title)
.or(fallback_title)
{
writer.save(title, &cancellation).await;
}
event_sender.send(AppEvent::GeneratedThreadTitle {
cancellation,
thread_id,
temporary_thread_id: None,
destination,
result: result.map_err(|error| error.to_string()),
});
});
return;
}
let config = self.chat_widget.config_ref();
let options = TemporaryStructuredThreadOptions {
kind: TemporaryThreadKind::Title,
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),
};
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 {
cancellation,
thread_id,
destination,
prompt,
expected_name,
fallback_title,
effort,
result,
});
});
}
/// Register a started hidden thread and generate its structured title.
#[allow(clippy::too_many_arguments)]
pub(super) fn on_thread_title_started(
&mut self,
app_server: &mut AppServerSession,
thread_id: ThreadId,
destination: ThreadTitleDestination,
prompt: String,
expected_name: Option<String>,
fallback_title: Option<String>,
effort: Option<ReasoningEffort>,
result: Result<String, String>,
cancellation: CancellationToken,
) {
if cancellation.is_cancelled() {
if let Ok(temporary_thread_id) = result {
let request_handle = app_server.request_handle();
tokio::spawn(async move {
unsubscribe_temporary_thread(&request_handle, temporary_thread_id).await;
});
}
return;
}
let save_name = (destination == ThreadTitleDestination::Automatic)
.then(|| app_server.automatic_thread_name_writer(thread_id, expected_name));
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,
);
}
return;
}
};
let (sender, receiver) = mpsc::unbounded_channel();
self.temporary_structured_requests
.insert(temporary_thread_id, (TemporaryThreadKind::Title, 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,
TemporaryThreadKind::Title.turn_params(
temporary_thread_id.to_string(),
prompt,
thread_title_output_schema(),
effort,
),
receiver,
cancellation.clone(),
)
.await
.map_err(|error| error.to_string());
if let Some(save_name) = save_name
&& let Some(title) = result
.as_deref()
.ok()
.and_then(parse_thread_title)
.or(fallback_title)
{
save_name.save(title, &cancellation).await;
}
event_sender.send(AppEvent::GeneratedThreadTitle {
cancellation,
thread_id,
temporary_thread_id: Some(temporary_thread_id),
destination,
result,
});
});
}
/// Suggest a title from stored and live conversation items without persisting it.
pub(super) async fn suggest_thread_name(
&mut self,
app_server: &mut AppServerSession,
thread_id: ThreadId,
request_id: uuid::Uuid,
) {
if self.chat_widget.thread_id() != Some(thread_id) {
return;
}
let Some(channel) = self.thread_event_channels.get(&thread_id) else {
self.chat_widget
.apply_thread_name_suggestion(thread_id, request_id, /*suggestion*/ None);
return;
};
let conversation = {
let store = channel.store.lock().await;
let mut seen = std::collections::HashSet::new();
recent_conversation_messages(
store
.turns
.iter()
.flat_map(Turn::item_payloads)
.chain(store.buffer.iter().filter_map(|event| {
let ThreadBufferedEvent::Notification(notification) = event else {
return None;
};
let ServerNotification::ItemCompleted(notification) = notification.as_ref()
else {
return None;
};
Some(&notification.item.payload)
}))
.filter(|item| seen.insert(item.id().to_string())),
)
};
let Some(conversation) = conversation else {
self.chat_widget
.apply_thread_name_suggestion(thread_id, request_id, /*suggestion*/ None);
return;
};
self.generate_thread_title(
app_server,
thread_id,
ThreadTitleDestination::RenameSuggestion { request_id },
&conversation,
/*expected_name*/ None,
);
}
}
/// 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."
)
}
/// 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();
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}")
}
pub(super) fn user_message_text(content: &[UserInput]) -> Option<String> {
let text = content
.iter()
.filter_map(|item| match item {
UserInput::Text { text, .. } => {
Some(crate::user_prompt::extract_prompt_request_with_offset(text).0)
}
_ => None,
})
.collect::<Vec<_>>()
.join(" ");
(!text.trim().is_empty()).then_some(text)
}
/// Format recent substantive messages chronologically without trusting their markup.
pub(super) fn recent_conversation_messages<'a, I>(items: I) -> Option<String>
where
I: IntoIterator<Item = &'a ThreadItemPayload>,
I::IntoIter: DoubleEndedIterator,
{
let mut messages = items
.into_iter()
.rev()
.filter_map(|item| match item {
ThreadItemPayload::UserMessage { content, .. } => {
let text = content
.iter()
.filter_map(|input| match input {
UserInput::Text { text, .. } => {
Some(crate::user_prompt::extract_prompt_request_with_offset(text).0)
}
_ => None,
})
.collect::<Vec<_>>()
.join("\n");
(!text.trim().is_empty()).then_some(("user", text))
}
ThreadItemPayload::AgentMessage { text, phase, .. }
if !matches!(phase, Some(MessagePhase::Commentary)) && !text.trim().is_empty() =>
{
Some(("assistant", text.clone()))
}
_ => None,
})
.take(THREAD_TITLE_RECENT_MESSAGES)
.map(|(role, text)| {
let escaped = text
.trim()
.replace('&', "&amp;")
.replace('<', "&lt;")
.replace('>', "&gt;");
(role, escaped)
})
.collect::<Vec<_>>();
if messages.is_empty() {
return None;
}
messages.reverse();
let conversation_bytes = THREAD_TITLE_PROMPT_MAX_BYTES
.saturating_sub(recent_conversation_thread_title_prompt("").len());
let markup_bytes = "<conversation>\n".len()
+ "\n</conversation>".len()
+ messages.len().saturating_sub(/*rhs*/ 1)
+ messages
.iter()
.map(|(role, _)| "<message role=\"\"></message>".len() + role.len())
.sum::<usize>();
let message_bytes = conversation_bytes.saturating_sub(markup_bytes) / messages.len();
let content_bytes = messages.iter().map(|(_, text)| text.len()).sum::<usize>();
let should_truncate = content_bytes > conversation_bytes.saturating_sub(markup_bytes);
let messages = messages
.into_iter()
.map(|(role, mut text)| {
if should_truncate && text.len() > message_bytes {
let mut end = message_bytes;
while !text.is_char_boundary(end) {
end -= 1;
}
if let Some(entity_start) = text[..end].rfind('&')
&& !text[entity_start..end].contains(';')
{
end = entity_start;
}
text.truncate(end);
}
format!("<message role=\"{role}\">{text}</message>")
})
.collect::<Vec<_>>();
Some(format!(
"<conversation>\n{}\n</conversation>",
messages.join("\n")
))
}
/// Bound the entire suggestion prompt while preserving complete Unicode characters.
pub(super) fn recent_conversation_thread_title_prompt(conversation: &str) -> String {
let instructions = thread_title_instructions();
let prefix = format!(
"{instructions}\n\
Prioritize the current task and latest substantive user request.\n\n\
Recent conversation messages:\n"
);
let conversation = conversation.trim();
let remaining_bytes = THREAD_TITLE_PROMPT_MAX_BYTES.saturating_sub(prefix.len());
let mut start = conversation.len().saturating_sub(remaining_bytes);
while !conversation.is_char_boundary(start) {
start += 1;
}
let conversation = &conversation[start..];
format!("{prefix}{conversation}")
}
/// 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;