Lightweight coding agent that runs in your terminal
Rust
Add cancellation for experimental thread samples (#55441)
liame-oaia4c9194247c6
diff --git a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zstindex bd8074d4bf..f19d6ffdcc 100644Binary files a/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst and b/codex-rs/app-server-protocol/schema/precomputed/app-server-exports-experimental.json.zst differdiff --git a/codex-rs/app-server-protocol/src/protocol/common.rs b/codex-rs/app-server-protocol/src/protocol/common.rsindex 509958c2ed..541af12881 100644--- a/codex-rs/app-server-protocol/src/protocol/common.rs+++ b/codex-rs/app-server-protocol/src/protocol/common.rs@@ -574,6 +574,12 @@ client_request_definitions! {serialization: None,response: v2::ThreadSampleResponse,},+ #[experimental("thread/sample/cancel")]+ ThreadSampleCancel => "thread/sample/cancel" {+ params: v2::ThreadSampleCancelParams,+ serialization: None,+ response: v2::ThreadSampleCancelResponse,+ },ThreadArchive => "thread/archive" {params: v2::ThreadArchiveParams,serialization: thread_id(params.thread_id),diff --git a/codex-rs/app-server-protocol/src/protocol/v2/thread_sample.rs b/codex-rs/app-server-protocol/src/protocol/v2/thread_sample.rsindex 08c7420105..bbdaac3ab5 100644--- a/codex-rs/app-server-protocol/src/protocol/v2/thread_sample.rs+++ b/codex-rs/app-server-protocol/src/protocol/v2/thread_sample.rs@@ -1,6 +1,7 @@//! One model response on an ephemeral fork that inherits the source's configuration and context.use crate::JsonSchema;+use crate::RequestId;use crate::TS;use codex_protocol::openai_models::ReasoningEffort;use serde::Deserialize;@@ -33,3 +34,15 @@ pub struct ThreadSampleResponse {pub cached_input_tokens: Option<i64>,pub output_tokens: Option<i64>,}++#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, JsonSchema, TS)]+#[serde(rename_all = "camelCase", deny_unknown_fields)]+#[ts(export_to = "v2/")]+pub struct ThreadSampleCancelParams {+ pub request_id: RequestId,+}++#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq, Eq, JsonSchema, TS)]+#[serde(rename_all = "camelCase")]+#[ts(export_to = "v2/")]+pub struct ThreadSampleCancelResponse {}diff --git a/codex-rs/app-server/src/message_processor.rs b/codex-rs/app-server/src/message_processor.rsindex 58b5a6ce5b..54f81d1600 100644--- a/codex-rs/app-server/src/message_processor.rs+++ b/codex-rs/app-server/src/message_processor.rs@@ -72,6 +72,7 @@ use codex_app_server_protocol::JSONRPCErrorError;use codex_app_server_protocol::JSONRPCNotification;use codex_app_server_protocol::JSONRPCRequest;use codex_app_server_protocol::JSONRPCResponse;+use codex_app_server_protocol::ThreadSampleCancelResponse;use codex_app_server_protocol::UserVerificationCancelResponse;use codex_app_server_protocol::experimental_required_message;use codex_arg0::Arg0DispatchPaths;@@ -1344,6 +1345,15 @@ impl MessageProcessor {.thread_sample(params, Arc::clone(&session.rpc_gate), request_context).await.map(|response| Some(response.into())),+ ClientRequest::ThreadSampleCancel { params, .. } => {+ self.outgoing+ .cancel_thread_sample_request(&ConnectionRequestId {+ connection_id,+ request_id: params.request_id,+ })+ .await;+ Ok(Some(ThreadSampleCancelResponse {}.into()))+ }ClientRequest::ThreadArchive { params, .. } => {self.thread_processor.thread_archive(request_id.clone(), params)diff --git a/codex-rs/app-server/src/outgoing_message.rs b/codex-rs/app-server/src/outgoing_message.rsindex 9ed210ebd3..647481cb3c 100644--- a/codex-rs/app-server/src/outgoing_message.rs+++ b/codex-rs/app-server/src/outgoing_message.rs@@ -75,6 +75,7 @@ pub(crate) struct RequestContext {enum RequestCancellationScope {Unavailable,UserVerification,+ ThreadSample,}impl RequestContext {@@ -92,6 +93,7 @@ impl RequestContext {| "userVerification/enroll"| "userVerification/delete"| "userVerification/verify" => RequestCancellationScope::UserVerification,+ "thread/sample" => RequestCancellationScope::ThreadSample,_ => RequestCancellationScope::Unavailable,},span,@@ -278,6 +280,15 @@ impl OutgoingMessageSender {}}+ pub(crate) async fn cancel_thread_sample_request(&self, request_id: &ConnectionRequestId) {+ let contexts = self.request_contexts.lock().await;+ if let Some(context) = contexts.get(request_id)+ && context.cancellation_scope == RequestCancellationScope::ThreadSample+ {+ context.cancellation.cancel();+ }+ }+pub(crate) async fn connection_closed(&self, connection_id: ConnectionId) {self.disconnect_user_verification_connection(connection_id).await;@@ -908,6 +919,10 @@ fn timestamped_server_notification(notification: ServerNotification) -> Outgoing})}+#[cfg(test)]+#[path = "thread_sample_cancel_context_tests.rs"]+mod thread_sample_cancel_context_tests;+#[cfg(test)]#[path = "user_verification_ownership_tests.rs"]mod user_verification_ownership_tests;diff --git a/codex-rs/app-server/src/request_processors/thread_processor.rs b/codex-rs/app-server/src/request_processors/thread_processor.rsindex af2abeb21b..1b73520af4 100644--- a/codex-rs/app-server/src/request_processors/thread_processor.rs+++ b/codex-rs/app-server/src/request_processors/thread_processor.rs@@ -637,6 +637,7 @@ impl ThreadRequestProcessor {samples: Arc::clone(&self.sample_responses),params,trace: context.request_trace(),+ cancellation: context.cancellation,},&self.background_tasks,rpc_gate,diff --git a/codex-rs/app-server/src/thread_sample.rs b/codex-rs/app-server/src/thread_sample.rsindex 7589343d48..edf7b0d1c9 100644--- a/codex-rs/app-server/src/thread_sample.rs+++ b/codex-rs/app-server/src/thread_sample.rs@@ -49,6 +49,7 @@ use std::sync::Mutex;use std::time::Duration;use tokio::sync::oneshot;use tokio::time::Instant;+use tokio_util::sync::CancellationToken;use tokio_util::task::TaskTracker;const SAMPLE_TIMEOUT: Duration = Duration::from_secs(30);@@ -68,6 +69,7 @@ pub(crate) struct SampleTask {pub(crate) samples: Arc<SampleResponseRegistry>,pub(crate) params: ThreadSampleParams,pub(crate) trace: Option<W3cTraceContext>,+ pub(crate) cancellation: CancellationToken,}pub(crate) async fn generate_sample(@@ -109,6 +111,7 @@ impl SampleTask {samples,params,trace,+ cancellation,} = self;let id = parent.startup_metadata().thread_id;if parent.agent_status().await == AgentStatus::Running {@@ -195,6 +198,9 @@ impl SampleTask {options.session_source = Some(SessionSource::Custom("thread_sample".to_string()));options.thread_source = Some(ThreadSource::Feature("thread_sample".to_string()));options.parent_trace = trace.clone();+ if cancellation.is_cancelled() {+ return Err(internal_error("sample canceled"));+ }if Instant::now() >= deadline {return Err(internal_error("sample timed out"));}@@ -280,6 +286,7 @@ impl SampleTask {};let result = tokio::select! {biased;+ _ = cancellation.cancelled() => Err(internal_error("sample canceled")),_ = tokio::time::sleep_until(deadline) => Err(internal_error("sample timed out")),result = sample => result,};diff --git a/codex-rs/app-server/src/thread_sample_cancel_context_tests.rs b/codex-rs/app-server/src/thread_sample_cancel_context_tests.rsnew file mode 100644index 0000000000..c757acf5c4--- /dev/null+++ b/codex-rs/app-server/src/thread_sample_cancel_context_tests.rs@@ -0,0 +1,56 @@+//! Checks that sample cancellation only affects matching requests on the same connection.++use super::*;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn thread_sample_cancel_only_signals_matching_request_contexts() {+ let (tx, _rx) = mpsc::channel(/*buffer*/ 1);+ let outgoing = OutgoingMessageSender::new(tx, AnalyticsEventsClient::disabled());+ for method in [+ "thread/sample",+ "thread/sample/cancel",+ "userVerification/status",+ "userVerification/enroll",+ "userVerification/delete",+ "userVerification/verify",+ "userVerification/cancel",+ "turn/start",+ ] {+ let target = ConnectionRequestId {+ connection_id: ConnectionId(1),+ request_id: RequestId::Integer(7),+ };+ let context = RequestContext::new(+ target.clone(),+ method,+ Span::none(),+ /*parent_trace*/ None,+ );+ let cancellation = context.cancellation.clone();+ outgoing.register_request_context(context).await;+ for wrong_target in [+ ConnectionRequestId {+ connection_id: ConnectionId(2),+ request_id: RequestId::Integer(7),+ },+ ConnectionRequestId {+ connection_id: ConnectionId(1),+ request_id: RequestId::String("7".into()),+ },+ ConnectionRequestId {+ connection_id: ConnectionId(1),+ request_id: RequestId::Integer(8),+ },+ ] {+ outgoing.cancel_thread_sample_request(&wrong_target).await;+ assert!(!cancellation.is_cancelled());+ }+ outgoing.cancel_thread_sample_request(&target).await;+ outgoing.cancel_thread_sample_request(&target).await;+ assert_eq!(cancellation.is_cancelled(), method == "thread/sample");+ assert_eq!(outgoing.request_context_count().await, 1);+ outgoing.connection_closed(ConnectionId(1)).await;+ assert_eq!(outgoing.request_context_count().await, 0);+ }+}diff --git a/codex-rs/app-server/tests/suite/v2/thread_sample.rs b/codex-rs/app-server/tests/suite/v2/thread_sample.rsindex c32b01d420..e90988c7e9 100644--- a/codex-rs/app-server/tests/suite/v2/thread_sample.rs+++ b/codex-rs/app-server/tests/suite/v2/thread_sample.rs@@ -12,6 +12,7 @@ use codex_app_server_protocol::ThreadForkParams;use codex_app_server_protocol::ThreadForkResponse;use codex_app_server_protocol::ThreadHistoryMode;use codex_app_server_protocol::ThreadLoadedListResponse;+use codex_app_server_protocol::ThreadSampleCancelResponse;use codex_app_server_protocol::ThreadSampleParams;use codex_app_server_protocol::ThreadSampleResponse;use codex_app_server_protocol::ThreadStartParams;@@ -732,8 +733,15 @@ async fn sample_does_not_hide_stream_errors_after_tool_calls() -> Result<()> {Ok(())}+enum SampleStop {+ Timeout,+ Cancel,+}++#[test_case(SampleStop::Timeout; "timeout")]+#[test_case(SampleStop::Cancel; "cancel")]#[tokio::test]-async fn sample_wait_keeps_parent_responsive_and_timeout_reclaims_child() -> Result<()> {+async fn sample_wait_keeps_parent_responsive_and_reclaims_child(stop: SampleStop) -> Result<()> {let server = responses::start_mock_server().await;responses::mount_sse_once(&server,@@ -781,16 +789,40 @@ async fn sample_wait_keeps_parent_responsive_and_timeout_reclaims_child() -> Res}),).await??;+ let (expected_error, wait) = match stop {+ SampleStop::Timeout => ("sample timed out", WAIT),+ SampleStop::Cancel => {+ let cancel_id = client+ .send_raw_request(+ "thread/sample/cancel",+ Some(json!({"requestId": sample_id})),+ )+ .await?;+ let response: ThreadSampleCancelResponse =+ timeout(Duration::from_secs(10), client.read_response(cancel_id)).await??;+ assert_eq!(response, ThreadSampleCancelResponse {});+ ("sample canceled", Duration::from_secs(10))+ }+ };let error = timeout(- WAIT,+ wait,client.read_stream_until_error_message(RequestId::Integer(sample_id)),).await??;- assert!(- error.error.message.contains("timed out"),- "{}",- error.error.message- );+ assert_eq!(error.error.message, expected_error);+ if matches!(stop, SampleStop::Cancel) {+ for request_id in [json!(sample_id), json!("unknown")] {+ let cancel_id = client+ .send_raw_request(+ "thread/sample/cancel",+ Some(json!({"requestId": request_id})),+ )+ .await?;+ let response: ThreadSampleCancelResponse =+ timeout(Duration::from_secs(10), client.read_response(cancel_id)).await??;+ assert_eq!(response, ThreadSampleCancelResponse {});+ }+ }assert_eq!(mock.requests().len(), 1);timeout(WAIT, async {loop {