diff --git a/codex-rs/app-server-protocol/src/protocol/thread_history.rs b/codex-rs/app-server-protocol/src/protocol/thread_history.rs index d2296c75c5..aacb08fcb1 100644 --- a/codex-rs/app-server-protocol/src/protocol/thread_history.rs +++ b/codex-rs/app-server-protocol/src/protocol/thread_history.rs @@ -37,6 +37,7 @@ use codex_protocol::protocol::GuardianAssessmentEvent; use codex_protocol::protocol::GuardianAssessmentStatus; use codex_protocol::protocol::ImageGenerationBeginEvent; use codex_protocol::protocol::ImageGenerationEndEvent; +use codex_protocol::protocol::InjectedMessageEvent; use codex_protocol::protocol::ItemCompletedEvent; use codex_protocol::protocol::ItemStartedEvent; use codex_protocol::protocol::McpToolCallBeginEvent; @@ -207,6 +208,7 @@ impl ThreadHistoryBuilder { EventMsg::TurnAborted(payload) => self.handle_turn_aborted(payload), EventMsg::TurnStarted(payload) => self.handle_turn_started(payload), EventMsg::TurnComplete(payload) => self.handle_turn_complete(payload), + EventMsg::InjectedMessage(payload) => self.handle_injected_message(payload), _ => {} } } @@ -287,6 +289,21 @@ impl ThreadHistoryBuilder { }); } + fn handle_injected_message(&mut self, payload: &InjectedMessageEvent) { + if payload.content.trim().is_empty() { + return; + } + + let id = self.next_item_id(); + self.ensure_turn().items.push(ThreadItem::UserMessage { + id, + content: vec![UserInput::Text { + text: payload.content.clone(), + text_elements: Vec::new(), + }], + }); + } + fn handle_agent_reasoning(&mut self, payload: &AgentReasoningEvent) { if payload.text.is_empty() { return; diff --git a/codex-rs/app-server/src/bespoke_event_handling.rs b/codex-rs/app-server/src/bespoke_event_handling.rs index 08a51108ae..9531585049 100644 --- a/codex-rs/app-server/src/bespoke_event_handling.rs +++ b/codex-rs/app-server/src/bespoke_event_handling.rs @@ -99,6 +99,7 @@ use codex_app_server_protocol::TurnPlanStep; use codex_app_server_protocol::TurnPlanUpdatedNotification; use codex_app_server_protocol::TurnStartedNotification; use codex_app_server_protocol::TurnStatus; +use codex_app_server_protocol::UserInput as V2UserInput; use codex_app_server_protocol::build_command_execution_end_item; use codex_app_server_protocol::build_file_change_approval_request_item; use codex_app_server_protocol::build_file_change_begin_item; @@ -1492,6 +1493,24 @@ pub(crate) async fn apply_bespoke_event_handling( .send_server_notification(ServerNotification::ItemCompleted(notification)) .await; } + EventMsg::InjectedMessage(event) => { + if !event.content.trim().is_empty() { + let notification = ItemCompletedNotification { + thread_id: conversation_id.to_string(), + turn_id: event_turn_id.clone(), + item: ThreadItem::UserMessage { + id: uuid::Uuid::new_v4().to_string(), + content: vec![V2UserInput::Text { + text: event.content, + text_elements: Vec::new(), + }], + }, + }; + outgoing + .send_server_notification(ServerNotification::ItemCompleted(notification)) + .await; + } + } EventMsg::HookStarted(event) => { if let ApiVersion::V2 = api_version { let notification = HookStartedNotification { diff --git a/codex-rs/cli/src/main.rs b/codex-rs/cli/src/main.rs index b13d2f0de3..b178941b1c 100644 --- a/codex-rs/cli/src/main.rs +++ b/codex-rs/cli/src/main.rs @@ -17,13 +17,6 @@ use codex_cli::run_login_with_chatgpt; use codex_cli::run_login_with_device_code; use codex_cli::run_logout; use codex_cloud_tasks::Cli as CloudTasksCli; -use codex_core::messages::MessagePayload; -use codex_core::messages::validate_meta_key; -use codex_core::timers::ThreadTimerStorageCreateParams; -use codex_core::timers::ThreadTimerTrigger; -use codex_core::timers::TimerDelivery; -use codex_core::timers::build_thread_timer_create_params; -use codex_core::timers::normalize_thread_timer_dtstart_input; use codex_exec::Cli as ExecCli; use codex_exec::Command as ExecCommand; use codex_exec::ReviewArgs; @@ -37,9 +30,7 @@ use codex_tui::ExitReason; use codex_tui::UpdateAction; use codex_utils_cli::CliConfigOverrides; use owo_colors::OwoColorize; -use std::collections::BTreeMap; use std::io::IsTerminal; -use std::path::Path; use std::path::PathBuf; use supports_color::Stream; @@ -49,11 +40,14 @@ mod app_cmd; mod desktop_app; mod marketplace_cmd; mod mcp_cmd; +mod queue_cmd; #[cfg(not(windows))] mod wsl_paths; use crate::marketplace_cmd::MarketplaceCli; use crate::mcp_cmd::McpCli; +use crate::queue_cmd::QueueCommand; +use crate::queue_cmd::run_queue_command; use codex_core::config::Config; use codex_core::config::ConfigOverrides; @@ -62,7 +56,6 @@ use codex_core::config::find_codex_home; use codex_features::FEATURES; use codex_features::Stage; use codex_features::is_known_feature_key; -use codex_protocol::ThreadId; use codex_protocol::protocol::AskForApproval; use codex_protocol::user_input::UserInput; use codex_terminal_detection::TerminalName; @@ -230,33 +223,6 @@ struct DebugPromptInputCommand { images: Vec, } -#[derive(Debug, Parser)] -struct QueueCommand { - /// Target thread id. - #[arg(long = "thread", value_name = "THREAD_ID")] - thread: String, - - /// Message content. - #[arg(long = "content", value_name = "TEXT")] - content: String, - - /// Optional instructions for immediate messages. Not allowed with --at. - #[arg(long = "instructions", value_name = "TEXT")] - instructions: Option, - - /// Message metadata as key=value. May be repeated. - #[arg(long = "meta", value_name = "KEY=VALUE")] - meta: Vec, - - /// Deliver by steering the current turn when possible. - #[arg(long = "steer")] - steer: bool, - - /// Queue a one-shot timer for a local datetime or time, e.g. 2026-04-10T09:30:00 or 09:30. - #[arg(long = "at", value_name = "WHEN")] - at: Option, -} - #[derive(Debug, Parser)] struct ResumeCommand { /// Conversation/session id (UUID) or thread name. UUIDs take precedence if it parses. @@ -1322,137 +1288,6 @@ async fn run_debug_clear_memories_command( Ok(()) } -async fn run_queue_command( - cmd: QueueCommand, - root_config_overrides: &CliConfigOverrides, - interactive: &TuiCli, -) -> anyhow::Result<()> { - validate_queue_command(&cmd)?; - let meta = parse_queue_meta(&cmd.meta)?; - let cli_kv_overrides = root_config_overrides - .parse_overrides() - .map_err(anyhow::Error::msg)?; - let overrides = ConfigOverrides { - config_profile: interactive.config_profile.clone(), - ..Default::default() - }; - let config = - Config::load_with_cli_overrides_and_harness_overrides(cli_kv_overrides, overrides).await?; - let thread_id = resolve_queue_thread_id(config.codex_home.as_path(), &cmd.thread).await?; - let state_db = - StateRuntime::init(config.sqlite_home.clone(), config.model_provider_id.clone()).await?; - let delivery = if cmd.steer { - TimerDelivery::SteerCurrentTurn - } else { - TimerDelivery::AfterTurn - }; - - if let Some(at) = cmd.at { - let dtstart = normalize_thread_timer_dtstart_input(&at).map_err(anyhow::Error::msg)?; - let timer_params = build_thread_timer_create_params(ThreadTimerStorageCreateParams { - thread_id, - source: "external".to_string(), - client_id: "codex-cli".to_string(), - trigger: ThreadTimerTrigger::Schedule { - dtstart: Some(dtstart.clone()), - rrule: None, - }, - payload: MessagePayload { - content: cmd.content, - instructions: None, - meta, - }, - delivery, - }) - .map_err(anyhow::Error::msg)?; - state_db.create_thread_timer(&timer_params).await?; - println!( - "{}", - queue_timer_success_message( - &timer_params.id, - &timer_params.thread_id, - &dtstart, - timer_params.pending_run, - ) - ); - return Ok(()); - } - - let meta_json = serde_json::to_string(&meta)?; - let message_params = codex_state::ThreadMessageCreateParams::new( - thread_id, - "external".to_string(), - cmd.content, - cmd.instructions, - meta_json, - delivery.as_str().to_string(), - unix_timestamp_now()?, - ); - state_db.create_thread_message(&message_params).await?; - println!( - "Queued message {} for thread {}.", - message_params.id, message_params.thread_id - ); - Ok(()) -} - -fn queue_timer_success_message( - timer_id: &str, - thread_id: &str, - dtstart: &str, - pending_run: bool, -) -> String { - if pending_run { - format!("Queued timer {timer_id} for thread {thread_id}; it is due now.") - } else { - let local_time = dtstart.replace('T', " "); - format!( - "Queued timer {timer_id} for thread {thread_id}; it will fire at {local_time} local time." - ) - } -} - -async fn resolve_queue_thread_id(codex_home: &Path, target: &str) -> anyhow::Result { - if let Ok(thread_id) = ThreadId::from_string(target) { - return Ok(thread_id.to_string()); - } - - let thread_ids = codex_core::find_thread_ids_by_name(codex_home, target).await?; - match thread_ids.as_slice() { - [] => anyhow::bail!("no thread named `{target}`"), - [thread_id] => Ok(thread_id.to_string()), - _ => anyhow::bail!("more than one thread is named `{target}`; use a thread id instead"), - } -} - -fn validate_queue_command(cmd: &QueueCommand) -> anyhow::Result<()> { - if cmd.at.is_some() && cmd.instructions.is_some() { - anyhow::bail!("--instructions is not supported with --at"); - } - Ok(()) -} - -fn unix_timestamp_now() -> anyhow::Result { - let duration = std::time::SystemTime::now() - .duration_since(std::time::UNIX_EPOCH) - .map_err(|err| anyhow::anyhow!("system clock is before unix epoch: {err}"))?; - i64::try_from(duration.as_secs()).map_err(|_| anyhow::anyhow!("current time is out of range")) -} - -fn parse_queue_meta(entries: &[String]) -> anyhow::Result> { - let mut meta = BTreeMap::new(); - for entry in entries { - let Some((key, value)) = entry.split_once('=') else { - anyhow::bail!("metadata entry `{entry}` must use key=value syntax"); - }; - validate_meta_key(key).map_err(anyhow::Error::msg)?; - if meta.insert(key.to_string(), value.to_string()).is_some() { - anyhow::bail!("duplicate metadata key `{key}`"); - } - } - Ok(meta) -} - /// Prepend root-level overrides so they have lower precedence than /// CLI-specific ones specified after the subcommand (if any). fn prepend_config_flags( @@ -1696,7 +1531,6 @@ mod tests { use codex_protocol::ThreadId; use codex_protocol::protocol::TokenUsage; use pretty_assertions::assert_eq; - use tempfile::TempDir; fn finalize_resume_from_args(args: &[&str]) -> TuiCli { let cli = MultitoolCli::try_parse_from(args).expect("parse"); @@ -1755,123 +1589,6 @@ mod tests { finalize_fork_interactive(interactive, root_overrides, session_id, last, all, fork_cli) } - #[test] - fn queue_command_parses_immediate_message() { - let cli = MultitoolCli::try_parse_from([ - "codex", - "queue", - "--thread", - "thread-1", - "--content", - "do work", - "--instructions", - "be brief", - "--meta", - "ticket=ABC_123", - "--steer", - ]) - .expect("parse"); - let Some(Subcommand::Queue(cmd)) = cli.subcommand else { - unreachable!() - }; - - assert_eq!(cmd.thread, "thread-1"); - assert_eq!(cmd.content, "do work"); - assert_eq!(cmd.instructions, Some("be brief".to_string())); - assert_eq!(cmd.meta, vec!["ticket=ABC_123".to_string()]); - assert!(cmd.steer); - assert_eq!(cmd.at, None); - } - - #[test] - fn queue_meta_rejects_invalid_and_duplicate_keys() { - assert!(parse_queue_meta(&["bad-key=value".to_string()]).is_err()); - assert!(parse_queue_meta(&["ticket=one".to_string(), "ticket=two".to_string()]).is_err()); - } - - #[test] - fn queue_at_rejects_instructions() { - let cli = MultitoolCli::try_parse_from([ - "codex", - "queue", - "--thread", - "thread-1", - "--content", - "do work", - "--instructions", - "be brief", - "--at", - "2026-04-10T12:00:00", - ]) - .expect("parse"); - let Some(Subcommand::Queue(cmd)) = cli.subcommand else { - unreachable!() - }; - - let err = validate_queue_command(&cmd).expect_err("queue command should be rejected"); - assert_eq!(err.to_string(), "--instructions is not supported with --at"); - } - - #[test] - fn queued_timer_output_reports_fire_time() { - assert_eq!( - queue_timer_success_message("timer-1", "thread-1", "2026-04-10T08:59:00", false), - "Queued timer timer-1 for thread thread-1; it will fire at 2026-04-10 08:59:00 local time." - ); - } - - #[test] - fn queued_timer_output_reports_due_now() { - assert_eq!( - queue_timer_success_message("timer-1", "thread-1", "2026-04-10T08:59:00", true), - "Queued timer timer-1 for thread thread-1; it is due now." - ); - } - - #[tokio::test] - async fn queue_thread_resolves_thread_name() { - let temp = TempDir::new().expect("tempdir"); - let thread_id = ThreadId::new(); - codex_core::append_thread_name(temp.path(), thread_id, "named-thread") - .await - .expect("append thread name"); - - assert_eq!( - resolve_queue_thread_id(temp.path(), "named-thread") - .await - .expect("resolve"), - thread_id.to_string() - ); - } - - #[tokio::test] - async fn queue_thread_name_rejects_missing_and_ambiguous_names() { - let temp = TempDir::new().expect("tempdir"); - let first = ThreadId::new(); - let second = ThreadId::new(); - codex_core::append_thread_name(temp.path(), first, "same") - .await - .expect("append first name"); - codex_core::append_thread_name(temp.path(), second, "same") - .await - .expect("append second name"); - - assert_eq!( - resolve_queue_thread_id(temp.path(), "missing") - .await - .expect_err("missing name should fail") - .to_string(), - "no thread named `missing`" - ); - assert_eq!( - resolve_queue_thread_id(temp.path(), "same") - .await - .expect_err("ambiguous name should fail") - .to_string(), - "more than one thread is named `same`; use a thread id instead" - ); - } - #[test] fn exec_resume_last_accepts_prompt_positional() { let cli = diff --git a/codex-rs/cli/src/queue_cmd.rs b/codex-rs/cli/src/queue_cmd.rs new file mode 100644 index 0000000000..4661d7b996 --- /dev/null +++ b/codex-rs/cli/src/queue_cmd.rs @@ -0,0 +1,327 @@ +//! Implementation for the `codex queue` command. +//! +//! The top-level CLI module owns command routing; this module owns the +//! queue-specific policy for resolving target threads, validating message +//! metadata, and writing either immediate messages or one-shot timers into the +//! SQLite state database. + +use clap::Parser; +use codex_core::config::Config; +use codex_core::config::ConfigOverrides; +use codex_core::messages::MessagePayload; +use codex_core::messages::validate_meta_key; +use codex_core::timers::ThreadTimerStorageCreateParams; +use codex_core::timers::ThreadTimerTrigger; +use codex_core::timers::TimerDelivery; +use codex_core::timers::build_thread_timer_create_params; +use codex_core::timers::normalize_thread_timer_dtstart_input; +use codex_protocol::ThreadId; +use codex_state::StateRuntime; +use codex_tui::Cli as TuiCli; +use codex_utils_cli::CliConfigOverrides; +use std::collections::BTreeMap; +use std::path::Path; + +#[derive(Debug, Parser)] +pub(crate) struct QueueCommand { + /// Target thread id. + #[arg(long = "thread", value_name = "THREAD_ID")] + thread: String, + + /// Message text. + #[arg(long = "message", value_name = "TEXT")] + message: String, + + /// Message metadata as key=value. May be repeated. + #[arg(long = "meta", value_name = "KEY=VALUE")] + meta: Vec, + + /// Queue a one-shot timer for a local datetime or time, e.g. 2026-04-10T09:30:00 or 09:30. + #[arg(long = "at", value_name = "WHEN")] + at: Option, +} + +pub(crate) async fn run_queue_command( + cmd: QueueCommand, + root_config_overrides: &CliConfigOverrides, + interactive: &TuiCli, +) -> anyhow::Result<()> { + let meta = parse_queue_meta(&cmd.meta)?; + let cli_kv_overrides = root_config_overrides + .parse_overrides() + .map_err(anyhow::Error::msg)?; + let overrides = ConfigOverrides { + config_profile: interactive.config_profile.clone(), + ..Default::default() + }; + let config = + Config::load_with_cli_overrides_and_harness_overrides(cli_kv_overrides, overrides).await?; + let thread_id = resolve_queue_thread_id(config.codex_home.as_path(), &cmd.thread).await?; + let state_db = + StateRuntime::init(config.sqlite_home.clone(), config.model_provider_id.clone()).await?; + let delivery = TimerDelivery::AfterTurn; + + if let Some(at) = cmd.at { + let dtstart = normalize_thread_timer_dtstart_input(&at).map_err(anyhow::Error::msg)?; + let timer_params = build_thread_timer_create_params(ThreadTimerStorageCreateParams { + thread_id, + source: "external".to_string(), + client_id: "codex-cli".to_string(), + trigger: ThreadTimerTrigger::Schedule { + dtstart: Some(dtstart.clone()), + rrule: None, + }, + payload: MessagePayload { + content: cmd.message, + instructions: None, + meta, + }, + delivery, + }) + .map_err(anyhow::Error::msg)?; + state_db.create_thread_timer(&timer_params).await?; + println!( + "{}", + queue_timer_success_message( + &timer_params.id, + &timer_params.thread_id, + &dtstart, + timer_params.pending_run, + ) + ); + return Ok(()); + } + + let meta_json = serde_json::to_string(&meta)?; + let message_params = codex_state::ThreadMessageCreateParams::new( + thread_id, + "external".to_string(), + cmd.message, + None, + meta_json, + delivery.as_str().to_string(), + unix_timestamp_now()?, + ); + state_db.create_thread_message(&message_params).await?; + println!( + "Queued message {} for thread {}.", + message_params.id, message_params.thread_id + ); + Ok(()) +} + +fn queue_timer_success_message( + timer_id: &str, + thread_id: &str, + dtstart: &str, + pending_run: bool, +) -> String { + if pending_run { + format!("Queued timer {timer_id} for thread {thread_id}; it is due now.") + } else { + let local_time = dtstart.replace('T', " "); + format!( + "Queued timer {timer_id} for thread {thread_id}; it will fire at {local_time} local time." + ) + } +} + +async fn resolve_queue_thread_id(codex_home: &Path, target: &str) -> anyhow::Result { + if let Ok(thread_id) = ThreadId::from_string(target) { + return Ok(thread_id.to_string()); + } + + let thread_ids = codex_core::find_thread_ids_by_name(codex_home, target).await?; + match thread_ids.as_slice() { + [] => anyhow::bail!("no thread named `{target}`"), + [thread_id] => Ok(thread_id.to_string()), + _ => anyhow::bail!("more than one thread is named `{target}`; use a thread id instead"), + } +} + +fn unix_timestamp_now() -> anyhow::Result { + let duration = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .map_err(|err| anyhow::anyhow!("system clock is before unix epoch: {err}"))?; + i64::try_from(duration.as_secs()).map_err(|_| anyhow::anyhow!("current time is out of range")) +} + +fn parse_queue_meta(entries: &[String]) -> anyhow::Result> { + let mut meta = BTreeMap::new(); + for entry in entries { + let Some((key, value)) = entry.split_once('=') else { + anyhow::bail!("metadata entry `{entry}` must use key=value syntax"); + }; + validate_meta_key(key).map_err(anyhow::Error::msg)?; + if meta.insert(key.to_string(), value.to_string()).is_some() { + anyhow::bail!("duplicate metadata key `{key}`"); + } + } + Ok(meta) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::MultitoolCli; + use crate::Subcommand; + use pretty_assertions::assert_eq; + use tempfile::TempDir; + + #[test] + fn queue_command_parses_immediate_message() { + let cli = MultitoolCli::try_parse_from([ + "codex", + "queue", + "--thread", + "thread-1", + "--message", + "do work", + "--meta", + "ticket=ABC_123", + ]) + .expect("parse"); + let Some(Subcommand::Queue(cmd)) = cli.subcommand else { + unreachable!() + }; + + assert_eq!(cmd.thread, "thread-1"); + assert_eq!(cmd.message, "do work"); + assert_eq!(cmd.meta, vec!["ticket=ABC_123".to_string()]); + assert_eq!(cmd.at, None); + } + + #[test] + fn queue_rejects_legacy_content_flag() { + assert!( + MultitoolCli::try_parse_from([ + "codex", + "queue", + "--thread", + "thread-1", + "--content", + "do work", + ]) + .is_err() + ); + } + + #[test] + fn queue_meta_rejects_invalid_and_duplicate_keys() { + assert!(parse_queue_meta(&["bad-key=value".to_string()]).is_err()); + assert!(parse_queue_meta(&["ticket=one".to_string(), "ticket=two".to_string()]).is_err()); + } + + #[test] + fn queue_rejects_instructions_flag() { + assert!( + MultitoolCli::try_parse_from([ + "codex", + "queue", + "--thread", + "thread-1", + "--message", + "do work", + "--instructions", + "be brief", + ]) + .is_err() + ); + } + + #[test] + fn queue_rejects_steer_flag() { + assert!( + MultitoolCli::try_parse_from([ + "codex", + "queue", + "--thread", + "thread-1", + "--message", + "do work", + "--steer", + ]) + .is_err() + ); + } + + #[test] + fn queue_at_parses_without_instructions() { + let cli = MultitoolCli::try_parse_from([ + "codex", + "queue", + "--thread", + "thread-1", + "--message", + "do work", + "--at", + "2026-04-10T12:00:00", + ]) + .expect("parse"); + let Some(Subcommand::Queue(cmd)) = cli.subcommand else { + unreachable!() + }; + + assert_eq!(cmd.at, Some("2026-04-10T12:00:00".to_string())); + } + + #[test] + fn queued_timer_output_reports_fire_time() { + assert_eq!( + queue_timer_success_message("timer-1", "thread-1", "2026-04-10T08:59:00", false), + "Queued timer timer-1 for thread thread-1; it will fire at 2026-04-10 08:59:00 local time." + ); + } + + #[test] + fn queued_timer_output_reports_due_now() { + assert_eq!( + queue_timer_success_message("timer-1", "thread-1", "2026-04-10T08:59:00", true), + "Queued timer timer-1 for thread thread-1; it is due now." + ); + } + + #[tokio::test] + async fn queue_thread_resolves_thread_name() { + let temp = TempDir::new().expect("tempdir"); + let thread_id = ThreadId::new(); + codex_core::append_thread_name(temp.path(), thread_id, "named-thread") + .await + .expect("append thread name"); + + assert_eq!( + resolve_queue_thread_id(temp.path(), "named-thread") + .await + .expect("resolve"), + thread_id.to_string() + ); + } + + #[tokio::test] + async fn queue_thread_name_rejects_missing_and_ambiguous_names() { + let temp = TempDir::new().expect("tempdir"); + let first = ThreadId::new(); + let second = ThreadId::new(); + codex_core::append_thread_name(temp.path(), first, "same") + .await + .expect("append first name"); + codex_core::append_thread_name(temp.path(), second, "same") + .await + .expect("append second name"); + + assert_eq!( + resolve_queue_thread_id(temp.path(), "missing") + .await + .expect_err("missing name should fail") + .to_string(), + "no thread named `missing`" + ); + assert_eq!( + resolve_queue_thread_id(temp.path(), "same") + .await + .expect_err("ambiguous name should fail") + .to_string(), + "more than one thread is named `same`; use a thread id instead" + ); + } +} diff --git a/codex-rs/core/src/codex.rs b/codex-rs/core/src/codex.rs index bf09e5df30..6afa9d9d1b 100644 --- a/codex-rs/core/src/codex.rs +++ b/codex-rs/core/src/codex.rs @@ -114,6 +114,7 @@ use codex_protocol::permissions::FileSystemSandboxPolicy; use codex_protocol::permissions::NetworkSandboxPolicy; use codex_protocol::protocol::FileChange; use codex_protocol::protocol::HasLegacyEvent; +use codex_protocol::protocol::InjectedMessageEvent; use codex_protocol::protocol::InterAgentCommunication; use codex_protocol::protocol::ItemCompletedEvent; use codex_protocol::protocol::ItemStartedEvent; @@ -287,6 +288,7 @@ use crate::mentions::collect_explicit_app_ids; use crate::mentions::collect_explicit_plugin_mentions; use crate::mentions::collect_tool_mentions_from_messages; use crate::network_policy_decision::execpolicy_network_rule_amendment; +use crate::pending_input::PendingInputItem; use crate::plugins::PluginsManager; use crate::plugins::build_plugin_injections; use crate::plugins::render_plugins_section; @@ -848,7 +850,7 @@ pub(crate) struct Session { timer_db_sync_started: AtomicBool, mailbox: Mailbox, mailbox_rx: Mutex, - idle_pending_input: Mutex>, // TODO (jif) merge with mailbox! + idle_pending_input: Mutex>, // TODO (jif) merge with mailbox! timers: Mutex, timer_tasks_cancellation_token: CancellationToken, pub(crate) guardian_review_session: GuardianReviewSessionManager, @@ -4137,6 +4139,19 @@ impl Session { self.ensure_rollout_materialized().await; } + pub(crate) async fn record_generated_message_and_emit_display( + &self, + turn_context: &TurnContext, + response_item: ResponseItem, + injected_event: InjectedMessageEvent, + ) { + self.record_conversation_items(turn_context, std::slice::from_ref(&response_item)) + .await; + self.send_event(turn_context, EventMsg::InjectedMessage(injected_event)) + .await; + self.ensure_rollout_materialized().await; + } + pub(crate) async fn notify_background_event( &self, turn_context: &TurnContext, @@ -4250,7 +4265,7 @@ impl Session { } let mut turn_state = active_turn.turn_state.lock().await; - turn_state.push_pending_input(input.into()); + turn_state.push_pending_input(ResponseInputItem::from(input).into()); turn_state.accept_mailbox_delivery_for_current_turn(); Ok(active_turn_id.clone()) } @@ -4265,7 +4280,7 @@ impl Session { Some(at) => { let mut ts = at.turn_state.lock().await; for item in input { - ts.push_pending_input(item); + ts.push_pending_input(item.into()); } Ok(()) } @@ -4321,7 +4336,16 @@ impl Session { self.mailbox_rx.lock().await.has_pending_trigger_turn() } + #[cfg(test)] pub async fn prepend_pending_input(&self, input: Vec) -> Result<(), ()> { + self.prepend_pending_input_items(input.into_iter().map(Into::into).collect()) + .await + } + + pub(crate) async fn prepend_pending_input_items( + &self, + input: Vec, + ) -> Result<(), ()> { let mut active = self.active_turn.lock().await; match active.as_mut() { Some(at) => { @@ -4333,7 +4357,16 @@ impl Session { } } + #[cfg(test)] pub async fn get_pending_input(&self) -> Vec { + self.take_pending_input_items() + .await + .into_iter() + .map(PendingInputItem::into_model_input) + .collect() + } + + pub(crate) async fn take_pending_input_items(&self) -> Vec { let (pending_input, accepts_mailbox_delivery) = { let mut active = self.active_turn.lock().await; match active.as_mut() { @@ -4356,6 +4389,7 @@ impl Session { .drain() .into_iter() .map(|mail| mail.to_response_input_item()) + .map(Into::into) .collect::>() }; if pending_input.is_empty() { @@ -4369,16 +4403,26 @@ impl Session { } } + #[cfg(test)] pub(crate) async fn queue_response_items_for_next_turn(&self, items: Vec) { if items.is_empty() { return; } + let mut idle_pending_input = self.idle_pending_input.lock().await; + idle_pending_input.extend(items.into_iter().map(PendingInputItem::from)); + } + + pub(crate) async fn queue_pending_input_for_next_turn(&self, items: Vec) { + if items.is_empty() { + return; + } + let mut idle_pending_input = self.idle_pending_input.lock().await; idle_pending_input.extend(items); } - pub(crate) async fn take_queued_response_items_for_next_turn(&self) -> Vec { + pub(crate) async fn take_queued_pending_input_for_next_turn(&self) -> Vec { std::mem::take(&mut *self.idle_pending_input.lock().await) } @@ -6258,7 +6302,7 @@ pub(crate) async fn run_turn( // submitted through the UI while the model was running. Though the UI // may support this, the model might not. let pending_input = if can_drain_pending_input { - sess.get_pending_input().await + sess.take_pending_input_items().await } else { Vec::new() }; @@ -6279,7 +6323,9 @@ pub(crate) async fn run_turn( } => { let remaining_pending_input = pending_input_iter.collect::>(); if !remaining_pending_input.is_empty() { - let _ = sess.prepend_pending_input(remaining_pending_input).await; + let _ = sess + .prepend_pending_input_items(remaining_pending_input) + .await; requeued_pending_input = true; } blocked_pending_input_contexts = additional_contexts; @@ -7244,6 +7290,7 @@ fn realtime_text_for_event(msg: &EventMsg) -> Option { | EventMsg::TurnComplete(_) | EventMsg::TokenCount(_) | EventMsg::UserMessage(_) + | EventMsg::InjectedMessage(_) | EventMsg::AgentMessageDelta(_) | EventMsg::AgentReasoning(_) | EventMsg::AgentReasoningDelta(_) diff --git a/codex-rs/core/src/codex/timer_runtime.rs b/codex-rs/core/src/codex/timer_runtime.rs index f6128597a4..3bcf759887 100644 --- a/codex-rs/core/src/codex/timer_runtime.rs +++ b/codex-rs/core/src/codex/timer_runtime.rs @@ -1,3 +1,10 @@ +//! SQLite-backed runtime bridge for thread timers and queued thread messages. +//! +//! This module connects [`Session`] to the persistent state database, keeps the +//! in-memory timer scheduler reconciled with cross-instance changes, and +//! converts claimed timers/messages into generated model input plus +//! transcript-safe delivery events. + use super::BackgroundEventEvent; use super::Event; use super::EventMsg; @@ -7,8 +14,11 @@ use crate::messages::MessageInvocationContext; use crate::messages::MessagePayload; use crate::messages::ThreadMessage; use crate::messages::db_message_to_thread_message; +use crate::messages::injected_message_event; use crate::messages::message_prompt_input_item; use crate::messages::validate_meta; +use crate::pending_input::GeneratedMessageInput; +use crate::pending_input::PendingInputItem; use crate::timers::ClaimedTimer; use crate::timers::CreateTimer; use crate::timers::PersistedTimer; @@ -20,10 +30,9 @@ use crate::timers::ThreadTimerTrigger; use crate::timers::TimerDelivery; use crate::timers::TimerTaskSpec; use crate::timers::TimersState; -use crate::timers::timer_prompt_input_item; +use crate::timers::timer_message_invocation_context; use chrono::Utc; use codex_features::Feature; -use codex_protocol::models::ResponseInputItem; use codex_rollout::state_db; use std::sync::Arc; use std::sync::atomic::Ordering; @@ -236,17 +245,21 @@ impl Session { if deleted_one_shot_timer { self.emit_timer_updated_notification().await; } - let input_item = timer_prompt_input_item(&context); + let message_context = timer_message_invocation_context(&context); + let input_item = PendingInputItem::GeneratedMessage(GeneratedMessageInput { + item: message_prompt_input_item(&message_context), + injected_event: injected_message_event(&message_context), + }); match context.delivery { TimerDelivery::SteerCurrentTurn => { if !self.inject_timer_into_active_turn(input_item.clone()).await { - self.queue_response_items_for_next_turn(vec![input_item]) + self.queue_pending_input_for_next_turn(vec![input_item]) .await; self.maybe_start_turn_for_pending_work().await; } } TimerDelivery::AfterTurn => { - self.queue_response_items_for_next_turn(vec![input_item]) + self.queue_pending_input_for_next_turn(vec![input_item]) .await; self.maybe_start_turn_for_pending_work().await; } @@ -266,13 +279,13 @@ impl Session { .inject_message_into_active_turn(input_item.clone()) .await { - self.queue_response_items_for_next_turn(vec![input_item]) + self.queue_pending_input_for_next_turn(vec![input_item]) .await; self.maybe_start_turn_for_pending_work().await; } } TimerDelivery::AfterTurn => { - self.queue_response_items_for_next_turn(vec![input_item]) + self.queue_pending_input_for_next_turn(vec![input_item]) .await; self.maybe_start_turn_for_pending_work().await; } @@ -282,7 +295,7 @@ impl Session { async fn claim_next_message_for_delivery( self: &Arc, - ) -> Option<(ResponseInputItem, TimerDelivery)> { + ) -> Option<(PendingInputItem, TimerDelivery)> { if !self.features.enabled(Feature::TimerScheduler) { return None; } @@ -342,12 +355,16 @@ impl Session { } }; let delivery = message.delivery; - let input_item = message_prompt_input_item(&MessageInvocationContext { + let message_context = MessageInvocationContext { source: message.source.clone(), content: message.content.clone(), instructions: message.instructions.clone(), meta: message.meta.clone(), queued_at: message.queued_at, + }; + let input_item = PendingInputItem::GeneratedMessage(GeneratedMessageInput { + item: message_prompt_input_item(&message_context), + injected_event: injected_message_event(&message_context), }); return Some((input_item, delivery)); } @@ -402,11 +419,11 @@ impl Session { Some(claimed) } - async fn inject_timer_into_active_turn(&self, item: ResponseInputItem) -> bool { + async fn inject_timer_into_active_turn(&self, item: PendingInputItem) -> bool { self.inject_message_into_active_turn(item).await } - async fn inject_message_into_active_turn(&self, item: ResponseInputItem) -> bool { + async fn inject_message_into_active_turn(&self, item: PendingInputItem) -> bool { let turn_state = { let active = self.active_turn.lock().await; let Some(active_turn) = active.as_ref() else { diff --git a/codex-rs/core/src/codex_tests.rs b/codex-rs/core/src/codex_tests.rs index 074de11ba4..d2dc7052f0 100644 --- a/codex-rs/core/src/codex_tests.rs +++ b/codex-rs/core/src/codex_tests.rs @@ -74,6 +74,7 @@ use codex_protocol::protocol::ConversationAudioParams; use codex_protocol::protocol::CreditsSnapshot; use codex_protocol::protocol::GranularApprovalConfig; use codex_protocol::protocol::InitialHistory; +use codex_protocol::protocol::InjectedMessageEvent; use codex_protocol::protocol::InterAgentCommunication; use codex_protocol::protocol::NetworkApprovalProtocol; use codex_protocol::protocol::RateLimitSnapshot; @@ -5059,6 +5060,49 @@ async fn queued_response_items_for_next_turn_move_into_next_active_turn() { assert_eq!(sess.get_pending_input().await, vec![queued_item]); } +#[tokio::test] +async fn generated_message_records_raw_item_and_emits_injected_event() { + let (sess, tc, rx) = make_session_and_context_with_rx().await; + let response_item = ResponseItem::Message { + id: None, + role: "user".to_string(), + content: vec![ContentItem::InputText { + text: "hidden wrapper".to_string(), + }], + end_turn: None, + phase: None, + }; + let injected_event = InjectedMessageEvent { + content: "Visible message".to_string(), + source: "external".to_string(), + }; + + sess.record_generated_message_and_emit_display(tc.as_ref(), response_item, injected_event) + .await; + + let raw = rx.recv().await.expect("raw response item event"); + assert!(matches!(raw.msg, EventMsg::RawResponseItem(_))); + + let injected = rx.recv().await.expect("injected message event"); + let EventMsg::InjectedMessage(injected) = injected.msg else { + panic!("expected InjectedMessage event"); + }; + assert_eq!( + injected, + InjectedMessageEvent { + content: "Visible message".to_string(), + source: "external".to_string(), + } + ); + + let no_legacy_user_message = + tokio::time::timeout(std::time::Duration::from_millis(10), rx.recv()).await; + assert!( + no_legacy_user_message.is_err(), + "generated messages should not emit a legacy UserMessageEvent" + ); +} + #[tokio::test] async fn queue_only_mailbox_mail_waits_for_next_turn_after_answer_boundary() { let (sess, tc, _rx) = make_session_and_context_with_rx().await; diff --git a/codex-rs/core/src/hook_runtime.rs b/codex-rs/core/src/hook_runtime.rs index 0d620119f7..bd1bc4c836 100644 --- a/codex-rs/core/src/hook_runtime.rs +++ b/codex-rs/core/src/hook_runtime.rs @@ -10,19 +10,20 @@ use codex_hooks::UserPromptSubmitOutcome; use codex_hooks::UserPromptSubmitRequest; use codex_protocol::items::TurnItem; use codex_protocol::models::DeveloperInstructions; -use codex_protocol::models::ResponseInputItem; use codex_protocol::models::ResponseItem; use codex_protocol::protocol::AskForApproval; use codex_protocol::protocol::EventMsg; use codex_protocol::protocol::HookCompletedEvent; use codex_protocol::protocol::HookRunSummary; use codex_protocol::protocol::HookStartedEvent; +use codex_protocol::protocol::InjectedMessageEvent; use codex_protocol::user_input::UserInput; use serde_json::Value; use crate::codex::Session; use crate::codex::TurnContext; use crate::event_mapping::parse_turn_item; +use crate::pending_input::PendingInputItem; pub(crate) struct HookRuntimeOutcome { pub should_stop: bool, @@ -38,6 +39,7 @@ pub(crate) enum PendingInputRecord { UserMessage { content: Vec, response_item: ResponseItem, + injected_event: Option, additional_contexts: Vec, }, ConversationItem { @@ -199,9 +201,15 @@ pub(crate) async fn run_user_prompt_submit_hooks( pub(crate) async fn inspect_pending_input( sess: &Arc, turn_context: &Arc, - pending_input_item: ResponseInputItem, + pending_input_item: PendingInputItem, ) -> PendingInputHookDisposition { - let response_item = ResponseItem::from(pending_input_item); + let (response_item, injected_event) = match pending_input_item { + PendingInputItem::Plain(item) => (ResponseItem::from(item), None), + PendingInputItem::GeneratedMessage(generated) => ( + ResponseItem::from(generated.item), + Some(generated.injected_event), + ), + }; if let Some(TurnItem::UserMessage(user_message)) = parse_turn_item(&response_item) { let user_prompt_submit_outcome = run_user_prompt_submit_hooks(sess, turn_context, user_message.message()).await; @@ -213,6 +221,7 @@ pub(crate) async fn inspect_pending_input( PendingInputHookDisposition::Accepted(Box::new(PendingInputRecord::UserMessage { content: user_message.content, response_item, + injected_event, additional_contexts: user_prompt_submit_outcome.additional_contexts, })) } @@ -232,14 +241,24 @@ pub(crate) async fn record_pending_input( PendingInputRecord::UserMessage { content, response_item, + injected_event, additional_contexts, } => { - sess.record_user_prompt_and_emit_turn_item( - turn_context.as_ref(), - content.as_slice(), - response_item, - ) - .await; + if let Some(injected_event) = injected_event { + sess.record_generated_message_and_emit_display( + turn_context.as_ref(), + response_item, + injected_event, + ) + .await; + } else { + sess.record_user_prompt_and_emit_turn_item( + turn_context.as_ref(), + content.as_slice(), + response_item, + ) + .await; + } record_additional_contexts(sess, turn_context, additional_contexts).await; } PendingInputRecord::ConversationItem { response_item } => { diff --git a/codex-rs/core/src/lib.rs b/codex-rs/core/src/lib.rs index a708a205df..247426202f 100644 --- a/codex-rs/core/src/lib.rs +++ b/codex-rs/core/src/lib.rs @@ -65,6 +65,7 @@ mod memories; pub(crate) mod mention_syntax; pub(crate) mod message_history; pub mod messages; +pub(crate) mod pending_input; pub(crate) mod utils; pub use mention_syntax::PLUGIN_TEXT_MENTION_SIGIL; pub use mention_syntax::TOOL_MENTION_SIGIL; diff --git a/codex-rs/core/src/messages.rs b/codex-rs/core/src/messages.rs index 8a5b19ee57..24be092789 100644 --- a/codex-rs/core/src/messages.rs +++ b/codex-rs/core/src/messages.rs @@ -3,6 +3,7 @@ use crate::timers::TimerDelivery; use codex_protocol::models::ContentItem; use codex_protocol::models::ResponseInputItem; +use codex_protocol::protocol::InjectedMessageEvent; use serde::Deserialize; use serde::Serialize; use std::collections::BTreeMap; @@ -71,6 +72,13 @@ pub(crate) fn message_prompt_input_item(message: &MessageInvocationContext) -> R } } +pub(crate) fn injected_message_event(message: &MessageInvocationContext) -> InjectedMessageEvent { + InjectedMessageEvent { + content: message.content.clone(), + source: message.source.clone(), + } +} + pub(crate) fn render_message_prompt(message: &MessageInvocationContext) -> String { let mut rendered = String::new(); rendered.push_str(CODEX_MESSAGE_OPEN_TAG); diff --git a/codex-rs/core/src/pending_input.rs b/codex-rs/core/src/pending_input.rs new file mode 100644 index 0000000000..14f5080f8b --- /dev/null +++ b/codex-rs/core/src/pending_input.rs @@ -0,0 +1,30 @@ +use codex_protocol::models::ResponseInputItem; +use codex_protocol::protocol::InjectedMessageEvent; + +#[derive(Debug, Clone, PartialEq)] +pub(crate) struct GeneratedMessageInput { + pub(crate) item: ResponseInputItem, + pub(crate) injected_event: InjectedMessageEvent, +} + +#[derive(Debug, Clone, PartialEq)] +pub(crate) enum PendingInputItem { + Plain(ResponseInputItem), + GeneratedMessage(GeneratedMessageInput), +} + +impl PendingInputItem { + #[cfg(test)] + pub(crate) fn into_model_input(self) -> ResponseInputItem { + match self { + Self::Plain(item) => item, + Self::GeneratedMessage(generated) => generated.item, + } + } +} + +impl From for PendingInputItem { + fn from(item: ResponseInputItem) -> Self { + Self::Plain(item) + } +} diff --git a/codex-rs/core/src/state/turn.rs b/codex-rs/core/src/state/turn.rs index 214fd8be15..d34a65286e 100644 --- a/codex-rs/core/src/state/turn.rs +++ b/codex-rs/core/src/state/turn.rs @@ -10,7 +10,6 @@ use tokio_util::sync::CancellationToken; use tokio_util::task::AbortOnDropHandle; use codex_protocol::dynamic_tools::DynamicToolResponse; -use codex_protocol::models::ResponseInputItem; use codex_protocol::request_permissions::RequestPermissionsResponse; use codex_protocol::request_user_input::RequestUserInputResponse; use codex_rmcp_client::ElicitationResponse; @@ -18,6 +17,7 @@ use rmcp::model::RequestId; use tokio::sync::oneshot; use crate::codex::TurnContext; +use crate::pending_input::PendingInputItem; use crate::tasks::AnySessionTask; use codex_protocol::models::PermissionProfile; use codex_protocol::protocol::ReviewDecision; @@ -101,7 +101,7 @@ pub(crate) struct TurnState { pending_user_input: HashMap>, pending_elicitations: HashMap<(String, RequestId), oneshot::Sender>, pending_dynamic_tools: HashMap>, - pending_input: Vec, + pending_input: Vec, mailbox_delivery_phase: MailboxDeliveryPhase, granted_permissions: Option, pub(crate) tool_calls: u64, @@ -197,11 +197,11 @@ impl TurnState { self.pending_dynamic_tools.remove(key) } - pub(crate) fn push_pending_input(&mut self, input: ResponseInputItem) { + pub(crate) fn push_pending_input(&mut self, input: PendingInputItem) { self.pending_input.push(input); } - pub(crate) fn prepend_pending_input(&mut self, mut input: Vec) { + pub(crate) fn prepend_pending_input(&mut self, mut input: Vec) { if input.is_empty() { return; } @@ -210,7 +210,7 @@ impl TurnState { self.pending_input = input; } - pub(crate) fn take_pending_input(&mut self) -> Vec { + pub(crate) fn take_pending_input(&mut self) -> Vec { if self.pending_input.is_empty() { Vec::with_capacity(0) } else { diff --git a/codex-rs/core/src/tasks/mod.rs b/codex-rs/core/src/tasks/mod.rs index 0e148237b3..2549c4960b 100644 --- a/codex-rs/core/src/tasks/mod.rs +++ b/codex-rs/core/src/tasks/mod.rs @@ -27,6 +27,7 @@ use crate::hook_runtime::PendingInputHookDisposition; use crate::hook_runtime::inspect_pending_input; use crate::hook_runtime::record_additional_contexts; use crate::hook_runtime::record_pending_input; +use crate::pending_input::PendingInputItem; use crate::state::ActiveTurn; use crate::state::RunningTask; use crate::state::TaskKind; @@ -38,7 +39,6 @@ use codex_otel::TURN_NETWORK_PROXY_METRIC; use codex_otel::TURN_TOKEN_USAGE_METRIC; use codex_otel::TURN_TOOL_CALL_METRIC; use codex_protocol::models::ContentItem; -use codex_protocol::models::ResponseInputItem; use codex_protocol::models::ResponseItem; use codex_protocol::protocol::EventMsg; use codex_protocol::protocol::RolloutItem; @@ -255,8 +255,8 @@ impl Session { let cancellation_token = CancellationToken::new(); let done = Arc::new(Notify::new()); - let queued_response_items = self.take_queued_response_items_for_next_turn().await; - let mailbox_items = self.get_pending_input().await; + let queued_response_items = self.take_queued_pending_input_for_next_turn().await; + let mailbox_items = self.take_pending_input_items().await; let turn_state = { let mut active = self.active_turn.lock().await; let turn = active.get_or_insert_with(ActiveTurn::default); @@ -405,7 +405,7 @@ impl Session { .turn_metadata_state .cancel_git_enrichment_task(); - let mut pending_input = Vec::::new(); + let mut pending_input = Vec::::new(); let mut should_clear_active_turn = false; let mut token_usage_at_turn_start = None; let mut turn_tool_calls = 0_u64; diff --git a/codex-rs/core/src/timers.rs b/codex-rs/core/src/timers.rs index 10aeabb0d3..98f4ecc0da 100644 --- a/codex-rs/core/src/timers.rs +++ b/codex-rs/core/src/timers.rs @@ -6,7 +6,6 @@ use crate::messages::MessageInvocationContext; use crate::messages::MessagePayload; -use crate::messages::message_prompt_input_item; use crate::messages::validate_meta; use crate::timer_trigger::TimerTrigger; use crate::timer_trigger::TriggerTiming; @@ -15,7 +14,6 @@ use crate::timer_trigger::normalize_schedule_dtstart_input; use crate::timer_trigger::timing_for_new_trigger; use crate::timer_trigger::timing_for_restored_trigger; use chrono::Utc; -use codex_protocol::models::ResponseInputItem; use serde::Deserialize; use serde::Serialize; use std::collections::BTreeMap; @@ -462,15 +460,23 @@ pub fn build_thread_timer_create_params( }) } -pub(crate) fn timer_prompt_input_item(timer: &TimerInvocationContext) -> ResponseInputItem { - let instructions = timer_message_instructions(timer); - message_prompt_input_item(&MessageInvocationContext { +#[cfg(test)] +pub(crate) fn timer_prompt_input_item( + timer: &TimerInvocationContext, +) -> codex_protocol::models::ResponseInputItem { + crate::messages::message_prompt_input_item(&timer_message_invocation_context(timer)) +} + +pub(crate) fn timer_message_invocation_context( + timer: &TimerInvocationContext, +) -> MessageInvocationContext { + MessageInvocationContext { source: format!("timer {}", timer.current_timer_id), content: timer_message_content(timer), - instructions, + instructions: timer_message_instructions(timer), meta: timer.meta.clone(), queued_at: timer.queued_at, - }) + } } fn timer_message_content(timer: &TimerInvocationContext) -> String { diff --git a/codex-rs/mcp-server/src/codex_tool_runner.rs b/codex-rs/mcp-server/src/codex_tool_runner.rs index 91fcc8a278..2a405bc8a6 100644 --- a/codex-rs/mcp-server/src/codex_tool_runner.rs +++ b/codex-rs/mcp-server/src/codex_tool_runner.rs @@ -355,6 +355,7 @@ async fn run_codex_tool_session_inner( | EventMsg::PlanUpdate(_) | EventMsg::TurnAborted(_) | EventMsg::UserMessage(_) + | EventMsg::InjectedMessage(_) | EventMsg::ShutdownComplete | EventMsg::ViewImageToolCall(_) | EventMsg::ImageGenerationBegin(_) diff --git a/codex-rs/protocol/src/protocol.rs b/codex-rs/protocol/src/protocol.rs index 65d6dab04c..e7d6c4e753 100644 --- a/codex-rs/protocol/src/protocol.rs +++ b/codex-rs/protocol/src/protocol.rs @@ -1412,6 +1412,9 @@ pub enum EventMsg { /// User/system input message (what was sent to the model) UserMessage(UserMessageEvent), + /// Transcript-safe display text for a runtime-injected message. + InjectedMessage(InjectedMessageEvent), + /// Agent text output delta message AgentMessageDelta(AgentMessageDeltaEvent), @@ -2283,6 +2286,12 @@ pub struct UserMessageEvent { pub text_elements: Vec, } +#[derive(Debug, Clone, Deserialize, Serialize, JsonSchema, TS, PartialEq, Eq)] +pub struct InjectedMessageEvent { + pub content: String, + pub source: String, +} + #[derive(Debug, Clone, Deserialize, Serialize, JsonSchema, TS)] pub struct AgentMessageDeltaEvent { pub delta: String, diff --git a/codex-rs/rollout/src/policy.rs b/codex-rs/rollout/src/policy.rs index 4b50781e76..99269f76f9 100644 --- a/codex-rs/rollout/src/policy.rs +++ b/codex-rs/rollout/src/policy.rs @@ -93,6 +93,7 @@ fn should_persist_event_msg_extended(ev: &EventMsg) -> bool { fn event_msg_persistence_mode(ev: &EventMsg) -> Option { match ev { EventMsg::UserMessage(_) + | EventMsg::InjectedMessage(_) | EventMsg::AgentMessage(_) | EventMsg::AgentReasoning(_) | EventMsg::AgentReasoningRawContent(_) diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs index cc8a60a67a..bcd3ef301e 100644 --- a/codex-rs/tui/src/chatwidget.rs +++ b/codex-rs/tui/src/chatwidget.rs @@ -80,10 +80,6 @@ use crate::terminal_title::SetTerminalTitleResult; use crate::terminal_title::clear_terminal_title; use crate::terminal_title::set_terminal_title; use crate::text_formatting::proper_join; -use crate::user_message_display::UserMessageDisplay; -use crate::user_message_display::UserMessageDisplayOptions; -use crate::user_message_display::classify_user_message; -use crate::user_message_display::user_message_history_text; use crate::version::CODEX_CLI_VERSION; use codex_app_server_protocol::AppSummary; use codex_app_server_protocol::CodexErrorInfo as AppServerCodexErrorInfo; @@ -5539,20 +5535,19 @@ impl ChatWidget { // Show replayable user content in conversation history. if render_in_history && !text.is_empty() { - let history_text = user_message_history_text(&text).unwrap_or_else(|| text.clone()); let local_image_paths = local_images .into_iter() .map(|img| img.path) .collect::>(); self.last_rendered_user_message_event = Some(Self::rendered_user_message_event_from_parts( - text, + text.clone(), text_elements.clone(), local_image_paths.clone(), remote_image_urls.clone(), )); self.add_to_history(history_cell::new_user_prompt( - history_text, + text, text_elements, local_image_paths, remote_image_urls, @@ -6746,6 +6741,17 @@ impl ChatWidget { self.on_user_message_event(ev); } } + EventMsg::InjectedMessage(ev) => { + if !ev.content.trim().is_empty() { + self.add_to_history(history_cell::new_user_prompt( + ev.content, + Vec::new(), + Vec::new(), + Vec::new(), + )); + self.needs_final_message_separator = false; + } + } EventMsg::EnteredReviewMode(review_request) => { self.on_entered_review_mode(review_request, from_replay) } @@ -6943,32 +6949,16 @@ impl ChatWidget { self.last_rendered_user_message_event = Some(Self::rendered_user_message_event_from_event(&event)); let remote_image_urls = event.images.unwrap_or_default(); - let message_is_empty = event.message.trim().is_empty(); - let allow_timer_info = remote_image_urls.is_empty() - && event.local_images.is_empty() - && event.text_elements.is_empty(); - match classify_user_message( - event.message, - UserMessageDisplayOptions { allow_timer_info }, - ) { - UserMessageDisplay::TimerInfo { prompt, schedule } => { - self.add_info_message(prompt, Some(schedule)); - self.needs_final_message_separator = false; - return; - } - UserMessageDisplay::History(message) => { - if !message_is_empty - || !event.text_elements.is_empty() - || !remote_image_urls.is_empty() - { - self.add_to_history(history_cell::new_user_prompt( - message, - event.text_elements, - event.local_images, - remote_image_urls, - )); - } - } + if !event.message.trim().is_empty() + || !event.text_elements.is_empty() + || !remote_image_urls.is_empty() + { + self.add_to_history(history_cell::new_user_prompt( + event.message, + event.text_elements, + event.local_images, + remote_image_urls, + )); } // User messages reset separator state so the next agent response doesn't add a stray break. diff --git a/codex-rs/tui/src/chatwidget/tests/timers.rs b/codex-rs/tui/src/chatwidget/tests/timers.rs index 1e9ccf4eab..dc5a7365d0 100644 --- a/codex-rs/tui/src/chatwidget/tests/timers.rs +++ b/codex-rs/tui/src/chatwidget/tests/timers.rs @@ -1,32 +1,18 @@ use super::*; use codex_protocol::protocol::EventMsg; +use codex_protocol::protocol::InjectedMessageEvent; use codex_protocol::protocol::UserMessageEvent; use insta::assert_snapshot; #[tokio::test] -async fn codex_message_renders_content_history() { +async fn injected_message_renders_content_history() { let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; chat.handle_codex_event_replay(Event { id: "event-1".to_string(), - msg: EventMsg::UserMessage(UserMessageEvent { - message: " -timer timer-1 -100 - -Give me a random animal name. - - -This one-shot timer has already been removed from the schedule, so you do not need to call delete_timer. -Do not expose scheduler internals unless they matter to the user. - - - -" - .to_string(), - images: None, - local_images: Vec::new(), - text_elements: Vec::new(), + msg: EventMsg::InjectedMessage(InjectedMessageEvent { + content: "Give me a random animal name.".to_string(), + source: "timer timer-1".to_string(), }), }); @@ -35,3 +21,23 @@ Do not expose scheduler internals unless they matter to the user. assert_snapshot!(rendered, @"› Give me a random animal name. "); } + +#[tokio::test] +async fn user_message_xml_renders_literally() { + let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(/*model_override*/ None).await; + + chat.handle_codex_event_replay(Event { + id: "event-1".to_string(), + msg: EventMsg::UserMessage(UserMessageEvent { + message: "not hidden".to_string(), + images: None, + local_images: Vec::new(), + text_elements: Vec::new(), + }), + }); + + let cells = drain_insert_history(&mut rx); + let rendered = lines_to_single_string(&cells[0]); + assert_snapshot!(rendered, @"› not hidden +"); +} diff --git a/codex-rs/tui/src/lib.rs b/codex-rs/tui/src/lib.rs index ce84f49d14..1e3b58452b 100644 --- a/codex-rs/tui/src/lib.rs +++ b/codex-rs/tui/src/lib.rs @@ -161,7 +161,6 @@ pub(crate) mod update_action; pub use update_action::UpdateAction; mod update_prompt; mod updates; -mod user_message_display; mod version; #[cfg(not(target_os = "linux"))] mod voice; diff --git a/codex-rs/tui/src/user_message_display.rs b/codex-rs/tui/src/user_message_display.rs deleted file mode 100644 index 3dcfaad419..0000000000 --- a/codex-rs/tui/src/user_message_display.rs +++ /dev/null @@ -1,200 +0,0 @@ -//! Display handling for user-message payloads that carry hidden control data. -//! -//! Core can deliver user-message events whose model-visible text includes -//! machine-readable wrappers. The TUI keeps those wrappers out of the transcript -//! by translating them into either visible user content or a compact status -//! message. - -#[derive(Debug, Clone, PartialEq, Eq)] -pub(crate) enum UserMessageDisplay { - History(String), - TimerInfo { prompt: String, schedule: String }, -} - -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub(crate) struct UserMessageDisplayOptions { - pub(crate) allow_timer_info: bool, -} - -pub(crate) fn classify_user_message( - message: String, - options: UserMessageDisplayOptions, -) -> UserMessageDisplay { - if options.allow_timer_info - && let Some(timer) = parse_timer_fired_user_message(&message) - { - return UserMessageDisplay::TimerInfo { - schedule: timer.schedule(), - prompt: timer.prompt, - }; - } - - UserMessageDisplay::History(user_message_history_text(&message).unwrap_or(message)) -} - -pub(crate) fn user_message_history_text(message: &str) -> Option { - parse_codex_message_content(message).or_else(|| parse_synthetic_user_message_display(message)) -} - -#[derive(Debug, Clone, PartialEq, Eq)] -struct TimerFiredUserMessage { - prompt: String, - trigger: Option, - delivery: Option, - recurring: bool, -} - -impl TimerFiredUserMessage { - fn schedule(&self) -> String { - let mut parts = vec!["Running thread timer".to_string()]; - if let Some(trigger) = self - .trigger - .as_deref() - .filter(|trigger| !trigger.is_empty()) - { - parts.push(trigger.to_string()); - } - if !self.recurring { - parts.push("one-shot".to_string()); - } - if let Some(delivery) = self - .delivery - .as_deref() - .filter(|delivery| !delivery.is_empty()) - { - parts.push(delivery.to_string()); - } - parts.join(" • ") - } -} - -fn parse_codex_message_content(message: &str) -> Option { - let trimmed = message.trim(); - if !trimmed.starts_with("") || !trimmed.ends_with("") { - return None; - } - - let content = extract_xml_tag(trimmed, "content")?; - let content = xml_unescape(content.trim_matches('\n')); - (!content.is_empty()).then_some(content) -} - -fn parse_timer_fired_user_message(message: &str) -> Option { - let trimmed = message.trim(); - if !trimmed.starts_with("") || !trimmed.ends_with("") { - return None; - } - - let prompt = extract_xml_tag(trimmed, "prompt") - .unwrap_or_default() - .trim_matches('\n') - .to_string(); - let trigger = extract_xml_tag(trimmed, "trigger").map(|text| text.trim().to_string()); - let delivery = extract_xml_tag(trimmed, "delivery").map(|text| text.trim().to_string()); - let recurring = extract_xml_tag(trimmed, "recurring") - .as_deref() - .map(str::trim) - == Some("true"); - - Some(TimerFiredUserMessage { - prompt, - trigger, - delivery, - recurring, - }) -} - -fn parse_synthetic_user_message_display(message: &str) -> Option { - let trimmed = message.trim(); - if !trimmed.starts_with("") - || !trimmed.ends_with("") - { - return None; - } - - let display = extract_xml_tag(trimmed, "display")?; - let display = xml_unescape(display.trim()); - (!display.is_empty()).then_some(display) -} - -fn extract_xml_tag(message: &str, tag: &str) -> Option { - let open = format!("<{tag}>"); - let close = format!(""); - let after_open = message.split_once(&open)?.1; - let value = after_open.split_once(&close)?.0; - Some(value.to_string()) -} - -fn xml_unescape(text: &str) -> String { - text.replace("<", "<") - .replace(">", ">") - .replace(""", "\"") - .replace("&", "&") -} - -#[cfg(test)] -mod tests { - use super::*; - use pretty_assertions::assert_eq; - - #[test] - fn codex_message_history_text_uses_content_only() { - assert_eq!( - user_message_history_text( - " -timer timer-1 -100 - -Run <tests>. - - -Hidden - - -" - ), - Some("Run .".to_string()) - ); - } - - #[test] - fn synthetic_message_history_text_uses_display_only() { - assert_eq!( - user_message_history_text( - "/review srchidden" - ), - Some("/review src".to_string()) - ); - } - - #[test] - fn timer_fired_can_render_as_info_message() { - assert_eq!( - classify_user_message( - "Run testsevery minuteafter-turntrue" - .to_string(), - UserMessageDisplayOptions { - allow_timer_info: true - }, - ), - UserMessageDisplay::TimerInfo { - prompt: "Run tests".to_string(), - schedule: "Running thread timer • every minute • after-turn".to_string(), - } - ); - } - - #[test] - fn timer_fired_can_remain_history_text_when_info_is_not_allowed() { - let message = "Run tests".to_string(); - assert_eq!( - classify_user_message( - message.clone(), - UserMessageDisplayOptions { - allow_timer_info: false - }, - ), - UserMessageDisplay::History(message) - ); - } -}