diff --git a/codex-rs/core/src/client.rs b/codex-rs/core/src/client.rs index 439d47de56..cf4376f659 100644 --- a/codex-rs/core/src/client.rs +++ b/codex-rs/core/src/client.rs @@ -33,9 +33,12 @@ use std::sync::OnceLock; use std::sync::atomic::AtomicBool; use std::sync::atomic::Ordering; +mod response_delivery; #[path = "client_tool_metadata.rs"] mod tool_metadata; +use response_delivery::ResponseDelivery; + use crate::CodexResponsesHeaders; use crate::PromptCacheKey; use crate::tools::ExecutedToolCalls; @@ -132,6 +135,7 @@ use crate::cyber_access_program; use crate::feedback_tags; use crate::responses_metadata::CodexResponsesMetadata; use crate::responses_metadata::subagent_header_value; +use crate::session::turn_context::TurnContext; use crate::util::emit_feedback_auth_recovery_tags; use codex_feedback::FeedbackRequestTags; use codex_feedback::emit_feedback_request_tags_with_auth_env; @@ -552,8 +556,16 @@ impl WebsocketSession { } } +/// Generation settings shared by HTTP and WebSocket, including transport fallback. +#[derive(Clone)] +pub(crate) struct SamplingOptions { + pub(crate) reasoning_effort: Option, + pub(crate) reasoning_summary: ReasoningSummaryConfig, + pub(crate) service_tier: Option, +} + enum WebsocketStreamOutcome { - Stream(ResponseStream), + Stream(Box), FallbackToHttp, } @@ -1978,12 +1990,10 @@ impl ResponsesHttpExecutor<'_> { prompt: &Arc, model_info: &ModelInfo, session_telemetry: &SessionTelemetry, - effort: Option, - summary: ReasoningSummaryConfig, - service_tier: Option, + sampling: SamplingOptions, responses_metadata: &CodexResponsesMetadata, inference_trace: &InferenceTraceContext, - ) -> Result { + ) -> Result { let auth_manager = self.client.state.provider.auth_manager(); let mut auth_recovery = auth_manager .as_ref() @@ -2036,9 +2046,9 @@ impl ResponsesHttpExecutor<'_> { let mut request = self.client.build_responses_request( prompt, model_info, - effort.clone(), - summary, - service_tier.clone(), + sampling.reasoning_effort.clone(), + sampling.reasoning_summary, + sampling.service_tier.clone(), responses_metadata, include_internal, )?; @@ -2121,14 +2131,14 @@ impl ResponsesHttpExecutor<'_> { match stream_result { Ok(stream) => { - return Ok(map_response_stream( + return Ok(OpenedModelResponse { stream, - request_session_telemetry, - inference_trace_attempt, - &self.client.state, + telemetry: request_session_telemetry, + trace: inference_trace_attempt, + client: Arc::clone(&self.client.state), interceptors, - /*last_response_tx*/ None, - )); + continuation: None, + }); } Err(ApiError::Transport(unauthorized_transport)) if self @@ -2195,9 +2205,7 @@ impl ModelClientSession { prompt: &Arc, model_info: &ModelInfo, session_telemetry: &SessionTelemetry, - effort: Option, - summary: ReasoningSummaryConfig, - service_tier: Option, + sampling: SamplingOptions, responses_metadata: &CodexResponsesMetadata, warmup: bool, request_trace: Option, @@ -2244,9 +2252,9 @@ impl ModelClientSession { let mut request = self.client.build_responses_request( prompt, model_info, - effort.clone(), - summary, - service_tier.clone(), + sampling.reasoning_effort.clone(), + sampling.reasoning_summary, + sampling.service_tier.clone(), responses_metadata, include_internal, )?; @@ -2509,16 +2517,16 @@ impl ModelClientSession { err })?; let (last_response_tx, last_response_rx) = oneshot::channel(); - let stream = map_response_stream( - stream_result, - request_session_telemetry, - inference_trace_attempt, - &self.client.state, + let stream = OpenedModelResponse { + stream: stream_result, + telemetry: request_session_telemetry, + trace: inference_trace_attempt, + client: Arc::clone(&self.client.state), interceptors, - Some(last_response_tx), - ); + continuation: Some(last_response_tx), + }; self.websocket_session.last_response_rx = Some(last_response_rx); - return Ok(WebsocketStreamOutcome::Stream(stream)); + return Ok(WebsocketStreamOutcome::Stream(Box::new(stream))); } } @@ -2593,9 +2601,11 @@ impl ModelClientSession { prompt, model_info, session_telemetry, - effort, - summary, - service_tier, + SamplingOptions { + reasoning_effort: effort, + reasoning_summary: summary, + service_tier, + }, responses_metadata, /*warmup*/ true, current_span_w3c_trace_context(), @@ -2603,7 +2613,8 @@ impl ModelClientSession { ) .await { - Ok(WebsocketStreamOutcome::Stream(mut stream)) => { + Ok(WebsocketStreamOutcome::Stream(opened)) => { + let mut stream = (*opened).into_stream()?; // Wait for the v2 warmup request to complete before sending the first turn request. while let Some(event) = stream.next().await { match event { @@ -2646,6 +2657,31 @@ impl ModelClientSession { responses_metadata: &CodexResponsesMetadata, inference_trace: &InferenceTraceContext, ) -> Result { + self.open_model_response( + prompt, + model_info, + session_telemetry, + SamplingOptions { + reasoning_effort: effort, + reasoning_summary: summary, + service_tier, + }, + responses_metadata, + inference_trace, + ) + .await? + .into_stream() + } + + pub(crate) async fn open_model_response( + &mut self, + prompt: &Arc, + model_info: &ModelInfo, + session_telemetry: &SessionTelemetry, + sampling: SamplingOptions, + responses_metadata: &CodexResponsesMetadata, + inference_trace: &InferenceTraceContext, + ) -> Result { let wire_api = self.client.state.provider.info().wire_api; match wire_api { WireApi::Responses => { @@ -2656,9 +2692,7 @@ impl ModelClientSession { prompt, model_info, session_telemetry, - effort.clone(), - summary, - service_tier.clone(), + sampling.clone(), responses_metadata, /*warmup*/ false, request_trace, @@ -2666,7 +2700,7 @@ impl ModelClientSession { ) .await? { - WebsocketStreamOutcome::Stream(stream) => return Ok(stream), + WebsocketStreamOutcome::Stream(stream) => return Ok(*stream), WebsocketStreamOutcome::FallbackToHttp => { self.try_switch_fallback_transport(session_telemetry, model_info); } @@ -2681,9 +2715,7 @@ impl ModelClientSession { prompt, model_info, session_telemetry, - effort, - summary, - service_tier, + sampling, responses_metadata, inference_trace, ) @@ -2770,29 +2802,59 @@ fn add_responses_lite_header(headers: &mut ApiHeaderMap, use_responses_lite: boo const RESPONSE_STREAM_CHANNEL_CAPACITY: usize = 1600; const STREAM_DROPPED_REASON: &str = "response stream dropped before provider terminal event"; -fn map_response_stream( - mut api_stream: codex_api::ResponseStream, - session_telemetry: SessionTelemetry, - inference_trace_attempt: InferenceTraceAttempt, - client: &ModelClientState, +/// The transport has opened the provider stream. Its caller now chooses whether +/// a synchronous post-hook must finish before Core can use the response. +pub(crate) struct OpenedModelResponse { + stream: codex_api::ResponseStream, + telemetry: SessionTelemetry, + trace: InferenceTraceAttempt, + client: Arc, interceptors: Vec>, - last_response_tx: Option>, -) -> ResponseStream { - let routing_affinity = api_stream.routing_affinity.take(); - let upstream_request_id = api_stream.upstream_request_id.take(); - let interrupt = api_stream.interrupt.take(); - let events = crate::model_request::intercept_stream(Box::pin(api_stream), interceptors); - let mut stream = map_response_events( - upstream_request_id, - events, - session_telemetry, - inference_trace_attempt, - client, - last_response_tx, - ); - stream.interrupt = interrupt; - stream.routing_affinity = routing_affinity; - stream + continuation: Option>, +} + +impl OpenedModelResponse { + pub(crate) fn into_stream(self) -> Result { + self.deliver(&mut None, /*sampling_turn*/ None) + } + + pub(crate) fn deliver( + mut self, + attempt: &mut Option, + sampling_turn: Option>, + ) -> Result { + let delivery = ResponseDelivery::new(attempt); + let routing_affinity = self.stream.routing_affinity.take(); + let request_id = self.stream.upstream_request_id.take(); + let interrupt = self.stream.interrupt.take(); + // A response interceptor can hold even the first token until completion. Measure + // ordinary turn TTFT on the decoded provider stream, before any such wait. + let provider_stream = if let Some(turn) = sampling_turn { + futures::stream::unfold((self.stream, turn), |(mut stream, turn)| async move { + let event = stream.next().await?; + if let Ok(event) = &event { + crate::turn_timing::record_turn_ttft_metric(&turn, event).await; + } + Some((event, (stream, turn))) + }) + .boxed() + } else { + self.stream.boxed() + }; + let events = crate::model_request::intercept_stream(provider_stream, self.interceptors); + let mut stream = map_response_events( + request_id, + events, + self.telemetry, + self.trace, + &self.client, + self.continuation, + delivery, + ); + stream.interrupt = interrupt; + stream.routing_affinity = routing_affinity; + Ok(stream) + } } fn map_response_events( @@ -2802,6 +2864,7 @@ fn map_response_events( inference_trace_attempt: InferenceTraceAttempt, client: &ModelClientState, mut last_response_tx: Option>, + mut delivery: ResponseDelivery, ) -> ResponseStream where S: futures::Stream> @@ -2843,7 +2906,7 @@ where let Some(event) = event else { break; }; - match event { + let event = match event { Ok(ResponseEvent::OutputItemDone(mut item)) => { // Assign IDs after interceptors, which may replace provider items. // Reuse the added event's ID so tracing and the harness agree. @@ -2858,18 +2921,7 @@ where if collect_output_items { items_added.push(item.clone()); } - if tx_event - .send(Ok(ResponseEvent::OutputItemDone(item))) - .await - .is_err() - { - inference_trace_attempt.record_cancelled( - STREAM_DROPPED_REASON, - upstream_request_id, - &items_added, - ); - return; - } + Ok(ResponseEvent::OutputItemDone(item)) } Ok(ResponseEvent::Completed { response_id, @@ -2895,19 +2947,13 @@ where }); } items_added = Vec::new(); - if tx_event - .send(Ok(ResponseEvent::Completed { - response_id, - token_usage, - usage_metadata, - reasoning_removals, - end_turn, - })) - .await - .is_err() - { - return; - } + Ok(ResponseEvent::Completed { + response_id, + token_usage, + usage_metadata, + reasoning_removals, + end_turn, + }) } Ok(mut event) => { if let ResponseEvent::OutputItemAdded(item) = &mut event { @@ -2921,14 +2967,7 @@ where i64::try_from(request_start.elapsed().as_millis()).unwrap_or(i64::MAX), ); } - if tx_event.send(Ok(event)).await.is_err() { - inference_trace_attempt.record_cancelled( - STREAM_DROPPED_REASON, - upstream_request_id, - &items_added, - ); - return; - } + Ok(event) } Err(err) => { let response_debug_context = @@ -2967,10 +3006,19 @@ where session_telemetry.see_event_completed_failed(&mapped); logged_error = true; } - if tx_event.send(Err(mapped)).await.is_err() { - return; - } + Err(mapped) } + }; + let terminal = matches!(&event, Ok(ResponseEvent::Completed { .. }) | Err(_)); + if !delivery.send_or_hold(event, &tx_event).await { + if !terminal { + inference_trace_attempt.record_cancelled( + STREAM_DROPPED_REASON, + upstream_request_id, + &items_added, + ); + } + return; } } inference_trace_attempt.record_failed( @@ -2978,6 +3026,7 @@ where upstream_request_id, &items_added, ); + delivery.finish_eof(&tx_event).await; }); ResponseStream { diff --git a/codex-rs/core/src/client/response_delivery.rs b/codex-rs/core/src/client/response_delivery.rs new file mode 100644 index 0000000000..eba1afb618 --- /dev/null +++ b/codex-rs/core/src/client/response_delivery.rs @@ -0,0 +1,88 @@ +//! Synchronous post-hooks finish before the turn receives response completion. + +use crate::client_common::ResponseEvent; +use crate::hook_runtime::sampling::SamplingAttempt; +use codex_api::ApiError; +use codex_hooks::ModelRequestHookEvent; +use codex_protocol::error::CodexErr; +use codex_protocol::error::Result; +use tokio::sync::mpsc; + +#[derive(Default)] +pub(super) struct ResponseDelivery { + attempt: Option, +} + +impl ResponseDelivery { + pub(super) fn new(attempt: &mut Option) -> Self { + Self { + attempt: attempt.take(), + } + } + + /// Return false when the turn has stopped receiving this attempt's output. + pub(super) async fn send_or_hold( + &mut self, + event: Result, + tx: &mpsc::Sender>, + ) -> bool { + let Some(attempt) = self.attempt.as_mut() else { + return tx.send(event).await.is_ok(); + }; + let report = match &event { + Ok(ResponseEvent::Completed { + response_id, + token_usage, + .. + }) => ModelRequestHookEvent::completed(response_id, token_usage.as_ref()), + Err(error) => ModelRequestHookEvent::failed(error), + Ok(_) => return tx.send(event).await.is_ok(), + }; + let owner = attempt.owner_cancellation.clone(); + if let Some(hooks) = attempt.start_post_hooks(report) { + tokio::select! { + biased; + () = tx.closed() => return false, + () = owner.cancelled() => return false, + () = hooks => {} + } + // The owner can interrupt before the reader is scheduled to close its channel. + if owner.is_cancelled() { + return false; + } + } + self.attempt = None; + let released = Self::release(event, tx).await; + match released { + Ok(delivered) => delivered, + Err(error) => tx.send(Err(codex_api::map_api_error(error))).await.is_ok(), + } + } + + async fn release( + event: Result, + tx: &mpsc::Sender>, + ) -> std::result::Result { + if tx.is_closed() { + return Ok(false); + } + Ok(tx.send(event).await.is_ok()) + } + + pub(super) async fn finish_eof(&mut self, tx: &mpsc::Sender>) { + let Some(mut attempt) = self.attempt.take() else { + return; + }; + let owner = attempt.owner_cancellation.clone(); + if let Some(hooks) = attempt.start_post_hooks(ModelRequestHookEvent::failed( + &CodexErr::Stream("stream closed before response.completed".into()), + )) { + tokio::select! { + biased; + () = tx.closed() => {} + () = owner.cancelled() => {} + () = hooks => {} + } + } + } +} diff --git a/codex-rs/core/src/client_common.rs b/codex-rs/core/src/client_common.rs index 6f2fbe5b64..b42c321d99 100644 --- a/codex-rs/core/src/client_common.rs +++ b/codex-rs/core/src/client_common.rs @@ -1,4 +1,5 @@ pub use codex_api::ResponseEvent; +use codex_protocol::error::CodexErr; use codex_protocol::error::Result; use codex_protocol::models::BaseInstructions; use codex_protocol::models::ContentItem; @@ -129,6 +130,32 @@ pub struct ResponseStream { pub(crate) consumer_dropped: CancellationToken, } +impl ResponseStream { + /// A cancelled turn discards any queued event, including an incomplete response's usage. + pub(crate) fn accept_for_turn( + event: Option>, + cancellation: &CancellationToken, + ) -> Option> { + if cancellation.is_cancelled() { + Some(Err(CodexErr::TurnAborted)) + } else { + event + } + } + + pub(crate) async fn next_for_turn( + &mut self, + cancellation: &CancellationToken, + ) -> Option> { + let event = tokio::select! { + biased; + event = self.rx_event.recv() => event, + () = cancellation.cancelled() => return Some(Err(CodexErr::TurnAborted)), + }; + Self::accept_for_turn(event, cancellation) + } +} + impl Stream for ResponseStream { type Item = Result; diff --git a/codex-rs/core/src/client_tests.rs b/codex-rs/core/src/client_tests.rs index d93642397b..b1d9a9366a 100644 --- a/codex-rs/core/src/client_tests.rs +++ b/codex-rs/core/src/client_tests.rs @@ -1691,6 +1691,7 @@ async fn untraced_http_stream_releases_completed_output_before_response_ends() { InferenceTraceAttempt::disabled(), &test_model_client(SessionSource::Cli).state, /*last_response_tx*/ None, + super::ResponseDelivery::default(), ); assert!(matches!( @@ -1733,6 +1734,7 @@ async fn incomplete_response_traces_attempted_call_without_streaming_it() -> any attempt, &test_model_client(SessionSource::Cli).state, /*last_response_tx*/ None, + super::ResponseDelivery::default(), ); assert!(matches!(stream.next().await, Some(Err(_)))); assert!(stream.next().await.is_none()); @@ -1778,6 +1780,7 @@ async fn dropped_response_stream_traces_cancelled_partial_output() -> anyhow::Re attempt, &test_model_client(SessionSource::Cli).state, /*last_response_tx*/ None, + super::ResponseDelivery::default(), ); let observed = stream @@ -1836,6 +1839,7 @@ async fn response_stream_records_last_model_feedback_ids() { InferenceTraceAttempt::disabled(), &test_model_client(SessionSource::Cli).state, /*last_response_tx*/ None, + super::ResponseDelivery::default(), ); while stream.next().await.is_some() {} @@ -2060,6 +2064,7 @@ async fn dropped_backpressured_response_stream_traces_cancelled_partial_output() attempt, &test_model_client(SessionSource::Cli).state, /*last_response_tx*/ None, + super::ResponseDelivery::default(), ); // Fill the mapper channel with non-terminal events, then yield one output @@ -2876,19 +2881,20 @@ async fn intercepted_output_reaches_trace_and_websocket_bookkeeping() -> anyhow: .await?; drop(tx_event); let (last_response_tx, last_response_rx) = tokio::sync::oneshot::channel(); - let mut stream = super::map_response_stream( - codex_api::ResponseStream { + let mut stream = super::OpenedModelResponse { + stream: codex_api::ResponseStream { routing_affinity: None, rx_event, upstream_request_id: None, interrupt: None, }, - test_session_telemetry(), - attempt, - &test_model_client(SessionSource::Cli).state, - vec![Box::new(ReplaceOutput)], - Some(last_response_tx), - ); + telemetry: test_session_telemetry(), + trace: attempt, + client: Arc::clone(&test_model_client(SessionSource::Cli).state), + interceptors: vec![Box::new(ReplaceOutput)], + continuation: Some(last_response_tx), + } + .into_stream()?; let mut delivered = Vec::new(); while let Some(event) = stream.next().await { if let ResponseEvent::OutputItemDone(item) = event? { diff --git a/codex-rs/core/src/compact.rs b/codex-rs/core/src/compact.rs index 0c81d89417..8c800c2884 100644 --- a/codex-rs/core/src/compact.rs +++ b/codex-rs/core/src/compact.rs @@ -5,6 +5,7 @@ use std::time::Instant; use crate::Prompt; use crate::client::ModelClientSession; +use crate::client::SamplingOptions; use crate::client_common::ResponseEvent; use crate::compact_pending_input::is_retained_pending_mail; use crate::compact_remote_v2::retained_client_items; @@ -37,6 +38,7 @@ use codex_analytics::CompactionStatus; use codex_analytics::CompactionStrategy; use codex_analytics::CompactionTrigger; use codex_analytics::now_unix_seconds; +use codex_async_utils::OrCancelExt; use codex_context_fragments::AnnotatedContent; use codex_context_fragments::set_annotated_content; use codex_context_fragments::truncate_annotated_text; @@ -59,7 +61,6 @@ use codex_protocol::protocol::EventMsg; use codex_protocol::user_input::UserInput; use codex_rollout_trace::InferenceTraceContext; use codex_utils_output_truncation::approx_token_count; -use futures::prelude::*; use tracing::error; pub use codex_prompts::SUMMARIZATION_PROMPT; @@ -275,6 +276,9 @@ async fn run_compact_task_inner_impl( compaction_metadata: CompactionTurnMetadata, ) -> CodexResult { let turn_context = Arc::clone(&step_context.turn); + let mut request = crate::hook_runtime::sampling::SamplingRequest::new( + codex_hooks::SamplingKind::ForegroundCompaction, + ); let compaction_item = TurnItem::ContextCompaction(ContextCompactionItem::new()); sess.emit_turn_item_started(&turn_context, &compaction_item) .await; @@ -337,8 +341,9 @@ async fn run_compact_task_inner_impl( .compaction_responses_metadata(&step_context, compaction_metadata) .await; let attempt_result = drain_to_completed( + &mut request, &sess, - turn_context.as_ref(), + &step_context, &mut client_session, &responses_metadata, &Arc::new(prompt), @@ -853,35 +858,48 @@ struct CompactionResponse { } async fn drain_to_completed( - sess: &Session, - turn_context: &TurnContext, + request: &mut crate::hook_runtime::sampling::SamplingRequest, + sess: &Arc, + step_context: &Arc, client_session: &mut ModelClientSession, responses_metadata: &CodexResponsesMetadata, prompt: &Arc, phase: CompactionPhase, ) -> CodexResult { + let turn_context = step_context.turn.as_ref(); let mut includes_reasoning = turn_context.model_info().use_responses_lite; - let mut stream = client_session - .stream( - prompt, - turn_context.model_info(), - &turn_context.session_telemetry, - sess.reasoning_effort_for_request( - &turn_context.initial_settings, - RequestEffortUsage::Compaction, - ) - .await, - turn_context.reasoning_summary(), - turn_context.config.service_tier.clone(), - responses_metadata, - // Rollout tracing currently models remote compaction only; local compaction streams - // are left untraced until the reducer has a first-class local compaction lifecycle. - &InferenceTraceContext::disabled(), + let cancellation = &step_context.turn_cancellation; + let mut stream = request + .open( + sess, + step_context, + &turn_context.model_info().slug, + cancellation, + client_session.open_model_response( + prompt, + turn_context.model_info(), + &turn_context.session_telemetry, + SamplingOptions { + reasoning_effort: sess + .reasoning_effort_for_request( + &turn_context.initial_settings, + RequestEffortUsage::Compaction, + ) + .await, + reasoning_summary: turn_context.reasoning_summary(), + service_tier: turn_context.config.service_tier.clone(), + }, + responses_metadata, + // Rollout tracing currently models remote compaction only; local compaction streams + // are left untraced until the reducer has a first-class local compaction lifecycle. + &InferenceTraceContext::disabled(), + ), ) - .await?; + .or_cancel(cancellation) + .await??; let mut output = Vec::new(); loop { - let maybe_event = stream.next().await; + let maybe_event = stream.next_for_turn(cancellation).await; let Some(event) = maybe_event else { return Err(CodexErr::Stream( "stream closed before response.completed".into(), diff --git a/codex-rs/core/src/compact_model_fallback.rs b/codex-rs/core/src/compact_model_fallback.rs index 5a2973bafd..1bea2a5866 100644 --- a/codex-rs/core/src/compact_model_fallback.rs +++ b/codex-rs/core/src/compact_model_fallback.rs @@ -12,17 +12,16 @@ pub(crate) fn should_retry_with_current_model( previous: &TurnContext, current: &TurnContext, ) -> bool { - if matches!( - error.details(), - CodexErrorDetails::TurnAborted - | CodexErrorDetails::Interrupted - | CodexErrorDetails::SessionBudgetExceeded - | CodexErrorDetails::InferenceHookDenied { .. } - | CodexErrorDetails::WorkspaceAccessDenied(_) - | CodexErrorDetails::ContentPolicyViolation { .. } - | CodexErrorDetails::ResponseIncomplete(_) - ) || (previous.model_info().slug == current.model_info().slug - && previous.cyber_access_program == current.cyber_access_program) + if crate::responses_retry::is_terminal_sampling_outcome(error) + || matches!( + error.details(), + CodexErrorDetails::TurnAborted + | CodexErrorDetails::Interrupted + | CodexErrorDetails::WorkspaceAccessDenied(_) + | CodexErrorDetails::ContentPolicyViolation { .. } + ) + || (previous.model_info().slug == current.model_info().slug + && previous.cyber_access_program == current.cyber_access_program) { return false; } diff --git a/codex-rs/core/src/compact_remote_v2.rs b/codex-rs/core/src/compact_remote_v2.rs index 6d9f535b5c..338c126b1a 100644 --- a/codex-rs/core/src/compact_remote_v2.rs +++ b/codex-rs/core/src/compact_remote_v2.rs @@ -10,6 +10,7 @@ use crate::Prompt; use crate::ResponseStream; use crate::client::ModelClientSession; use crate::client::ResponsesHttpExecutor; +use crate::client::SamplingOptions; use crate::client_common::ResponseEvent; use crate::compact::CompactedHistoryMetadata; use crate::compact::CompactionAnalyticsAttempt; @@ -40,6 +41,7 @@ use codex_analytics::CompactionImplementation; use codex_analytics::CompactionPhase; use codex_analytics::CompactionReason; use codex_analytics::CompactionTrigger; +use codex_async_utils::OrCancelExt; use codex_context_fragments::set_annotated_content; use codex_context_fragments::to_annotated_content; use codex_features::Feature; @@ -97,7 +99,7 @@ const MAX_REMOTE_COMPACTION_V2_STREAM_RETRIES: u64 = 2; #[derive(Clone, Copy)] enum CompactionRequestKind<'a> { - Foreground, + Foreground(&'a CancellationToken), Background(&'a CancellationToken), } @@ -289,8 +291,9 @@ struct RemoteCompactionV2Output { } async fn run_remote_compaction_request_v2( - sess: &Session, - step_context: &StepContext, + request: &mut crate::hook_runtime::sampling::SamplingRequest, + sess: &Arc, + step_context: &Arc, prompt: &Arc, responses_metadata: &CodexResponsesMetadata, transport: &mut CompactionRequestTransport<'_>, @@ -308,14 +311,25 @@ async fn run_remote_compaction_request_v2( // Replay the routing token without letting this request change foreground routing. let turn_state = Arc::new(turn_state.clone().map(OnceLock::from).unwrap_or_default()); let http_executor = ResponsesHttpExecutor::new(&sess.services.model_client); + let send = http_executor.stream_responses_http( + &turn_state, + auth_owner.clone(), + /*event_sender*/ None, + prompt, + &settings.model_info, + &step_context.session_telemetry, + SamplingOptions { + reasoning_effort: effort, + reasoning_summary: settings.reasoning_summary, + service_tier: settings.service_tier.clone(), + }, + responses_metadata, + &trace, + ); let stream = tokio::select! { biased; _ = cancellation.cancelled() => return Err(CodexErr::TurnAborted), - stream = http_executor.stream_responses_http( - &turn_state, auth_owner.clone(), /*event_sender*/ None, prompt, &settings.model_info, &step_context.session_telemetry, effort, - settings.reasoning_summary, settings.service_tier.clone(), responses_metadata, - &trace, - ) => stream?, + stream = request.open(sess, step_context, &settings.model_info.slug, &cancellation, send) => stream?, }; return collect_compaction_output( sess, @@ -334,27 +348,38 @@ async fn run_remote_compaction_request_v2( .stream_max_retries() .min(MAX_REMOTE_COMPACTION_V2_STREAM_RETRIES); let mut retry_state = ResponsesStreamRetryState::default(); + let cancellation = &step_context.turn_cancellation; loop { - let result = match client_session - .stream( - prompt, - &settings.model_info, - &turn_context.session_telemetry, - sess.reasoning_effort_for_request(settings, RequestEffortUsage::Compaction) - .await, - settings.reasoning_summary, - step_context.settings.service_tier.clone(), - responses_metadata, - &InferenceTraceContext::disabled(), + let result = match request + .open( + sess, + step_context, + &settings.model_info.slug, + cancellation, + client_session.open_model_response( + prompt, + &settings.model_info, + &turn_context.session_telemetry, + SamplingOptions { + reasoning_effort: sess + .reasoning_effort_for_request(settings, RequestEffortUsage::Compaction) + .await, + reasoning_summary: settings.reasoning_summary, + service_tier: step_context.settings.service_tier.clone(), + }, + responses_metadata, + &InferenceTraceContext::disabled(), + ), ) - .await + .or_cancel(cancellation) + .await? { Ok(stream) => { collect_compaction_output( sess, turn_context, stream, - CompactionRequestKind::Foreground, + CompactionRequestKind::Foreground(cancellation), ) .await } @@ -396,7 +421,9 @@ async fn collect_compaction_output( let mut completed_token_usage = None; loop { let event = match request_kind { - CompactionRequestKind::Foreground => stream.next().await, + CompactionRequestKind::Foreground(cancellation) => { + stream.next_for_turn(cancellation).await + } CompactionRequestKind::Background(cancellation) => tokio::select! { biased; // Charge completed usage even when cancellation arrives at the same time. @@ -417,7 +444,7 @@ async fn collect_compaction_output( .await; } } - CompactionRequestKind::Foreground => { + CompactionRequestKind::Foreground(_) => { sess.record_incomplete_response_usage( turn_context, &turn_context.initial_settings, @@ -451,7 +478,7 @@ async fn collect_compaction_output( .await?; } } - CompactionRequestKind::Foreground => { + CompactionRequestKind::Foreground(_) => { sess.record_observed_response_completed( turn_context, &response_id, @@ -1384,8 +1411,10 @@ mod tests { assert_eq!(truncated, vec![newest]); } + #[test_case::test_case(false; "turn interrupt discards queued incomplete usage")] + #[test_case::test_case(true; "session shutdown preserves queued incomplete usage without foreground updates")] #[tokio::test] - async fn collect_background_incomplete_does_not_publish_foreground_usage() { + async fn collect_queued_incomplete_usage_on_cancellation(background: bool) { let usage = TokenUsage { input_tokens: 100, output_tokens: 20, @@ -1416,14 +1445,25 @@ mod tests { &sess, &turn_context, stream, - CompactionRequestKind::Background(&cancellation), + if background { + CompactionRequestKind::Background(&cancellation) + } else { + CompactionRequestKind::Foreground(&cancellation) + }, ) .await; - assert!(matches!(result, Err(ref err) - if matches!(err.details(), CodexErrorDetails::ResponseIncomplete(_)))); assert_eq!(sess.token_usage_info().await, None); assert!(rx.is_empty()); + if !background { + assert!( + matches!(result, Err(ref err) if matches!(err.details(), CodexErrorDetails::TurnAborted)) + ); + assert!(accounting.reports.lock().unwrap().is_empty()); + return; + } + assert!(matches!(result, Err(ref err) + if matches!(err.details(), CodexErrorDetails::ResponseIncomplete(_)))); assert_eq!( *accounting.reports.lock().unwrap(), vec![AgentUsageReport { @@ -1434,8 +1474,11 @@ mod tests { ); } + #[test_case::test_case(true, false; "background bills a complete response even without a summary")] + #[test_case::test_case(false, true; "turn interrupt discards a queued complete response")] + #[test_case::test_case(true, true; "session shutdown bills a queued complete response even without a summary")] #[tokio::test] - async fn background_compaction_charges_usage_even_if_output_is_missing() { + async fn collect_queued_complete_response(background: bool, interrupted: bool) { let (mut sess, turn, _) = crate::session::tests::make_session_and_context_with_rx().await; let accounting = Arc::new(UsageRecorder { reports: Mutex::new(Vec::new()), @@ -1453,14 +1496,29 @@ mod tests { reasoning_removals: None, end_turn: Some(true), })]); + let cancellation = CancellationToken::new(); + if interrupted { + cancellation.cancel(); + } let result = collect_compaction_output( &sess, &turn, stream, - CompactionRequestKind::Background(&CancellationToken::new()), + if background { + CompactionRequestKind::Background(&cancellation) + } else { + CompactionRequestKind::Foreground(&cancellation) + }, ) .await; + if !background { + assert!( + matches!(result, Err(error) if matches!(error.details(), CodexErrorDetails::TurnAborted)) + ); + assert!(accounting.reports.lock().unwrap().is_empty()); + return; + } assert!( matches!(result, Err(error) if matches!(error.details(), CodexErrorDetails::Fatal(_))) ); @@ -1514,7 +1572,7 @@ mod tests { &sess, &turn_context, stream, - CompactionRequestKind::Foreground, + CompactionRequestKind::Foreground(&CancellationToken::new()), ) .await .expect("compaction should be collected"); diff --git a/codex-rs/core/src/compact_remote_v2_attempt.rs b/codex-rs/core/src/compact_remote_v2_attempt.rs index 096eddeba5..191389e41c 100644 --- a/codex-rs/core/src/compact_remote_v2_attempt.rs +++ b/codex-rs/core/src/compact_remote_v2_attempt.rs @@ -73,6 +73,7 @@ pub(crate) struct BackgroundCompactionInput { } pub(super) async fn run_remote_compact_v2_attempt( + request: &mut crate::hook_runtime::sampling::SamplingRequest, sess: &Arc, step_context: &Arc, compaction_trace: &CompactionTraceContext, @@ -240,6 +241,7 @@ pub(super) async fn run_remote_compact_v2_attempt( }) }); let compaction_output_result = run_remote_compaction_request_v2( + request, sess, step_context, &prompt, @@ -352,7 +354,11 @@ pub(crate) async fn run_background_compaction( CompactionImplementation::ResponsesCompactionV2, phase, ); + let mut request = crate::hook_runtime::sampling::SamplingRequest::new( + codex_hooks::SamplingKind::BackgroundCompaction, + ); let attempt = run_remote_compact_v2_attempt( + &mut request, sess, &step_context, &CompactionTraceContext::disabled(), diff --git a/codex-rs/core/src/compact_remote_v2_installation.rs b/codex-rs/core/src/compact_remote_v2_installation.rs index df751918c6..d502885bc3 100644 --- a/codex-rs/core/src/compact_remote_v2_installation.rs +++ b/codex-rs/core/src/compact_remote_v2_installation.rs @@ -124,7 +124,11 @@ async fn build_and_install_compaction( )), ) } else { + let mut request = crate::hook_runtime::sampling::SamplingRequest::new( + codex_hooks::SamplingKind::ForegroundCompaction, + ); let attempt = run_remote_compact_v2_attempt( + &mut request, sess, step_context, &compaction_trace, @@ -150,6 +154,7 @@ async fn build_and_install_compaction( fallback_turn_context.provider.info().name.as_str(), ); let fallback_result = run_remote_compact_v2_attempt( + &mut request, sess, replacement_step_context, &fallback_compaction_trace, @@ -168,6 +173,13 @@ async fn build_and_install_compaction( ); match fallback_result { Ok(attempt) => (attempt, fallback_turn_context), + Err(fallback_error) + if crate::responses_retry::is_terminal_sampling_outcome( + &fallback_error, + ) => + { + return Err(fallback_error); + } Err(_) => return Err(error), } } diff --git a/codex-rs/core/src/hook_runtime.rs b/codex-rs/core/src/hook_runtime.rs index 09235da17d..7da1b27e35 100644 --- a/codex-rs/core/src/hook_runtime.rs +++ b/codex-rs/core/src/hook_runtime.rs @@ -1,4 +1,5 @@ mod executor; +pub(crate) mod sampling; pub(crate) use executor::prepare_executor_hook_sources; @@ -1111,10 +1112,7 @@ fn compaction_trigger_label(value: CompactionTrigger) -> &'static str { } } -pub(crate) fn hooks_for_model_request( - session: &Arc, - step: &StepContext, -) -> Arc { +fn hooks_for_model_request(session: &Arc, step: &StepContext) -> Arc { match step.turn.session_source { SessionSource::Internal(InternalSessionSource::MemoryConsolidation) | SessionSource::SubAgent(SubAgentSource::MemoryConsolidation) => Arc::new( @@ -1130,25 +1128,14 @@ pub(crate) fn hooks_for_model_request( } } -pub(crate) async fn run_model_request_hooks( +async fn run_model_request_hooks( session: &Arc, step: &StepContext, hooks: &codex_hooks::Hooks, - event: codex_hooks::ModelRequestHookEvent, + request: codex_hooks::ModelRequestHookInput, ) { - let subagent = thread_spawn_subagent_hook_context(session, &step.turn); - let request = codex_hooks::ModelRequestHookInput { - session_id: session.session_id().to_string(), - turn_id: step.turn.sub_id.clone(), - cwd: tool_hook_cwd(&step.environments, &step.turn), - transcript_path: session.hook_transcript_path().await, - model: step.settings.model_info.slug.clone(), - event, - agent_id: subagent.as_ref().map(|context| context.agent_id.clone()), - agent_type: subagent.map(|context| context.agent_type), - }; emit_hook_started_events(session, &step.turn, hooks.preview_model_request(&request)).await; - let events = hooks.run_model_request(request).await; + let events = hooks.run_model_request(request, |_| {}).await; emit_hook_completed_events(session, &step.turn, events).await; } diff --git a/codex-rs/core/src/hook_runtime/sampling.rs b/codex-rs/core/src/hook_runtime/sampling.rs new file mode 100644 index 0000000000..af40f89371 --- /dev/null +++ b/codex-rs/core/src/hook_runtime/sampling.rs @@ -0,0 +1,206 @@ +//! Each provider attempt pairs its own hooks. Transport recovery within an +//! attempt does not start another hook pair. + +use super::emit_hook_completed_events; +use super::emit_hook_started_events; +use super::hooks_for_model_request; +use super::run_model_request_hooks; +use super::thread_spawn_subagent_hook_context; +use super::tool_hook_cwd; +use crate::client::OpenedModelResponse; +use crate::client_common::ResponseStream; +use crate::session::session::Session; +use crate::session::step_context::StepContext; +use codex_hooks::ModelRequestHookEvent; +use codex_hooks::ModelRequestHookInput; +use codex_hooks::SamplingKind; +use codex_protocol::error::Result; +use codex_protocol::protocol::HookCompletedEvent; +use codex_protocol::protocol::HookEventName; +use codex_protocol::protocol::HookExecutionMode; +use codex_protocol::protocol::HookRunStatus; +use std::sync::Arc; +use std::time::Instant; +use tokio::sync::oneshot; +use tokio_util::sync::CancellationToken; + +pub(crate) struct SamplingRequest { + kind: SamplingKind, +} + +impl SamplingRequest { + pub(crate) fn new(kind: SamplingKind) -> Self { + Self { kind } + } + + pub(crate) fn open( + &mut self, + session: &Arc, + step: &Arc, + model: &str, + owner_cancellation: &CancellationToken, + send: impl Future> + Send, + ) -> impl Future> + Send { + // Keep the transport and hook state out of the turn's cancellation and retry futures. + Box::pin(self.open_attempt(session, step, model, owner_cancellation, send)) + } + + async fn open_attempt( + &mut self, + session: &Arc, + step: &Arc, + model: &str, + owner_cancellation: &CancellationToken, + send: impl Future>, + ) -> Result { + let sampling_turn = match self.kind { + SamplingKind::Sampling => Some(Arc::clone(&step.turn)), + SamplingKind::ForegroundCompaction | SamplingKind::BackgroundCompaction => None, + }; + let hooks = hooks_for_model_request(session, step); + let pre_mode = hooks.execution_mode_for_event(HookEventName::PreModelRequest); + let post_mode = hooks.execution_mode_for_event(HookEventName::PostModelRequest); + if pre_mode.is_none() && post_mode.is_none() { + return send.await?.deliver(&mut None, sampling_turn); + } + let subagent = thread_spawn_subagent_hook_context(session, &step.turn); + let input = ModelRequestHookInput { + lifecycle_id: uuid::Uuid::new_v4(), + kind: self.kind, + session_id: session.session_id().to_string(), + thread_id: session.thread_id().to_string(), + turn_id: step.turn.sub_id.clone(), + cwd: tool_hook_cwd(&step.environments, &step.turn), + transcript_path: session.hook_transcript_path().await, + model: model.to_owned(), + event: ModelRequestHookEvent::PreModelRequest, + agent_id: subagent.as_ref().map(|context| context.agent_id.clone()), + agent_type: subagent.map(|context| context.agent_type), + }; + let mut attempt = post_mode.map(|mode| SamplingAttempt { + owner_cancellation: owner_cancellation.clone(), + post: Some(PostHooks { + hooks: Arc::clone(&hooks), + step: Arc::clone(step), + input: input.clone(), + mode, + }), + session: Arc::clone(session), + }); + if pre_mode.is_some() { + run_model_request_hooks(session, step, &hooks, input).await; + } + let stream = send + .await + .and_then(|opened| opened.deliver(&mut attempt, sampling_turn)); + if let Err(error) = &stream + && let Some(mut attempt) = attempt + && let Some(hooks) = attempt.start_post_hooks(ModelRequestHookEvent::failed(error)) + { + hooks.await; + } + stream + } +} + +/// The sampling future owns the synchronous handlers. Observer-only and +/// pre-response cancellation notifications run on the session's hook executor. +struct PostHooks { + hooks: Arc, + step: Arc, + input: ModelRequestHookInput, + mode: HookExecutionMode, +} + +impl PostHooks { + async fn run(mut self, session: &Arc, event: ModelRequestHookEvent) { + self.input.event = event; + run_model_request_hooks(session, &self.step, &self.hooks, self.input).await; + } + + async fn run_sync(mut self, session: Arc, event: ModelRequestHookEvent) { + let (mut done, wait) = oneshot::channel(); + self.input.event = event; + // Dropping the waiter cancels execution while the task finishes publishing + // lifecycle events. It must run independently of the async hook limit. + tokio::spawn(async move { + if done.is_closed() { + return; + } + let turn = &self.step.turn; + let runs = self.hooks.preview_model_request(&self.input); + let started = Instant::now(); + emit_hook_started_events(&session, turn, runs.clone()).await; + let mut finished: Vec = Vec::new(); + let events = tokio::select! { + biased; + () = done.closed() => { + let completed_at = chrono::Utc::now().timestamp(); + let duration_ms = i64::try_from(started.elapsed().as_millis()).unwrap_or(i64::MAX); + for mut run in runs { + if run.execution_mode != HookExecutionMode::Sync + || finished.iter().any(|event| event.run.id == run.id) + { + continue; + } + run.status = HookRunStatus::Stopped; + run.status_message = Some("Hook cancelled because the turn was interrupted".into()); + run.completed_at = Some(completed_at); + run.duration_ms = Some(duration_ms); + finished.push(HookCompletedEvent { + turn_id: Some(turn.sub_id.clone()), + run, + }); + } + finished + } + events = self.hooks.run_model_request(self.input, |event| finished.push(event.clone())) => events, + }; + emit_hook_completed_events(&session, turn, events).await; + let _ = done.send(()); + }); + let _ = wait.await; + } + + fn schedule(self, session: Arc, event: ModelRequestHookEvent) { + Arc::clone(&self.hooks).schedule_async_task(async move { + self.run(&session, event).await; + }); + } +} + +pub(crate) struct SamplingAttempt { + /// The turn owns foreground responses; the session owns speculative responses. + pub(crate) owner_cancellation: CancellationToken, + session: Arc, + post: Option, +} + +impl Drop for SamplingAttempt { + fn drop(&mut self) { + if let Some(post) = self.post.take() { + post.schedule( + Arc::clone(&self.session), + ModelRequestHookEvent::cancelled(), + ); + } + } +} + +impl SamplingAttempt { + /// Observers run on the session executor. The request owns the synchronous + /// group: if the turn stops waiting, dropping this future cancels it. + pub(crate) fn start_post_hooks( + &mut self, + event: ModelRequestHookEvent, + ) -> Option + Send + 'static> { + let post = self.post.take()?; + let session = Arc::clone(&self.session); + if post.mode == HookExecutionMode::Sync { + Some(post.run_sync(session, event)) + } else { + post.schedule(session, event); + None + } + } +} diff --git a/codex-rs/core/src/responses_retry.rs b/codex-rs/core/src/responses_retry.rs index d795969bb6..d33caa262d 100644 --- a/codex-rs/core/src/responses_retry.rs +++ b/codex-rs/core/src/responses_retry.rs @@ -29,6 +29,18 @@ pub(crate) enum ResponsesStreamRequest { RemoteCompactionV2, } +/// A new generation cannot repair a terminal provider response or settle the +/// previous attempt's bill. Preserve these outcomes across transport retries, +/// same-turn steering, and compaction's fallback to another model. +pub(crate) fn is_terminal_sampling_outcome(error: &CodexErr) -> bool { + matches!( + error.details(), + CodexErrorDetails::ResponseIncomplete(_) + | CodexErrorDetails::SessionBudgetExceeded + | CodexErrorDetails::InferenceHookDenied { .. } + ) +} + pub(crate) struct ResponsesStreamRetryState { retries: u64, connection_retries: u64, diff --git a/codex-rs/core/src/session/mod.rs b/codex-rs/core/src/session/mod.rs index ce1297bcdc..335872b61f 100644 --- a/codex-rs/core/src/session/mod.rs +++ b/codex-rs/core/src/session/mod.rs @@ -4654,6 +4654,7 @@ impl Session { Ok(Arc::new(StepContext { sampled_through_sequence: None, serving_assessment: None, + turn_cancellation: cancellation_token.clone(), preempt: turn_context .config .features diff --git a/codex-rs/core/src/session/step_context.rs b/codex-rs/core/src/session/step_context.rs index 4da137bc3f..6041bf0f46 100644 --- a/codex-rs/core/src/session/step_context.rs +++ b/codex-rs/core/src/session/step_context.rs @@ -31,6 +31,8 @@ pub(crate) struct StepContext { /// Final serving value for this invocation; retained by its code cell across waits. pub(crate) serving_assessment: Option>, pub(crate) turn: Arc, + /// Cancels work owned by this turn, independently of steers or session shutdown. + pub(crate) turn_cancellation: CancellationToken, /// Preempts this request and yields its code-mode observations when user input arrives. pub(crate) preempt: Option, /// Realtime call activity and instructions captured for this sampling request. diff --git a/codex-rs/core/src/session/tests.rs b/codex-rs/core/src/session/tests.rs index 3a7236db02..aa7fa92726 100644 --- a/codex-rs/core/src/session/tests.rs +++ b/codex-rs/core/src/session/tests.rs @@ -305,6 +305,7 @@ impl StepContext { settings.service_tier = turn.config.service_tier.clone(); Arc::new(Self { sampled_through_sequence: None, + turn_cancellation: tokio_util::sync::CancellationToken::new(), preempt: turn .config .features diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rs index c3d3a36c48..55f1d2d344 100644 --- a/codex-rs/core/src/session/turn.rs +++ b/codex-rs/core/src/session/turn.rs @@ -7,8 +7,10 @@ use std::time::Duration; use std::time::Instant; use crate::client::ModelClientSession; +use crate::client::SamplingOptions; use crate::client_common::Prompt; use crate::client_common::ResponseEvent; +use crate::client_common::ResponseStream; use crate::compact::AutoCompactionDisabled; use crate::compact::run_inline_auto_compact_task; use crate::compact_remote_v2::BackgroundCompactionCandidate; @@ -21,15 +23,14 @@ use crate::cyber_access_program; use crate::environment_selection::TurnEnvironmentSnapshot; use crate::feedback_tags; use crate::hook_runtime::drain_async_hook_results; -use crate::hook_runtime::hooks_for_model_request; use crate::hook_runtime::inspect_pending_input; use crate::hook_runtime::legacy_notify_input_messages; use crate::hook_runtime::record_additional_contexts; use crate::hook_runtime::record_pending_input; use crate::hook_runtime::run_legacy_after_agent_hook; -use crate::hook_runtime::run_model_request_hooks; use crate::hook_runtime::run_pending_session_start_hooks; use crate::hook_runtime::run_turn_stop_hooks; +use crate::hook_runtime::sampling::SamplingRequest; use crate::mcp_skill_dependencies::maybe_prompt_and_install_mcp_dependencies; use crate::mentions::build_connector_slug_counts; use crate::mentions::collect_explicit_app_ids; @@ -68,7 +69,6 @@ use crate::tools::router::ToolSuggestPresentation; use crate::tools::router::record_registration_metrics; use crate::tools::spec_plan::build_tool_router; use crate::turn_diff_tracker::TurnDiffTracker; -use crate::turn_timing::record_turn_ttft_metric; use crate::util::error_or_panic; use codex_analytics::AppInvocation; use codex_analytics::CompactionPhase; @@ -86,9 +86,7 @@ use codex_features::Feature; use codex_file_system::EnvironmentAccess; use codex_file_system::FindUpErrorPolicy; use codex_file_system::find_nearest_ancestor_with_markers; -use codex_hooks::ModelRequestHookEvent::PostModelRequest; -use codex_hooks::ModelRequestHookEvent::PreModelRequest; -use codex_hooks::ModelRequestStatus; +use codex_hooks::SamplingKind; use codex_login::CodexAuth; use codex_model_provider::RemoteCompactionSupport; use codex_protocol::ResponseItemId; @@ -113,8 +111,6 @@ use codex_protocol::protocol::AgentReasoningSectionBreakEvent; use codex_protocol::protocol::CodexErrorInfo; use codex_protocol::protocol::ErrorEvent; use codex_protocol::protocol::EventMsg; -use codex_protocol::protocol::HookEventName; -use codex_protocol::protocol::HookExecutionMode; use codex_protocol::protocol::InternalSessionSource; use codex_protocol::protocol::PlanDeltaEvent; use codex_protocol::protocol::ReasoningContentDeltaEvent; @@ -1936,6 +1932,7 @@ async fn run_sampling_request( let mut initial_input = Some(input); let mut notify_messages = Vec::new(); let mut executed_tool_calls_by_output = HashMap::new(); + let mut sampling_request = SamplingRequest::new(SamplingKind::Sampling); loop { // Running code-mode cells can request review while this response is in flight. // Keep the latest received ID until response.created replaces it. @@ -2011,6 +2008,7 @@ async fn run_sampling_request( }; let mut draining_for_mailbox = false; let err = match try_run_sampling_request( + &mut sampling_request, tool_runtime.clone(), Arc::clone(&sess), sampling_step_context, @@ -2042,11 +2040,8 @@ async fn run_sampling_request( } return Err(err); } - CodexErrorDetails::SessionBudgetExceeded - | CodexErrorDetails::InferenceHookDenied { .. } - | CodexErrorDetails::Fatal(_) => { - return Err(err); - } + CodexErrorDetails::Fatal(_) => return Err(err), + _ if crate::responses_retry::is_terminal_sampling_outcome(&err) => return Err(err), _ => err, }, }; @@ -2867,6 +2862,7 @@ async fn drain_in_flight( ) )] async fn try_run_sampling_request( + sampling_request: &mut SamplingRequest, tool_runtime: ToolCallRuntime, sess: Arc, step_context: Arc, @@ -2925,47 +2921,11 @@ async fn try_run_sampling_request( let effort = sess .reasoning_effort_for_request(&step_context.settings, super::RequestEffortUsage::Sampling) .await; - let hooks = hooks_for_model_request(&sess, &step_context); - let post_mode = hooks.execution_mode_for_event(HookEventName::PostModelRequest); - let defer_tool_dispatch = post_mode == Some(HookExecutionMode::Sync); - let finish_post_request = post_mode.map(|_| { - let (post_request, completed) = tokio::sync::oneshot::channel(); - let (hook_done, wait_for_hook) = tokio::sync::oneshot::channel(); - hooks.schedule_async_task({ - let hooks = Arc::clone(&hooks); - let session = Arc::clone(&sess); - let step = Arc::clone(&step_context); - async move { - let event = completed.await.unwrap_or(PostModelRequest { - status: ModelRequestStatus::Cancelled, - error: None, - token_usage: None, - }); - run_model_request_hooks(&session, &step, &hooks, event).await; - let _ = hook_done.send(()); - } - }); - let cancellation_token = cancellation_token.clone(); - async move |event| { - let _ = post_request.send(event); - if defer_tool_dispatch { - // Interrupt the wait, not the session-owned hook or final token accounting. - let _ = wait_for_hook.or_cancel(&cancellation_token).await; - } - } - }); - if hooks - .execution_mode_for_event(HookEventName::PreModelRequest) - .is_some() - { - run_model_request_hooks(&sess, &step_context, &hooks, PreModelRequest).await; - } let sampling_timing_guard = turn_context.turn_timing_state.begin_sampling(); let mut response_id_for_assessment = None; let mut answer_moderation: Option = None; let mut pending_assessment: Option = None; let mut response_completed = false; - let mut request_token_usage: Option = None; let mut includes_reasoning = step_context.settings.model_info.use_responses_lite; // Catalog policies can enable adaptive review independently of the legacy scorer flag. // Capture evidence whenever Guardian is available; the reviewer resolves the policy. @@ -2981,37 +2941,33 @@ async fn try_run_sampling_request( let mut resampling = crate::guardian::ResponseResampling::new(&sess); let prompt = Arc::new(prompt); let mut stream_request = async |prompt: &Arc| { - client_session - .stream( + let send = client_session + .open_model_response( prompt, &step_context.settings.model_info, &step_context.session_telemetry, - effort.clone(), - step_context.settings.reasoning_summary, - step_context.settings.service_tier.clone(), + SamplingOptions { + reasoning_effort: effort.clone(), + reasoning_summary: step_context.settings.reasoning_summary, + service_tier: step_context.settings.service_tier.clone(), + }, responses_metadata, &inference_trace, ) - .instrument(trace_span!("stream_request")) + .instrument(trace_span!("stream_request")); + sampling_request + .open( + &sess, + &step_context, + &step_context.settings.model_info.slug, + &cancellation_token, + send, + ) .await }; - let stream = stream_request(&prompt) + let mut stream = stream_request(&prompt) .or_cancel(&cancellation_token) - .await?; - let mut stream = match stream { - Ok(stream) => stream, - Err(error) => { - if let Some(finish_post_request) = finish_post_request { - finish_post_request(PostModelRequest { - status: ModelRequestStatus::Failed, - error: Some(error.to_string()), - token_usage: None, - }) - .await; - } - return Err(error); - } - }; + .await??; let can_interrupt = turn_context .config .features @@ -3090,8 +3046,6 @@ async fn try_run_sampling_request( "codex.response.receive_wait_ms", receive_started.elapsed().as_secs_f64() * 1000.0, ); - // Account for an already-received terminal error even if cancellation raced it. - // Cancellation still stops ordinary stream events before they can run tools. let event = match event { Ok(Ok(event)) => event, Ok(Err(_)) => { @@ -3118,13 +3072,7 @@ async fn try_run_sampling_request( Err(_) => break Err(CodexErr::TurnAborted), }; - if cancellation_token.is_cancelled() - && !matches!(event.as_ref(), Some(Err(err)) - if matches!(err.details(), CodexErrorDetails::ResponseIncomplete(_))) - { - break Err(CodexErr::TurnAborted); - } - + let event = ResponseStream::accept_for_turn(event, &cancellation_token); let event = match event.unwrap_or_else(|| { Err(CodexErr::Stream( "stream closed before response.completed".into(), @@ -3133,11 +3081,6 @@ async fn try_run_sampling_request( Ok(event) => event, Err(err) => { if let CodexErrorDetails::ResponseIncomplete(incomplete) = err.details() { - if let Some(usage) = &incomplete.token_usage { - request_token_usage - .get_or_insert_default() - .add_assign(usage); - } sess.record_incomplete_response_usage( &turn_context, &step_context.settings, @@ -3162,7 +3105,6 @@ async fn try_run_sampling_request( } }; - record_turn_ttft_metric(&turn_context, &event).await; let Some(event) = resampling.filter(event, &step_context.tool_router) else { continue; }; @@ -3273,7 +3215,7 @@ async fn try_run_sampling_request( step_context: Arc::clone(&step_context), turn_store: Arc::clone(&turn_store), tool_runtime, - defer_tool_dispatch: defer_tool_dispatch || *draining_for_mailbox, + defer_tool_dispatch: *draining_for_mailbox, cancellation_token: cancellation_token.child_token(), }; if *draining_for_mailbox { @@ -3532,11 +3474,6 @@ async fn try_run_sampling_request( .await; } response_completed = true; - if let Some(usage) = &token_usage { - request_token_usage - .get_or_insert_default() - .add_assign(usage); - } sess.services .analytics_events_client .track_code_mode_tool_call( @@ -3757,21 +3694,6 @@ async fn try_run_sampling_request( drop(stream); drop(sampling_span); drop(sampling_timing_guard); - if let Some(finish_post_request) = finish_post_request { - let (status, error) = match (response_completed, &outcome) { - (true, _) => (ModelRequestStatus::Completed, None), - (false, Err(error)) if !matches!(error.details(), CodexErrorDetails::TurnAborted) => { - (ModelRequestStatus::Failed, Some(error.to_string())) - } - _ => (ModelRequestStatus::Cancelled, None), - }; - finish_post_request(PostModelRequest { - status, - error, - token_usage: request_token_usage, - }) - .await; - } flush_assistant_text_segments_all( &sess, &turn_context, diff --git a/codex-rs/core/tests/common/hooks.rs b/codex-rs/core/tests/common/hooks.rs index 9e07569e63..515ea66310 100644 --- a/codex-rs/core/tests/common/hooks.rs +++ b/codex-rs/core/tests/common/hooks.rs @@ -5,6 +5,56 @@ use codex_core::config::Config; use codex_features::Feature; use codex_hooks::HookListEntry; use codex_utils_absolute_path::AbsolutePathBuf; +use serde_json::json; + +/// Build the MCP reply for a loopback hook fixture; notifications have no body. +pub fn hook_mcp_reply( + request: &serde_json::Value, + server: &str, + tools: &[&str], + call: impl FnOnce(&serde_json::Value) -> serde_json::Value, +) -> Option { + let method = request["method"].as_str().expect("MCP method"); + let Some(id) = request.get("id") else { + assert!( + method.starts_with("notifications/"), + "missing ID for {method}" + ); + return None; + }; + let result = match method { + "initialize" => json!({ + "protocolVersion": request["params"]["protocolVersion"], + "capabilities": {"tools": {}}, + "serverInfo": {"name": server, "version": "1.0.0"}, + }), + "tools/list" => { + json!({"tools":tools.iter().map(|name| json!({"name":name,"inputSchema":{"type":"object"}})).collect::>()}) + } + "tools/call" => call(&request["params"]), + method => panic!("unexpected MCP request: {method}"), + }; + Some(json!({"jsonrpc":"2.0", "id":id, "result":result})) +} + +pub async fn mount_hook_mcp( + server: &wiremock::MockServer, + name: &'static str, + tools: &'static [&'static str], + respond: impl Fn(&serde_json::Value) -> serde_json::Value + Send + Sync + 'static, +) { + wiremock::Mock::given(wiremock::matchers::method("POST")) + .and(wiremock::matchers::path("/repl")) + .respond_with(move |req: &wiremock::Request| { + let request = serde_json::from_slice(&req.body).expect("MCP request"); + match hook_mcp_reply(&request, name, tools, &respond) { + Some(reply) => wiremock::ResponseTemplate::new(200).set_body_json(reply), + None => wiremock::ResponseTemplate::new(202), + } + }) + .mount(server) + .await; +} pub fn trust_discovered_hooks(config: &mut Config) { config diff --git a/codex-rs/core/tests/suite/compact.rs b/codex-rs/core/tests/suite/compact.rs index aff676a91b..13272eea02 100644 --- a/codex-rs/core/tests/suite/compact.rs +++ b/codex-rs/core/tests/suite/compact.rs @@ -1643,6 +1643,146 @@ async fn failed_compaction_preserves_history_after_restart() -> Result<()> { Ok(()) } +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn foreground_compaction_only_installs_and_bills_after_its_post_hook() -> Result<()> { + skip_if_no_network!(Ok(())); + let server = start_mock_server().await; + let responses = ["seed", "interrupted", "accepted"].map(|id| { + sse(vec![ + ev_assistant_message(id, id), + ev_completed_with_tokens(id, /*total_tokens*/ 42), + ]) + }); + let model = mount_sse_sequence(&server, responses.to_vec()).await; + let hook_server = start_mock_server().await; + let calls = Arc::new(std::sync::Mutex::new(Vec::new())); + let held = Arc::new(tokio::sync::Notify::new()); + let (release, gate) = std::sync::mpsc::channel(); + let gate = std::sync::Mutex::new(gate); + core_test_support::hooks::mount_hook_mcp(&hook_server, "observer", &["pre", "post"], { + let calls = Arc::clone(&calls); + let held = Arc::clone(&held); + move |params| { + let input = ¶ms["arguments"]; + if input["kind"] == "foreground_compaction" { + calls + .lock() + .unwrap() + .push((params["name"].clone(), input["response_id"].clone())); + if input["response_id"] == "interrupted" { + held.notify_one(); + // Dropping the sender also releases the mock if an assertion fails. + let _ = gate.lock().unwrap().recv(); + } + } + json!({"content":[]}) + } + }) + .await; + let url = format!("{}/repl", hook_server.uri()); + let provider = non_openai_model_provider(&server); + let accounting = Arc::new(super::rollout_budget::HostAccounting::default()); + let mut extensions = codex_extension_api::ExtensionRegistryBuilder::new(); + extensions.thread_lifecycle_contributor(accounting.clone()); + let test = test_codex() + .with_pre_build_hook(move |home| { + let hook = |tool, input| { + json!([{ "hooks": [{ + "type": "mcp_tool", + "server": "observer", + "tool": tool, + "input": input + }] }]) + }; + let config = json!({ + "hooks": { + "PreModelRequest": hook("pre", json!({ "kind": "${kind}" })), + "PostModelRequest": hook("post", json!({ + "kind": "${kind}", + "response_id": "${response_id}" + })) + }, + "mcp_servers": { "observer": { + "url": url, + "environment_id": super::rmcp_client::remote_aware_environment_id() + } } + }); + fs::write(home.join("config.toml"), toml::to_string(&config).unwrap()).unwrap(); + }) + .with_config(move |config| { + config.model_provider = provider; + set_test_compact_prompt(config); + trust_discovered_hooks(config); + }) + .with_extensions(Arc::new(extensions.build())) + .build_with_auto_env(&server) + .await?; + test.submit_turn("seed history").await?; + let charged_turns = || { + accounting + .reports + .lock() + .unwrap() + .iter() + .map(|r| r.turn_id.clone()) + .collect::>() + }; + let seed_charges = charged_turns(); + assert_eq!(seed_charges.len(), 1); + + test.codex.submit(Op::Compact).await?; + tokio::time::timeout(std::time::Duration::from_secs(15), held.notified()).await?; + test.codex.flush_rollout().await?; + let history = test.codex.load_history(/*include_archived*/ false).await?; + assert!( + !history + .items + .iter() + .any(|item| matches!(item, RolloutItem::Compacted(_))) + ); + assert_eq!(charged_turns(), seed_charges); + test.codex.submit(Op::Interrupt).await?; + wait_for_event(&test.codex, |event| { + matches!(event, EventMsg::TurnAborted(_)) + }) + .await; + release.send(())?; + + let accepted_turn = test.codex.submit(Op::Compact).await?; + wait_for_event( + &test.codex, + |event| matches!(event, EventMsg::TurnComplete(done) if done.turn_id == accepted_turn), + ) + .await; + test.codex.flush_rollout().await?; + let history = test.codex.load_history(/*include_archived*/ false).await?; + let checkpoints: Vec<_> = history + .items + .iter() + .filter_map(|item| match item { + RolloutItem::Compacted(checkpoint) => { + Some(checkpoint.compaction_response_id.as_deref()) + } + _ => None, + }) + .collect(); + assert_eq!(checkpoints, [Some("accepted")]); + let mut expected_charges = seed_charges; + expected_charges.push(accepted_turn); + assert_eq!(charged_turns(), expected_charges); + assert_eq!( + *calls.lock().unwrap(), + [ + (json!("pre"), Value::Null), + (json!("post"), json!("interrupted")), + (json!("pre"), Value::Null), + (json!("post"), json!("accepted")), + ] + ); + assert_eq!(model.requests().len(), 3); + Ok(()) +} + #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn manual_compact_records_durable_and_local_token_usage() { skip_if_no_network!(); diff --git a/codex-rs/core/tests/suite/hooks.rs b/codex-rs/core/tests/suite/hooks.rs index 1adc7868b1..a537e09672 100644 --- a/codex-rs/core/tests/suite/hooks.rs +++ b/codex-rs/core/tests/suite/hooks.rs @@ -31,6 +31,7 @@ use codex_protocol::permissions::NetworkSandboxPolicy; use codex_protocol::protocol::AskForApproval; use codex_protocol::protocol::EventMsg; use codex_protocol::protocol::HookEventName; +use codex_protocol::protocol::HookRunStatus; use codex_protocol::protocol::InternalSessionSource; use codex_protocol::protocol::Op; use codex_protocol::protocol::SessionSource; @@ -47,6 +48,7 @@ use codex_protocol::user_input::UserInput; use codex_thread_store::InMemoryThreadStore; use core_test_support::TestTargetOs; use core_test_support::fs_wait; +use core_test_support::hooks::mount_hook_mcp; use core_test_support::hooks::trust_discovered_hooks; use core_test_support::responses; use core_test_support::responses::ev_apply_patch_custom_tool_call; @@ -4503,32 +4505,13 @@ async fn local_bundled_cleanup_hook_runs_without_saved_trust( }), }; let server = start_mock_server().await; - wiremock::Mock::given(wiremock::matchers::method("POST")) - .and(wiremock::matchers::path("/repl")) - .respond_with(move |request: &wiremock::Request| { - let request: Value = serde_json::from_slice(&request.body).expect("MCP request"); - let result = match request["method"].as_str() { - Some("initialize") => serde_json::json!({ - "protocolVersion": request["params"]["protocolVersion"], - "capabilities": { "tools": {} }, - "serverInfo": { "name": mcp_server_name, "version": "1.0.0" }, - }), - Some("notifications/initialized") => return wiremock::ResponseTemplate::new(202), - Some("tools/list") => serde_json::json!({ "tools": [ - { "name": "turn_ended", "inputSchema": { "type": "object" } }, - { "name": "regular_stop", "inputSchema": { "type": "object" } }, - ] }), - Some("tools/call") => hook_response.clone(), - method => panic!("unexpected MCP request: {method:?}"), - }; - wiremock::ResponseTemplate::new(200).set_body_json(serde_json::json!({ - "jsonrpc": "2.0", - "id": request["id"], - "result": result, - })) - }) - .mount(&server) - .await; + mount_hook_mcp( + &server, + mcp_server_name, + &["turn_ended", "regular_stop"], + move |_| hook_response.clone(), + ) + .await; let response = mount_sse_once( &server, sse(vec![ @@ -6142,33 +6125,18 @@ async fn model_request_hooks_report_failures_and_retries_but_cannot_veto() -> Re wait_for_hook_inputs(test.codex_home_path(), "PostModelRequest", /*count*/ 2).await?; assert_eq!(pre.len(), 2); assert_eq!(post.len(), 2); + let thread_id = test.session_configured.thread_id.to_string(); + for hook in pre.iter().chain(&post) { + assert_eq!(hook["thread_id"], thread_id); + assert_eq!(hook["kind"], "sampling"); + } assert_eq!(post[0]["status"], "failed"); assert!(post[0]["error"].is_string()); - assert_eq!(post[1]["status"], "completed"); - assert_eq!(post[1]["error"], Value::Null); + assert_eq!(post[0]["response_id"], Value::Null); assert_eq!(post[0]["token_usage"], Value::Null); - assert_eq!( - post[1]["token_usage"], - json!({ - "input_tokens": 42, - "cached_input_tokens": 0, - "cache_write_input_tokens": 0, - "output_tokens": 0, - "reasoning_output_tokens": 0, - "total_tokens": 42, - }) - ); - for (before, after) in pre.iter().zip(&post) { - let mut common = after.clone(); - common["hook_event_name"] = json!("PreModelRequest"); - let fields = common.as_object_mut().unwrap(); - fields.remove("status"); - fields.remove("error"); - fields.remove("token_usage"); - assert_eq!(before, &common); - assert!(before["session_id"].is_string()); - assert!(before["cwd"].is_string()); - } + assert_eq!(post[1]["status"], "completed"); + assert_eq!(post[1]["response_id"], "successful-attempt"); + assert_eq!(post[1]["token_usage"]["total_tokens"], 42); Ok(()) } @@ -6214,33 +6182,57 @@ async fn model_request_observer_reports_cancellation() -> Result<()> { Ok(()) } -#[test_case::test_case(Some(false), false; "sync finishes before dispatch")] -#[test_case::test_case(Some(false), true; "resume after interrupt preserves aborted custom call and usage")] -#[test_case::test_case(Some(true), false; "async dispatches before stream ends")] -#[test_case::test_case(None, false; "no post hook dispatches before stream ends")] +#[derive(Clone, Copy, PartialEq, Eq)] +enum ToolDispatchCase { + Eager, + AsyncHook, + SyncHook, + InterruptedHook, +} + +#[test_case::test_case(ToolDispatchCase::Eager; "default runs the tool before the response ends")] +#[test_case::test_case(ToolDispatchCase::AsyncHook; "an observer does not hold the tool")] +#[test_case::test_case(ToolDispatchCase::SyncHook; "streaming output and tools precede a synchronous hook")] +#[test_case::test_case(ToolDispatchCase::InterruptedHook; "interrupt cancels the synchronous hook before billing")] #[tokio::test] -async fn model_request_post_hook_orders_tool_dispatch( - hook_async: Option, - interrupt: bool, -) -> Result<()> { +async fn model_request_post_hook_orders_tool_dispatch(case: ToolDispatchCase) -> Result<()> { skip_if_no_network!(Ok(())); - let (finish_stream, gate) = oneshot::channel(); - let call = if interrupt { - ev_apply_patch_custom_tool_call( - "call", - "*** Begin Patch\n*** Add File: should-not-exist\n+unexpected\n*** End Patch", - ) - } else { - ev_function_call("call", "test_sync_tool", "{}") + use ToolDispatchCase::AsyncHook; + use ToolDispatchCase::Eager; + use ToolDispatchCase::InterruptedHook; + use ToolDispatchCase::SyncHook; + const MARKER: &str = "tool-dispatched"; + const STREAMED: &str = "Still streaming."; + + let hook_async = match case { + Eager => None, + AsyncHook => Some(true), + SyncHook | InterruptedHook => Some(false), }; + let (finish_stream, gate) = oneshot::channel(); + let mut completed = ev_completed_with_tokens("first", /*total_tokens*/ 42); + completed["response"]["usage"]["codex_rollout_budget_units"] = json!(1); let first = vec![ StreamingSseChunk { gate: None, - body: sse(vec![ev_response_created("first"), call]), + body: sse(vec![ + ev_response_created("first"), + ev_apply_patch_custom_tool_call( + "call", + &format!("*** Begin Patch\n*** Add File: {MARKER}\n+ran\n*** End Patch"), + ), + ev_message_item_added("progress", ""), + ev_output_text_delta(STREAMED), + ev_message_item_done("progress", STREAMED), + // Safety notifications pass through in either mode. Observing this one + // proves the reader consumed the preceding items while completion was held. + json!({"type":"response.metadata", "response_id":"first", + "metadata":{"type":"safety_buffering","use_cases":["cyber"],"reasons":["policy-check"]}}), + ]), }, StreamingSseChunk { gate: Some(gate), - body: sse_event(ev_completed_with_tokens("first", /*total_tokens*/ 42)), + body: sse_event(completed), }, ]; let second = vec![StreamingSseChunk { @@ -6248,31 +6240,43 @@ async fn model_request_post_hook_orders_tool_dispatch( body: sse(vec![ev_response_created("second"), ev_completed("second")]), }]; let (server, _) = start_streaming_sse_server(vec![first, second]).await; - let test = test_codex() - .with_model("test-gpt-5.1-codex") + let accounting = Arc::new(super::rollout_budget::HostAccounting::default()); + // The first post-hook blocks on this connection until the test closes it. + let hook_gate = tokio::net::TcpListener::bind("127.0.0.1:0").await?; + let port = hook_gate.local_addr()?.port(); + let mut builder = test_codex() .with_pre_build_hook(move |home| { - let order = home.join("order").display().to_string(); - let tool = format!("echo tool >> '{order}'"); - let mut hooks = - json!({"PreToolUse": [{"hooks": [{"type": "command", "command": tool}]}]}); if let Some(hook_async) = hook_async { - let started = home.join("post-started"); - let release = home.join("release-post"); let post = format!( - "touch '{}'; while test ! -e '{}'; do sleep 0.02; done; echo post >> '{order}'", - started.display(), - release.display(), + r#"python3 -c 'import json, socket, sys; json.load(sys.stdin).get("response_id") == "first" and socket.create_connection(("127.0.0.1", {port})).recv(1)'"# ); - hooks["PostModelRequest"] = json!([{"hooks": [{ + let hooks = json!({"PostModelRequest": [{"hooks": [{ "type": "command", "command": post, "async": hook_async, - }]}]); + }]}]}); + fs::write(home.join("hooks.json"), json!({"hooks": hooks}).to_string()) + .expect("write hook configuration"); } - fs::write(home.join("hooks.json"), json!({"hooks": hooks}).to_string()) - .expect("write hook configuration"); }) - .with_config(trust_discovered_hooks) - .build_with_streaming_server(&server) - .await?; + .with_config(move |config| { + if hook_async.is_some() { + trust_discovered_hooks(config); + } + if matches!(case, Eager | SyncHook) { + config.rollout_budget = Some(super::rollout_budget::rollout_budget()); + } + // The builder changes cwd after loading config, so bind the write grant to that cwd. + config.workspace_roots = vec![config.cwd.clone()]; + config.permissions.set_workspace_roots(config.workspace_roots.clone()); + config.permissions.approval_policy = Constrained::allow_any(AskForApproval::Never); + config.permissions.set_permission_profile(restrictive_workspace_write_profile()) + .expect("allow the fixture's patch inside its temporary workspace"); + }); + if matches!(case, SyncHook | InterruptedHook) { + let mut extensions = codex_extension_api::ExtensionRegistryBuilder::new(); + extensions.thread_lifecycle_contributor(accounting.clone()); + builder = builder.with_extensions(Arc::new(extensions.build())); + } + let test = builder.build_with_streaming_server(&server).await?; test.codex .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text { text: "use the tool".into(), @@ -6280,61 +6284,71 @@ async fn model_request_post_hook_orders_tool_dispatch( }])) .await?; - let home = test.codex_home_path(); - let order = home.join("order"); - let sync_post = hook_async == Some(false); - if !sync_post { - // Dispatch must not depend on the terminal response event, which we still hold. - fs_wait::wait_for_path_exists(&order, Duration::from_secs(10)).await?; - } + let marker = test.workspace_path(MARKER); + let mut saw_delta = false; + wait_for_event(&test.codex, |event| { + saw_delta |= matches!(event, EventMsg::AgentMessageContentDelta(message) if message.delta == STREAMED); + matches!(event, EventMsg::SafetyBuffering(_)) + }).await; + assert!(saw_delta); + fs_wait::wait_for_path_exists(&marker, Duration::from_secs(10)).await?; finish_stream.send(()).expect("release response stream"); - let release = home.join("release-post"); - if sync_post { - fs_wait::wait_for_path_exists(home.join("post-started"), Duration::from_secs(10)).await?; - } - if interrupt { - test.codex.submit(Op::Interrupt).await?; - wait_for_event(&test.codex, |event| matches!(event, - EventMsg::TokenCount(ev) if ev.info.as_ref().is_some_and(|info| info.total_token_usage.total_tokens == 42) - )).await; - wait_for_event(&test.codex, |event| { - matches!(event, EventMsg::TurnAborted(_)) - }) - .await; - assert!( - !order.exists(), - "interrupt must not dispatch the deferred tool" - ); - fs::write(release, "")?; - assert!(!test.workspace_path("should-not-exist").exists()); - - let server = start_mock_server().await; - let requests = mount_sse_once(&server, responses::sse_completed("resumed")).await; - let resumed = test_codex().restart(&server, &test).await?; - let usage = resumed - .codex - .token_usage_info() - .await - .context("restored usage")?; - assert_eq!(usage.total_token_usage.total_tokens, 42); - resumed.submit_turn("continue after interrupt").await?; - let (output, _) = requests - .single_request() - .custom_tool_call_output_content_and_success("call") - .context("aborted custom tool output")?; - assert_eq!(output.as_deref(), Some("aborted before dispatch")); + let held_hook = if hook_async.is_some() { + Some( + timeout(Duration::from_secs(10), hook_gate.accept()) + .await?? + .0, + ) } else { - fs::write(release, "")?; - wait_for_event(&test.codex, |event| { - matches!(event, EventMsg::TurnComplete(_)) + None + }; + if hook_async == Some(false) { + assert!(accounting.reports.lock().expect("usage reports").is_empty()); + } + if case == InterruptedHook { + let started = wait_for_event_match(&test.codex, |event| match event { + EventMsg::HookStarted(started) + if started.run.event_name == HookEventName::PostModelRequest + && started.run.handler_type + == codex_protocol::protocol::HookHandlerType::Command => + { + Some(started.clone()) + } + _ => None, }) .await; - let events = fs::read_to_string(order)?; - assert!( - events.starts_with(if sync_post { "post\ntool\n" } else { "tool\n" }), - "{events}" + test.codex.submit(Op::Interrupt).await?; + let mut stopped = None; + let mut aborted = false; + wait_for_event(&test.codex, |event| { + match event { + EventMsg::HookCompleted(completed) if completed.run.id == started.run.id => { + stopped = Some(completed.clone()); + } + EventMsg::TurnAborted(_) => aborted = true, + _ => {} + } + aborted && stopped.is_some() + }) + .await; + let stopped = stopped.expect("post-hook must emit a terminal event after interruption"); + assert_eq!(stopped.turn_id, started.turn_id); + assert_eq!(stopped.run.id, started.run.id); + assert_eq!(stopped.run.status, HookRunStatus::Stopped); + assert_eq!( + stopped.run.status_message.as_deref(), + Some("Hook cancelled because the turn was interrupted"), ); + drop(held_hook); + assert!(accounting.reports.lock().expect("usage reports").is_empty()); + return Ok(()); } + drop(held_hook); + wait_for_event(&test.codex, |event| { + matches!(event, EventMsg::TurnComplete(_)) + }) + .await; + assert_eq!(fs::read_to_string(marker)?, "ran\n"); Ok(()) } diff --git a/codex-rs/core/tests/suite/scenarios.rs b/codex-rs/core/tests/suite/scenarios.rs index bb2ff29e2d..f04b93878a 100644 --- a/codex-rs/core/tests/suite/scenarios.rs +++ b/codex-rs/core/tests/suite/scenarios.rs @@ -4581,6 +4581,59 @@ async fn async_compaction_reuses_pending_work( let accounting = (outcome == PendingCompactionOutcome::Success).then(|| Arc::new(HostAccounting::default())); let mut builder = test_codex(); + let observe_attempts = outcome == PendingCompactionOutcome::Success && !manual; + let timeout = Duration::from_secs(/*secs*/ 20); + let post_started = Arc::new(tokio::sync::Notify::new()); + let (release_post, wait_for_release) = std::sync::mpsc::channel(); + let (record, recorded) = std::sync::mpsc::channel(); + // The harness owns the loopback MCP server. Hook inputs and waits do not + // depend on a shell or filesystem shared with the tool environment. + let _hook_server = if observe_attempts { + let server = start_mock_server().await; + core_test_support::hooks::mount_hook_mcp( + &server, + "compaction-observer", + &["pre", "post"], + { + let started = Arc::clone(&post_started); + let release = std::sync::Mutex::new(wait_for_release); + move |params| { + record.send(params.clone()).expect("record hook call"); + if observe_attempts + && params["name"] == "post" + && params["arguments"]["kind"] == "background_compaction" + { + started.notify_one(); + release + .lock() + .expect("post-hook gate") + .recv_timeout(timeout) + .expect("release background post-hook"); + } + json!({"content": []}) + } + }, + ) + .await; + let url = format!("{}/repl", server.uri()); + builder = builder.with_pre_build_hook(move |home| { + let hook = |tool, input| json!([{"hooks": [{ + "type": "mcp_tool", "server": "compaction-observer", "tool": tool, "input": input + }]}]); + let hooks = json!({ + "PreModelRequest": hook("pre", json!({"kind": "${kind}"})), + "PostModelRequest": hook("post", json!({"kind": "${kind}", "response_id": "${response_id}", "token_usage": "${token_usage}"})), + }); + let config = json!({"hooks": hooks, "mcp_servers": {"compaction-observer": { + "url": url, "environment_id": super::rmcp_client::remote_aware_environment_id() + }}}); + std::fs::write(home.join("config.toml"), toml::to_string(&config).expect("serialize hook config")) + .expect("install compaction hooks"); + }); + Some(server) + } else { + None + }; if let Some(accounting) = &accounting { let mut extensions = ExtensionRegistryBuilder::new(); extensions.thread_lifecycle_contributor(accounting.clone()); @@ -4597,6 +4650,9 @@ async fn async_compaction_reuses_pending_work( }, env, move |config| { + if observe_attempts { + core_test_support::hooks::trust_discovered_hooks(config); + } if over_budget { config.async_compaction_threshold_percent = 1; config.model_auto_compact_token_limit = Some(5_000); @@ -4605,7 +4661,6 @@ async fn async_compaction_reuses_pending_work( ) .await?; test.codex.ensure_rollout_materialized().await; - let timeout = Duration::from_secs(/*secs*/ 20); test.submit_text_turn("first").await?; if has_background { tokio::time::timeout(timeout, streaming.wait_for_request_count(/*count*/ 2)).await?; @@ -4678,6 +4733,24 @@ async fn async_compaction_reuses_pending_work( if has_background && let Some(release_background) = release_background { release_background.send(()).expect("release pending result"); } + if observe_attempts { + tokio::time::timeout(timeout, post_started.notified()).await?; + // The collector bills a background terminal event before returning its + // candidate. A blocked post-hook must still hold that event. + let billed_while_held = accounting + .as_ref() + .expect("successful background attempt") + .reports + .lock() + .expect("usage reports") + .iter() + .any(|report| report.usage.total_tokens == BACKGROUND_TOKENS); + release_post.send(()).expect("release the compaction hook"); + assert!( + !billed_while_held, + "background usage reached the collector before its post-hook finished" + ); + } let EventMsg::ItemStarted(started) = started else { unreachable!(); }; @@ -4733,6 +4806,28 @@ async fn async_compaction_reuses_pending_work( assert_eq!(charged_turns, [&usage("seed").turn_id]); } let continuation = usage("continuation"); + if observe_attempts { + let calls: Vec<_> = recorded.try_iter().collect(); + let compactions = |tool: &str| { + calls + .iter() + .filter(|call| call["name"] == tool) + .map(|call| &call["arguments"]) + .filter(|input| input["kind"] != "sampling") + .collect::>() + }; + let pre = compactions("pre"); + let post = compactions("post"); + assert_eq!( + (pre.len(), post.len()), + (1, 1), + "adopting the candidate must not run a second attempt" + ); + assert_eq!(pre[0]["kind"], "background_compaction"); + assert_eq!(post[0]["kind"], pre[0]["kind"]); + assert_eq!(post[0]["response_id"], "background"); + assert_eq!(post[0]["token_usage"]["total_tokens"], BACKGROUND_TOKENS); + } assert_eq!( ( continuation.turn_token_usage.total_tokens, diff --git a/codex-rs/hooks/schema/generated/model-request.command.input.schema.json b/codex-rs/hooks/schema/generated/model-request.command.input.schema.json index 86bf69b399..467b2d46b8 100644 --- a/codex-rs/hooks/schema/generated/model-request.command.input.schema.json +++ b/codex-rs/hooks/schema/generated/model-request.command.input.schema.json @@ -19,6 +19,14 @@ "null" ] }, + "SamplingKind": { + "enum": [ + "sampling", + "foreground_compaction", + "background_compaction" + ], + "type": "string" + }, "TokenUsage": { "properties": { "cache_write_input_tokens": { @@ -83,6 +91,14 @@ ], "type": "string" }, + "response_id": { + "allOf": [ + { + "$ref": "#/definitions/NullableString" + } + ], + "description": "The provider's identifier for the completed or incomplete response, if available." + }, "status": { "$ref": "#/definitions/ModelRequestStatus" }, @@ -100,6 +116,7 @@ "required": [ "error", "hook_event_name", + "response_id", "status", "token_usage" ], @@ -116,12 +133,19 @@ "cwd": { "$ref": "#/definitions/AbsolutePathBuf" }, + "kind": { + "$ref": "#/definitions/SamplingKind" + }, "model": { "type": "string" }, "session_id": { "type": "string" }, + "thread_id": { + "description": "Identifies the issuing thread within its shared session.", + "type": "string" + }, "transcript_path": { "$ref": "#/definitions/NullableString" }, @@ -131,8 +155,10 @@ }, "required": [ "cwd", + "kind", "model", "session_id", + "thread_id", "transcript_path", "turn_id" ], diff --git a/codex-rs/hooks/src/engine/command_runner.rs b/codex-rs/hooks/src/engine/command_runner.rs index 00cd404713..37c5d1a7cb 100644 --- a/codex-rs/hooks/src/engine/command_runner.rs +++ b/codex-rs/hooks/src/engine/command_runner.rs @@ -123,7 +123,9 @@ impl CommandHookRuntime { event_input: Value, cwd: std::path::PathBuf, turn_id: Option, - parse: fn(&ConfiguredHandler, HandlerRunResult, Option) -> ParsedHandler, + parse: impl Fn(&ConfiguredHandler, HandlerRunResult, Option) -> ParsedHandler + + Send + + 'static, ) { if self.result_sender.is_closed() { return; diff --git a/codex-rs/hooks/src/engine/dispatcher.rs b/codex-rs/hooks/src/engine/dispatcher.rs index cc45564933..73b1d9dd1b 100644 --- a/codex-rs/hooks/src/engine/dispatcher.rs +++ b/codex-rs/hooks/src/engine/dispatcher.rs @@ -128,6 +128,34 @@ pub(crate) async fn execute_handlers_with_metadata( turn_id: Option, metadata: Option<&Map>, parse: fn(&ConfiguredHandler, HandlerRunResult, Option) -> ParsedHandler, +) -> Vec> { + execute_handlers_with_progress( + engine, + handlers, + input, + cwd, + turn_id, + metadata, + parse, + |_| {}, + ) + .await +} + +#[allow(clippy::too_many_arguments)] +pub(crate) async fn execute_handlers_with_progress( + engine: &ClaudeHooksEngine, + handlers: Vec, + input: &Value, + cwd: &Path, + turn_id: Option, + metadata: Option<&Map>, + parse: impl Fn(&ConfiguredHandler, HandlerRunResult, Option) -> ParsedHandler + + Copy + + Send + + Sync + + 'static, + mut on_completed: impl FnMut(&HookCompletedEvent) + Send, ) -> Vec> { let mut executor_handlers = Vec::new(); let mut pending = FuturesUnordered::new(); @@ -169,6 +197,7 @@ pub(crate) async fn execute_handlers_with_metadata( should_block |= parsed.completed.run.status == HookRunStatus::Blocked; parsed.completion_order = completion_order; completion_order += 1; + on_completed(&parsed.completed); completed.push((configured_order, parsed)); } completed.sort_by_key(|(configured_order, _)| *configured_order); diff --git a/codex-rs/hooks/src/events/model_request.rs b/codex-rs/hooks/src/events/model_request.rs index 058d0b7016..ed26d3cfca 100644 --- a/codex-rs/hooks/src/events/model_request.rs +++ b/codex-rs/hooks/src/events/model_request.rs @@ -24,19 +24,22 @@ pub enum ModelRequestHookEvent { status: ModelRequestStatus, #[schemars(with = "crate::schema::NullableString")] error: Option, - #[schemars(required, schema_with = "token_usage_schema")] + #[schemars(required, schema_with = "nullable_schema::")] token_usage: Option, + /// The provider's identifier for the completed or incomplete response, if available. + #[schemars(with = "crate::schema::NullableString")] + response_id: Option, }, } // Hook schemas otherwise omit null from Option fields, but usage is always present on post. -fn token_usage_schema( +fn nullable_schema( generator: &mut schemars::r#gen::SchemaGenerator, ) -> schemars::schema::Schema { schemars::schema::SchemaObject { subschemas: Some(Box::new(schemars::schema::SubschemaValidation { any_of: Some(vec![ - generator.subschema_for::(), + generator.subschema_for::(), generator.subschema_for::<()>(), ]), ..Default::default() @@ -55,6 +58,44 @@ pub enum ModelRequestStatus { } impl ModelRequestHookEvent { + pub fn completed(response_id: &str, token_usage: Option<&TokenUsage>) -> Self { + Self::PostModelRequest { + status: ModelRequestStatus::Completed, + error: None, + token_usage: token_usage.cloned(), + response_id: Some(response_id.to_owned()), + } + } + + pub fn failed(error: &codex_protocol::error::CodexErr) -> Self { + use codex_protocol::error::CodexErrorDetails; + let (response_id, token_usage) = match error.details() { + CodexErrorDetails::TurnAborted | CodexErrorDetails::Interrupted => { + return Self::cancelled(); + } + CodexErrorDetails::ResponseIncomplete(incomplete) => ( + incomplete.response_id.clone(), + incomplete.token_usage.clone(), + ), + _ => (None, None), + }; + Self::PostModelRequest { + status: ModelRequestStatus::Failed, + error: Some(error.to_string()), + token_usage, + response_id, + } + } + + pub fn cancelled() -> Self { + Self::PostModelRequest { + status: ModelRequestStatus::Cancelled, + error: None, + token_usage: None, + response_id: None, + } + } + fn hook_event(&self) -> HookEventName { match self { Self::PreModelRequest => HookEventName::PreModelRequest, @@ -63,10 +104,24 @@ impl ModelRequestHookEvent { } } +#[derive(Clone, Copy, Debug, Serialize, JsonSchema)] +#[serde(rename_all = "snake_case")] +pub enum SamplingKind { + Sampling, + ForegroundCompaction, + BackgroundCompaction, +} + #[derive(Clone, Debug, Serialize, JsonSchema)] #[schemars(rename = "model-request.command.input")] pub struct ModelRequestHookInput { + /// Names the hook lifecycle for this attempt, including asynchronous completions. + #[serde(skip)] + pub lifecycle_id: uuid::Uuid, + pub kind: SamplingKind, pub session_id: String, + /// Identifies the issuing thread within its shared session. + pub thread_id: String, pub turn_id: String, pub cwd: AbsolutePathBuf, #[schemars(with = "crate::schema::NullableString")] @@ -80,6 +135,10 @@ pub struct ModelRequestHookInput { pub event: ModelRequestHookEvent, } +fn identify_run(run: &mut HookRunSummary, lifecycle_id: uuid::Uuid) { + run.id = format!("{}:{lifecycle_id}", run.id); +} + pub(crate) fn preview( handlers: &[ConfiguredHandler], request: &ModelRequestHookInput, @@ -90,13 +149,18 @@ pub(crate) fn preview( /*matcher_input*/ None, ) .iter() - .map(dispatcher::running_summary) + .map(|handler| { + let mut run = dispatcher::running_summary(handler); + identify_run(&mut run, request.lifecycle_id); + run + }) .collect() } pub(crate) async fn run( engine: &ClaudeHooksEngine, request: ModelRequestHookInput, + on_completed: impl FnMut(&HookCompletedEvent) + Send, ) -> Vec { let matched = dispatcher::select_handlers( &engine.handlers, @@ -109,20 +173,30 @@ pub(crate) async fn run( let input = match serde_json::to_value(&request) { Ok(input) => input, Err(error) => { - return common::serialization_failure_hook_events( + let mut events = common::serialization_failure_hook_events( matched, Some(request.turn_id), error.to_string(), ); + for event in &mut events { + identify_run(&mut event.run, request.lifecycle_id); + } + return events; } }; - dispatcher::execute_handlers( + dispatcher::execute_handlers_with_progress( engine, matched, &input, request.cwd.as_path(), Some(request.turn_id), - parse_completed, + /*metadata*/ None, + move |handler, result, turn_id| { + let mut parsed = parse_completed(handler, result, turn_id); + identify_run(&mut parsed.completed.run, request.lifecycle_id); + parsed + }, + on_completed, ) .await .into_iter() diff --git a/codex-rs/hooks/src/lib.rs b/codex-rs/hooks/src/lib.rs index 4e7c073d77..79f2a8be14 100644 --- a/codex-rs/hooks/src/lib.rs +++ b/codex-rs/hooks/src/lib.rs @@ -137,3 +137,4 @@ pub fn hook_key( pub use events::model_request::ModelRequestHookEvent; pub use events::model_request::ModelRequestHookInput; pub use events::model_request::ModelRequestStatus; +pub use events::model_request::SamplingKind; diff --git a/codex-rs/hooks/src/registry.rs b/codex-rs/hooks/src/registry.rs index 244ef75431..7e3954673e 100644 --- a/codex-rs/hooks/src/registry.rs +++ b/codex-rs/hooks/src/registry.rs @@ -33,6 +33,7 @@ use codex_config::ConfigLayerStack; use codex_plugin::ExecutorPluginHookSource; use codex_plugin::PluginHookSource; use codex_protocol::ThreadId; +use codex_protocol::protocol::HookCompletedEvent; use codex_protocol::protocol::HookEventName; use codex_protocol::protocol::HookExecutionMode; use codex_protocol::shell_environment::scrub_non_inheritable_env_vars; @@ -380,8 +381,9 @@ impl Hooks { pub async fn run_model_request( &self, request: crate::ModelRequestHookInput, - ) -> Vec { - crate::events::model_request::run(&self.engine, request).await + on_completed: impl FnMut(&HookCompletedEvent) + Send, + ) -> Vec { + crate::events::model_request::run(&self.engine, request, on_completed).await } }