From e9f19e9196fe4fc7428050f1b2d6f900d6d2c9f8 Mon Sep 17 00:00:00 2001 From: Eric Traut Date: Sat, 2 May 2026 09:30:56 -0700 Subject: [PATCH] Materialize goal-started threads for resume --- .../app-server/src/codex_message_processor.rs | 2 + .../thread_goal_handlers.rs | 59 ++++++++++++++ .../app-server/tests/suite/v2/thread_list.rs | 77 +++++++++++++++++++ 3 files changed, 138 insertions(+) diff --git a/codex-rs/app-server/src/codex_message_processor.rs b/codex-rs/app-server/src/codex_message_processor.rs index 1767b6372a..5bb7b40ff5 100644 --- a/codex-rs/app-server/src/codex_message_processor.rs +++ b/codex-rs/app-server/src/codex_message_processor.rs @@ -365,6 +365,7 @@ use codex_protocol::protocol::SessionConfiguredEvent; use codex_protocol::protocol::SessionMetaLine; use codex_protocol::protocol::TurnEnvironmentSelection; use codex_protocol::protocol::USER_MESSAGE_BEGIN; +use codex_protocol::protocol::UserMessageEvent; use codex_protocol::protocol::W3cTraceContext; use codex_protocol::user_input::MAX_USER_INPUT_TEXT_CHARS; use codex_protocol::user_input::UserInput as CoreInputItem; @@ -376,6 +377,7 @@ use codex_state::StateRuntime; use codex_state::ThreadMetadata; use codex_state::ThreadMetadataBuilder; use codex_state::log_db::LogDbLayer; +use codex_thread_store::AppendThreadItemsParams as StoreAppendThreadItemsParams; use codex_thread_store::ArchiveThreadParams as StoreArchiveThreadParams; use codex_thread_store::ListThreadsParams as StoreListThreadsParams; use codex_thread_store::LocalThreadStore; diff --git a/codex-rs/app-server/src/codex_message_processor/thread_goal_handlers.rs b/codex-rs/app-server/src/codex_message_processor/thread_goal_handlers.rs index 5359f26836..2e2880393e 100644 --- a/codex-rs/app-server/src/codex_message_processor/thread_goal_handlers.rs +++ b/codex-rs/app-server/src/codex_message_processor/thread_goal_handlers.rs @@ -57,6 +57,65 @@ impl CodexMessageProcessor { thread.prepare_external_goal_mutation().await; } + if let Some(objective) = objective + && running_thread.is_some() + { + if let Err(err) = self.thread_store.persist_thread(thread_id).await { + self.send_internal_error( + request_id, + format!("failed to materialize thread before setting goal: {err}"), + ) + .await; + return; + } + + let first_user_message = match state_db.get_thread(thread_id).await { + Ok(metadata) => metadata.and_then(|metadata| metadata.first_user_message), + Err(err) => { + self.send_internal_error( + request_id, + format!("failed to read thread metadata before setting goal: {err}"), + ) + .await; + return; + } + }; + if first_user_message + .as_deref() + .is_none_or(|message| message.trim().is_empty()) + { + let item = RolloutItem::EventMsg(EventMsg::UserMessage(UserMessageEvent { + message: format!("/goal {objective}"), + images: None, + local_images: Vec::new(), + text_elements: Vec::new(), + })); + if let Err(err) = self + .thread_store + .append_items(StoreAppendThreadItemsParams { + thread_id, + items: vec![item], + }) + .await + { + self.send_internal_error( + request_id, + format!("failed to seed goal-started thread preview: {err}"), + ) + .await; + return; + } + if let Err(err) = self.thread_store.flush_thread(thread_id).await { + self.send_internal_error( + request_id, + format!("failed to flush goal-started thread preview: {err}"), + ) + .await; + return; + } + } + } + let goal = (if let Some(objective) = objective { let existing_goal = state_db .get_thread_goal(thread_id) diff --git a/codex-rs/app-server/tests/suite/v2/thread_list.rs b/codex-rs/app-server/tests/suite/v2/thread_list.rs index 615692d70d..f2c17caca9 100644 --- a/codex-rs/app-server/tests/suite/v2/thread_list.rs +++ b/codex-rs/app-server/tests/suite/v2/thread_list.rs @@ -3,6 +3,7 @@ use app_test_support::McpProcess; use app_test_support::create_fake_rollout; use app_test_support::create_fake_rollout_with_source; use app_test_support::create_final_assistant_message_sse_response; +use app_test_support::create_mock_responses_server_repeating_assistant; use app_test_support::create_mock_responses_server_sequence; use app_test_support::rollout_path; use app_test_support::test_absolute_path; @@ -15,6 +16,7 @@ use codex_app_server_protocol::JSONRPCResponse; use codex_app_server_protocol::RequestId; use codex_app_server_protocol::SessionSource; use codex_app_server_protocol::SortDirection; +use codex_app_server_protocol::ThreadGoalSetResponse; use codex_app_server_protocol::ThreadListCwdFilter; use codex_app_server_protocol::ThreadListResponse; use codex_app_server_protocol::ThreadSortKey; @@ -35,6 +37,7 @@ use codex_protocol::protocol::SessionSource as CoreSessionSource; use codex_protocol::protocol::SubAgentSource; use core_test_support::responses; use pretty_assertions::assert_eq; +use serde_json::json; use std::cmp::Reverse; use std::fs; use std::fs::FileTimes; @@ -198,6 +201,80 @@ async fn thread_list_basic_empty() -> Result<()> { Ok(()) } +#[tokio::test] +async fn thread_list_includes_thread_started_with_goal() -> Result<()> { + let server = create_mock_responses_server_repeating_assistant("Done").await; + let codex_home = TempDir::new()?; + create_runtime_config(codex_home.path(), &server.uri())?; + let config_path = codex_home.path().join("config.toml"); + let config = std::fs::read_to_string(&config_path)?; + std::fs::write( + &config_path, + config.replace( + "[model_providers.mock_provider]", + "[features]\ngoals = true\n\n[model_providers.mock_provider]", + ), + )?; + + let mut mcp = init_mcp(codex_home.path()).await?; + let start_id = mcp + .send_thread_start_request(ThreadStartParams { + model: Some("mock-model".to_string()), + ..Default::default() + }) + .await?; + let start_resp: JSONRPCResponse = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_response_message(RequestId::Integer(start_id)), + ) + .await??; + let ThreadStartResponse { thread, .. } = to_response::(start_resp)?; + assert!( + !thread.path.as_ref().expect("thread path").exists(), + "fresh thread should still be lazily materialized" + ); + + let objective = "improve benchmark coverage"; + let goal_id = mcp + .send_raw_request( + "thread/goal/set", + Some(json!({ + "threadId": thread.id.clone(), + "objective": objective, + "status": "active", + })), + ) + .await?; + let goal_resp: JSONRPCResponse = timeout( + DEFAULT_READ_TIMEOUT, + mcp.read_stream_until_response_message(RequestId::Integer(goal_id)), + ) + .await??; + let _: ThreadGoalSetResponse = to_response(goal_resp)?; + + let ThreadListResponse { data, .. } = list_threads( + &mut mcp, + /*cursor*/ None, + Some(10), + Some(vec!["mock_provider".to_string()]), + /*source_kinds*/ None, + /*archived*/ None, + ) + .await?; + + let listed = data + .iter() + .find(|candidate| candidate.id == thread.id) + .expect("goal-started thread should be listed for resume"); + assert_eq!(listed.preview, format!("/goal {objective}")); + assert!( + listed.path.as_ref().expect("listed thread path").exists(), + "setting the first goal should materialize the rollout" + ); + + Ok(()) +} + #[tokio::test] async fn thread_list_reports_system_error_idle_flag_after_failed_turn() -> Result<()> { let responses = vec![