Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Measure Guardian approval blocking time per turn (#55591)

ioanbudea-OAI60d78332fc6a
diff --git a/codex-rs/core/src/tasks/lifecycle.rs b/codex-rs/core/src/tasks/lifecycle.rs
index afecaede5a..07a2c850a8 100644
--- a/codex-rs/core/src/tasks/lifecycle.rs
+++ b/codex-rs/core/src/tasks/lifecycle.rs
@@ -21,6 +21,9 @@ impl Session {
) {
let metadata: Arc<dyn TurnAnalyticsMetadata> = turn_context.turn_metadata_state.clone();
turn_context.extension_data.insert(metadata);
+ turn_context
+ .extension_data
+ .insert(turn_context.session_telemetry.clone());
let collaboration_mode = turn_context.collaboration_mode();
for contributor in self.services.extensions.turn_lifecycle_contributors() {
if contributor.turn_start_phase(&self.services.thread_extension_data) != phase {
diff --git a/codex-rs/core/tests/suite/guardian_mcp_elicitation.rs b/codex-rs/core/tests/suite/guardian_mcp_elicitation.rs
index ab6bf48c1f..1193fe6648 100644
--- a/codex-rs/core/tests/suite/guardian_mcp_elicitation.rs
+++ b/codex-rs/core/tests/suite/guardian_mcp_elicitation.rs
@@ -8,6 +8,8 @@ use codex_extension_api::ExtensionRegistryBuilder;
use codex_extension_api::McpServerContribution;
use codex_extension_api::McpServerContributionContext;
use codex_extension_api::McpServerContributor;
+use codex_otel::MetricsClient;
+use codex_otel::MetricsConfig;
use codex_protocol::config_types::ApprovalsReviewer;
use codex_protocol::items::McpToolCallStatus;
use codex_protocol::items::TurnItem;
@@ -27,9 +29,12 @@ use core_test_support::test_codex::local_requests;
use core_test_support::test_codex::test_codex;
use core_test_support::wait_for_event;
use core_test_support::wait_for_mcp_server;
+use opentelemetry_sdk::metrics::data::AggregatedMetrics;
+use opentelemetry_sdk::metrics::data::MetricData;
use pretty_assertions::assert_eq;
use serde_json::Value;
use serde_json::json;
+use std::collections::BTreeMap;
use std::sync::Arc;
use std::time::Duration;
use test_case::test_case;
@@ -955,6 +960,10 @@ async fn yielded_code_mode_elicitation_keeps_live_invocation_metadata() -> Resul
}
}))?;
let mut builder = test_codex()
+ .with_model_info_override("gpt-5.2", |model| {
+ model.tool_mode = Some(codex_protocol::openai_models::ToolMode::CodeMode);
+ model.experimental_supported_tools = vec!["test_sync_tool".to_string()];
+ })
.with_model_info_override("gpt-5.4", |model| {
model.tool_mode = Some(codex_protocol::openai_models::ToolMode::CodeMode);
model.experimental_supported_tools = vec!["test_sync_tool".to_string()];
@@ -968,7 +977,16 @@ async fn yielded_code_mode_elicitation_keeps_live_invocation_metadata() -> Resul
config.approvals_reviewer = ApprovalsReviewer::User;
config.mcp_servers.set(mcp_servers).unwrap();
});
- let test = builder.build_with_auto_env(&server).await?;
+ let mut test = builder.build_with_auto_env(&server).await?;
+ let metrics = MetricsClient::new(
+ MetricsConfig::in_memory("test", "test", "1", Default::default()).with_runtime_reader(),
+ )?;
+ let mut options = test.start_thread_options().await;
+ options.history_mode = Some(codex_protocol::protocol::ThreadHistoryMode::Legacy);
+ options.thread_extension_init.insert(metrics.clone());
+ let thread = test.thread_manager.start_thread(options).await?;
+ test.codex.shutdown_and_wait().await?;
+ test.codex = thread.thread;
wait_for_mcp_server(&test.codex, "node_repl").await?;
let barrier = r#"await tools.test_sync_tool({barrier: {
id: "elicitation-origin", participants: 2, timeout_ms: 60000
@@ -1043,10 +1061,16 @@ async fn yielded_code_mode_elicitation_keeps_live_invocation_metadata() -> Resul
)
.await;
test.codex
- .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
- text: "Run B and wait for A.".into(),
- text_elements: Vec::new(),
- }]))
+ .start_or_steer_turn(
+ TurnInputRequest::user_input(vec![UserInput::Text {
+ text: "Run B and wait for A.".into(),
+ text_elements: Vec::new(),
+ }])
+ .with_thread_settings(ThreadSettingsOverrides {
+ model: Some("gpt-5.2".into()),
+ ..Default::default()
+ }),
+ )
.await?;
let mut invocation_id = None;
let mut assessment_target = None;
@@ -1081,5 +1105,37 @@ async fn yielded_code_mode_elicitation_keeps_live_invocation_metadata() -> Resul
.count(),
1
);
+ test.codex.shutdown_and_wait().await?;
+ let mut samples = guardian_blocking_samples(&metrics, "model")?;
+ assert_eq!(samples.remove("gpt-5.4"), Some(0.0));
+ assert!(samples.remove("gpt-5.2").unwrap() > 0.0);
+ assert!(samples.is_empty());
Ok(())
}
+
+/// Reads per-turn samples shared by command and MCP approval regressions.
+pub(super) fn guardian_blocking_samples(
+ metrics: &MetricsClient,
+ label: &str,
+) -> Result<BTreeMap<String, f64>> {
+ let snapshot = metrics.snapshot()?;
+ let metric = snapshot
+ .scope_metrics()
+ .flat_map(opentelemetry_sdk::metrics::data::ScopeMetrics::metrics)
+ .find(|metric| metric.name() == "codex.guardian.turn.blocking_ms")
+ .context("blocking histogram")?;
+ let AggregatedMetrics::F64(MetricData::Histogram(histogram)) = metric.data() else {
+ panic!("expected blocking histogram");
+ };
+ histogram
+ .data_points()
+ .map(|point| {
+ let attribute = point
+ .attributes()
+ .find(|tag| tag.key.as_str() == label)
+ .context("blocking metric label")?;
+ assert_eq!(point.count(), 1);
+ Ok((attribute.value.as_str().to_string(), point.sum()))
+ })
+ .collect()
+}
diff --git a/codex-rs/core/tests/suite/guardian_review.rs b/codex-rs/core/tests/suite/guardian_review.rs
index bd31aa799e..a0ef8c25b1 100644
--- a/codex-rs/core/tests/suite/guardian_review.rs
+++ b/codex-rs/core/tests/suite/guardian_review.rs
@@ -26,6 +26,8 @@ use codex_features::Feature;
use codex_history::RolloutItem;
use codex_login::CodexAuth;
use codex_models_manager::manager::RefreshStrategy;
+use codex_otel::MetricsClient;
+use codex_otel::MetricsConfig;
use codex_protocol::ThreadId;
use codex_protocol::config_types::ApprovalsReviewer;
use codex_protocol::config_types::WindowsSandboxLevel;
@@ -95,6 +97,7 @@ use wiremock::http::Method;
use wiremock::matchers::method;
use wiremock::matchers::path_regex;
+use super::guardian_mcp_elicitation::guardian_blocking_samples;
use super::network_approval::guardian_parent_catalog;
use super::rmcp_client::remote_aware_environment_id;
use super::rmcp_client::remote_aware_stdio_server_bin;
@@ -2806,7 +2809,16 @@ async fn yielded_code_mode_denials_interrupt_the_servicing_turn() -> Result<()>
config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);
config.approvals_reviewer = ApprovalsReviewer::AutoReview;
});
- let test = builder.build_with_auto_env(&server).await?;
+ let mut test = builder.build_with_auto_env(&server).await?;
+ let metrics = MetricsClient::new(
+ MetricsConfig::in_memory("test", "test", "1", Default::default()).with_runtime_reader(),
+ )?;
+ let mut options = test.start_thread_options().await;
+ options.history_mode = Some(codex_protocol::protocol::ThreadHistoryMode::Legacy);
+ options.thread_extension_init.insert(metrics.clone());
+ let thread = test.thread_manager.start_thread(options).await?;
+ test.codex.shutdown_and_wait().await?;
+ test.codex = thread.thread;
let barrier = r#"await tools.test_sync_tool({barrier: {
id: "guardian-origin", participants: 2, timeout_ms: 60000
}});"#;
@@ -2950,5 +2962,145 @@ for (let index = 0; index < 6; index++) {{
1
);
}
+ test.codex.shutdown_and_wait().await?;
+ let mut samples = guardian_blocking_samples(&metrics, "outcome")?;
+ assert_eq!(samples.remove("completed"), Some(0.0));
+ assert!(samples.remove("aborted").unwrap() > 0.0);
+ assert!(samples.is_empty());
+ Ok(())
+}
+
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn guardian_blocking_follows_a_pending_review_across_turns() -> Result<()> {
+ skip_if_no_network!(Ok(()));
+ skip_if_sandbox!(Ok(()));
+
+ let code = r#"// @exec: {"yield_time_ms": 1}
+text(await tools.exec_command({
+ cmd: "echo spanning-review",
+ sandbox_permissions: "require_escalated",
+ justification: "Keep a Guardian review pending across turns."
+}));"#;
+ let (finish_a, a_gate) = tokio::sync::oneshot::channel();
+ let (finish_review, review_gate) = tokio::sync::oneshot::channel();
+ let chunk = |gate, events| StreamingSseChunk {
+ gate,
+ body: sse(events),
+ };
+ let (streaming, _) = start_streaming_sse_server(vec![
+ vec![
+ chunk(
+ /*gate*/ None,
+ vec![
+ ev_response_created("a"),
+ ev_custom_tool_call("cell-a", "exec", code),
+ ],
+ ),
+ chunk(Some(a_gate), vec![ev_completed("a")]),
+ ],
+ vec![chunk(
+ Some(review_gate),
+ vec![
+ ev_response_created("review"),
+ ev_assistant_message("assessment", r#"{"outcome":"deny"}"#),
+ ev_completed("review"),
+ ],
+ )],
+ vec![chunk(/*gate*/ None, vec![ev_completed("a-finished")])],
+ vec![chunk(
+ /*gate*/ None,
+ vec![
+ ev_function_call("wait-a", "wait", r#"{"cell_id":"1","yield_time_ms":60000}"#),
+ ev_completed("b"),
+ ],
+ )],
+ vec![chunk(/*gate*/ None, vec![ev_completed("b-finished")])],
+ ])
+ .await;
+ let server = start_mock_server().await;
+ let base_url = format!("{}/v1", streaming.uri());
+ let mut builder = test_codex().with_config(move |config| {
+ config.features.enable(Feature::CodeMode).unwrap();
+ config
+ .features
+ .disable(Feature::EnableRequestCompression)
+ .unwrap();
+ config.model_provider.base_url = Some(base_url);
+ config.model_provider.supports_websockets = false;
+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);
+ config.approvals_reviewer = ApprovalsReviewer::AutoReview;
+ });
+ for model in ["gpt-5.2", "gpt-5.4"] {
+ builder = builder.with_model_info_override(model, |info| {
+ info.tool_mode = Some(codex_protocol::openai_models::ToolMode::CodeMode);
+ });
+ }
+ let mut test = builder
+ .with_model("gpt-5.4")
+ .build_with_auto_env(&server)
+ .await?;
+ let metrics = MetricsClient::new(
+ MetricsConfig::in_memory("test", "test", "1", Default::default()).with_runtime_reader(),
+ )?;
+ let mut options = test.start_thread_options().await;
+ options.history_mode = Some(codex_protocol::protocol::ThreadHistoryMode::Legacy);
+ options.thread_extension_init.insert(metrics.clone());
+ let thread = test.thread_manager.start_thread(options).await?;
+ test.codex.shutdown_and_wait().await?;
+ test.codex = thread.thread;
+
+ test.codex
+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
+ text: "Start A and leave its cell running.".into(),
+ text_elements: Vec::new(),
+ }]))
+ .await?;
+ // The review has reached its backend before A is allowed to finish.
+ streaming.wait_for_request_count(/*count*/ 2).await;
+ finish_a.send(()).unwrap();
+ wait_for_event(&test.codex, |event| {
+ matches!(event, EventMsg::TurnComplete(_))
+ })
+ .await;
+ let requests = streaming.requests().await;
+ let yielded: Value = serde_json::from_slice(&requests[2])?;
+ let output = yielded["input"]
+ .as_array()
+ .unwrap()
+ .iter()
+ .find(|item| item["call_id"] == "cell-a" && item["type"] == "custom_tool_call_output")
+ .unwrap();
+ assert!(
+ output["output"]
+ .to_string()
+ .contains("Script running with cell ID 1"),
+ "{output}"
+ );
+
+ test.codex
+ .start_or_steer_turn(
+ TurnInputRequest::user_input(vec![UserInput::Text {
+ text: "Wait for A's cell.".into(),
+ text_elements: Vec::new(),
+ }])
+ .with_thread_settings(ThreadSettingsOverrides {
+ model: Some("gpt-5.2".into()),
+ ..Default::default()
+ }),
+ )
+ .await?;
+ // B is active while the same review is still blocked on its response gate.
+ streaming.wait_for_request_count(/*count*/ 4).await;
+ finish_review.send(()).unwrap();
+ wait_for_event(&test.codex, |event| {
+ matches!(event, EventMsg::TurnComplete(_))
+ })
+ .await;
+ test.codex.shutdown_and_wait().await?;
+ let samples = guardian_blocking_samples(&metrics, "model")?;
+ assert_eq!(samples.len(), 2);
+ assert!(samples["gpt-5.4"] > 0.0);
+ assert!(samples["gpt-5.2"] > 0.0);
+ streaming.shutdown().await;
Ok(())
}
diff --git a/codex-rs/ext/guardian-reviewer/src/blocking.rs b/codex-rs/ext/guardian-reviewer/src/blocking.rs
new file mode 100644
index 0000000000..0daecf7f40
--- /dev/null
+++ b/codex-rs/ext/guardian-reviewer/src/blocking.rs
@@ -0,0 +1,149 @@
+//! Splits the union of thread-owned approval waits across active turns.
+//! Turn completion exports one sample; pending reviews survive idle gaps and turn changes.
+//! Saved durations are removed when their turn finishes or its handle drops.
+
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::sync::Mutex;
+use std::sync::PoisonError;
+use std::sync::Weak;
+use std::time::Duration;
+use std::time::Instant;
+
+/// Tracks pending approvals independently of the turn currently servicing them.
+#[derive(Default)]
+pub struct ReviewBlocking {
+ state: Mutex<State>,
+}
+
+#[derive(Default)]
+struct State {
+ interval: Interval,
+ turn: Option<String>,
+ completed: HashMap<String, Duration>,
+}
+
+/// Identifies a turn's sample and removes it when the turn is released.
+pub struct ReviewBlockingTurn {
+ id: String,
+ tracker: Weak<ReviewBlocking>,
+ telemetry: Arc<codex_otel::SessionTelemetry>,
+}
+
+impl State {
+ fn start_turn(&mut self, turn_id: &str, now: Instant) {
+ if let Some(previous) = self.turn.replace(turn_id.to_owned()) {
+ self.completed
+ .insert(previous, self.interval.finish_turn(now));
+ }
+ self.interval.start_turn(now);
+ }
+
+ fn finish_turn(&mut self, turn_id: &str, now: Instant) -> Option<Duration> {
+ if self.turn.as_deref() == Some(turn_id) {
+ self.turn = None;
+ Some(self.interval.finish_turn(now))
+ } else {
+ self.completed.remove(turn_id)
+ }
+ }
+}
+
+#[derive(Default)]
+struct Interval {
+ active: usize,
+ since: Option<Instant>,
+ elapsed: Duration,
+}
+
+impl Interval {
+ fn start_turn(&mut self, now: Instant) {
+ self.elapsed = Duration::ZERO;
+ self.since = (self.active > 0).then_some(now);
+ }
+
+ fn finish_turn(&mut self, now: Instant) -> Duration {
+ if let Some(since) = self.since.take() {
+ self.elapsed += now.saturating_duration_since(since);
+ }
+ std::mem::take(&mut self.elapsed)
+ }
+
+ fn enter(&mut self, now: Instant) {
+ if self.active == 0 {
+ self.since = Some(now);
+ }
+ self.active += 1;
+ }
+ fn leave(&mut self, now: Instant) {
+ self.active = self.active.saturating_sub(1);
+ if self.active == 0
+ && let Some(since) = self.since.take()
+ {
+ self.elapsed += now.saturating_duration_since(since);
+ }
+ }
+}
+
+impl ReviewBlocking {
+ pub fn start_turn(
+ self: &Arc<Self>,
+ turn_id: &str,
+ telemetry: Arc<codex_otel::SessionTelemetry>,
+ ) -> ReviewBlockingTurn {
+ self.state
+ .lock()
+ .unwrap_or_else(PoisonError::into_inner)
+ .start_turn(turn_id, Instant::now());
+ ReviewBlockingTurn {
+ id: turn_id.to_owned(),
+ tracker: Arc::downgrade(self),
+ telemetry,
+ }
+ }
+
+ pub fn finish_turn(&self, turn: &ReviewBlockingTurn, outcome: &'static str) {
+ let elapsed = self
+ .state
+ .lock()
+ .unwrap_or_else(PoisonError::into_inner)
+ .finish_turn(&turn.id, Instant::now());
+ if let Some(elapsed) = elapsed {
+ turn.telemetry.record_duration(
+ "codex.guardian.turn.blocking_ms",
+ elapsed,
+ &[("outcome", outcome)],
+ );
+ }
+ }
+
+ pub(crate) fn enter(self: &Arc<Self>) -> BlockingGuard {
+ let mut state = self.state.lock().unwrap_or_else(PoisonError::into_inner);
+ state.interval.enter(Instant::now());
+ BlockingGuard(Arc::clone(self))
+ }
+}
+
+impl Drop for ReviewBlockingTurn {
+ fn drop(&mut self) {
+ if let Some(tracker) = self.tracker.upgrade() {
+ tracker
+ .state
+ .lock()
+ .unwrap_or_else(PoisonError::into_inner)
+ .finish_turn(&self.id, Instant::now());
+ }
+ }
+}
+
+pub(crate) struct BlockingGuard(Arc<ReviewBlocking>);
+impl Drop for BlockingGuard {
+ fn drop(&mut self) {
+ let mut state = self.0.state.lock().unwrap_or_else(PoisonError::into_inner);
+ state.interval.leave(Instant::now());
+ }
+}
+
+#[cfg(test)]
+#[path = "blocking_tests.rs"]
+mod tests;
diff --git a/codex-rs/ext/guardian-reviewer/src/blocking_tests.rs b/codex-rs/ext/guardian-reviewer/src/blocking_tests.rs
new file mode 100644
index 0000000000..0d0a6553f4
--- /dev/null
+++ b/codex-rs/ext/guardian-reviewer/src/blocking_tests.rs
@@ -0,0 +1,68 @@
+//! Checks overlapping approvals and turn boundaries with an explicit clock.
+
+use super::*;
+use pretty_assertions::assert_eq;
+
+#[test]
+fn overlapping_reviews_span_turns_without_charging_idle_gaps() {
+ let start = Instant::now();
+ let mut interval = Interval::default();
+ interval.start_turn(start);
+ interval.enter(start);
+ interval.enter(start + Duration::from_millis(10));
+ interval.leave(start + Duration::from_millis(30));
+ assert_eq!(interval.elapsed, Duration::ZERO);
+ assert_eq!(
+ interval.finish_turn(start + Duration::from_millis(40)),
+ Duration::from_millis(40)
+ );
+ interval.start_turn(start + Duration::from_millis(60));
+ interval.leave(start + Duration::from_millis(70));
+ assert_eq!(
+ interval.finish_turn(start + Duration::from_millis(80)),
+ Duration::from_millis(10)
+ );
+ // A review that starts while idle contributes only after the next turn starts.
+ interval.enter(start + Duration::from_millis(100));
+ interval.start_turn(start + Duration::from_millis(200));
+ interval.leave(start + Duration::from_millis(210));
+ assert_eq!(
+ interval.finish_turn(start + Duration::from_millis(220)),
+ Duration::from_millis(10)
+ );
+ interval.start_turn(start + Duration::from_millis(230));
+ interval.enter(start + Duration::from_millis(240));
+ interval.leave(start + Duration::from_millis(250));
+ interval.enter(start + Duration::from_millis(270));
+ interval.leave(start + Duration::from_millis(280));
+ assert_eq!(
+ interval.finish_turn(start + Duration::from_millis(300)),
+ Duration::from_millis(20)
+ );
+ interval.start_turn(start + Duration::from_millis(310));
+ assert_eq!(
+ interval.finish_turn(start + Duration::from_millis(320)),
+ Duration::ZERO
+ );
+}
+
+#[test]
+fn late_turn_completion_preserves_both_samples_and_ignores_duplicate_stops() {
+ let start = Instant::now();
+ let mut state = State::default();
+ state.start_turn("a", start);
+ state.interval.enter(start + Duration::from_millis(10));
+ state.start_turn("b", start + Duration::from_millis(30));
+ assert_eq!(
+ state.finish_turn("a", start + Duration::from_millis(50)),
+ Some(Duration::from_millis(20))
+ );
+ assert_eq!(
+ state.finish_turn("a", start + Duration::from_millis(60)),
+ None
+ );
+ assert_eq!(
+ state.finish_turn("b", start + Duration::from_millis(70)),
+ Some(Duration::from_millis(40))
+ );
+}
diff --git a/codex-rs/ext/guardian-reviewer/src/lib.rs b/codex-rs/ext/guardian-reviewer/src/lib.rs
index 173401024a..94b078f738 100644
--- a/codex-rs/ext/guardian-reviewer/src/lib.rs
+++ b/codex-rs/ext/guardian-reviewer/src/lib.rs
@@ -3,6 +3,9 @@
//! The host supplies review attempts and enforces the resulting decision on the bound action.
mod assessment;
+mod blocking;
+pub use blocking::ReviewBlocking;
+pub use blocking::ReviewBlockingTurn;
mod circuit_breaker;
mod completion;
mod conversation;
diff --git a/codex-rs/ext/guardian-reviewer/src/routing.rs b/codex-rs/ext/guardian-reviewer/src/routing.rs
index c33aa1ae7e..28d97774ba 100644
--- a/codex-rs/ext/guardian-reviewer/src/routing.rs
+++ b/codex-rs/ext/guardian-reviewer/src/routing.rs
@@ -71,6 +71,10 @@ impl<H: ReviewHost> ReviewRequest<'_, H> {
.telemetry
.start_timer("codex.guardian.decision.duration_ms", &[])
.ok();
+ let _blocking = self
+ .thread_store
+ .get::<crate::ReviewBlocking>()
+ .map(|blocking| blocking.enter());
let runtime = self.thread_store.get::<crate::ReviewerTasks>();
let _task = runtime.as_ref().map(|runtime| runtime.tasks.token());
if runtime
diff --git a/codex-rs/ext/guardian-v2/src/sync_reviewer/mod.rs b/codex-rs/ext/guardian-v2/src/sync_reviewer/mod.rs
index 0aba3d653b..e6fb25fdca 100644
--- a/codex-rs/ext/guardian-v2/src/sync_reviewer/mod.rs
+++ b/codex-rs/ext/guardian-v2/src/sync_reviewer/mod.rs
@@ -22,6 +22,8 @@ use codex_extension_api::TurnAbortInput;
use codex_extension_api::TurnLifecycleContributor;
use codex_extension_api::TurnStartInput;
use codex_extension_api::TurnStopInput;
+use codex_guardian_reviewer::ReviewBlocking;
+use codex_guardian_reviewer::ReviewBlockingTurn;
use codex_guardian_reviewer::ReviewDenials;
use codex_guardian_reviewer::ReviewerPool;
use codex_guardian_reviewer::ReviewerTasks;
@@ -58,6 +60,7 @@ impl ThreadLifecycleContributor<Config> for GuardianExtension {
let manager = self.thread_manager.clone();
let parent_thread_id = input.thread_store.level_id().to_owned();
let runtime = input.thread_store.get_or_init(ReviewerTasks::default);
+ input.thread_store.get_or_init(ReviewBlocking::default);
input.thread_store.get_or_init(|| {
ReviewerPool::<GuardianReviewSession>::new(
Arc::clone(&runtime),
@@ -228,19 +231,39 @@ impl ThreadLifecycleContributor<Config> for GuardianExtension {
impl TurnLifecycleContributor for GuardianExtension {
fn on_turn_start<'a>(&'a self, input: TurnStartInput<'a>) -> ExtensionFuture<'a, ()> {
- Box::pin(ReviewDenials::clear_turn(input.thread_store, input.turn_id))
+ Box::pin(async move {
+ if input.thread_store.get::<ReviewerTasks>().is_some()
+ && let Some(telemetry) = input.turn_store.get()
+ {
+ let tracker = input.thread_store.get_or_init(ReviewBlocking::default);
+ input
+ .turn_store
+ .get_or_init(|| tracker.start_turn(input.turn_id, telemetry));
+ }
+ ReviewDenials::clear_turn(input.thread_store, input.turn_id).await;
+ })
}
fn on_turn_stop<'a>(&'a self, input: TurnStopInput<'a>) -> ExtensionFuture<'a, ()> {
- Box::pin(ReviewDenials::clear_turn(
- input.thread_store,
- input.turn_store.level_id(),
- ))
+ Box::pin(async move {
+ if let (Some(tracker), Some(turn)) = (
+ input.thread_store.get::<ReviewBlocking>(),
+ input.turn_store.get::<ReviewBlockingTurn>(),
+ ) {
+ tracker.finish_turn(&turn, "completed");
+ }
+ ReviewDenials::clear_turn(input.thread_store, input.turn_store.level_id()).await;
+ })
}
fn on_turn_abort<'a>(&'a self, input: TurnAbortInput<'a>) -> ExtensionFuture<'a, ()> {
- Box::pin(ReviewDenials::clear_turn(
- input.thread_store,
- input.turn_store.level_id(),
- ))
+ Box::pin(async move {
+ if let (Some(tracker), Some(turn)) = (
+ input.thread_store.get::<ReviewBlocking>(),
+ input.turn_store.get::<ReviewBlockingTurn>(),
+ ) {
+ tracker.finish_turn(&turn, "aborted");
+ }
+ ReviewDenials::clear_turn(input.thread_store, input.turn_store.level_id()).await;
+ })
}
}