Lightweight coding agent that runs in your terminal
Rust
Classify clock tools as built-in control tools (#41331)
jif430d26b543b2
diff --git a/codex-rs/app-server/tests/suite/v2/sleep.rs b/codex-rs/app-server/tests/suite/v2/sleep.rsindex b0b4a939f2..93542f4388 100644--- a/codex-rs/app-server/tests/suite/v2/sleep.rs+++ b/codex-rs/app-server/tests/suite/v2/sleep.rs@@ -15,16 +15,150 @@ use codex_app_server_protocol::TurnStartResponse;use codex_app_server_protocol::UserInput as V2UserInput;use core_test_support::responses;use pretty_assertions::assert_eq;+use serde_json::json;use std::time::Duration;use tempfile::TempDir;use tokio::time::timeout;+use super::analytics::captured_analytics_events;+use super::analytics::mount_analytics_capture;+use super::analytics::wait_for_matching_analytics_event;+#[cfg(windows)]const DEFAULT_READ_TIMEOUT: Duration = Duration::from_secs(25);#[cfg(not(windows))]const DEFAULT_READ_TIMEOUT: Duration = Duration::from_secs(10);const CURRENT_TIME_AT: i64 = 1_781_717_655;+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn clock_tools_emit_control_tool_analytics() -> Result<()> {+ let calls = [+ ("curr_time", json!({}), "completed"),+ ("sleep", json!({"duration_ms": 1}), "completed"),+ (+ "sleep",+ json!({"duration_ms": "PRIVATE_INVALID_DURATION"}),+ "failed",+ ),+ ("sleep", json!({"duration_ms": 43_200_000}), "interrupted"),+ ];+ let server = responses::start_mock_server().await;+ let response_mock = responses::mount_sse_sequence(+ &server,+ calls+ .iter()+ .enumerate()+ .map(|(index, (tool, arguments, _))| {+ let response_id = format!("resp-{index}");+ responses::sse(vec![+ responses::ev_response_created(&response_id),+ responses::ev_function_call_with_namespace(+ &format!("call-{index}"),+ "clock",+ tool,+ &arguments.to_string(),+ ),+ responses::ev_completed(&response_id),+ ])+ })+ .collect(),+ )+ .await;+ let codex_home = TempDir::new()?;+ MockResponsesConfig::new(&server.uri())+ .with_root_config(&format!("chatgpt_base_url = \"{}\"", server.uri()))+ .with_provider_config("supports_websockets = false")+ .with_extra_config("[features.current_time_reminder]\nenabled = true\nsleep_tool = true")+ .write(codex_home.path())?;+ mount_analytics_capture(&server, codex_home.path()).await?;+ let mut app_server = TestAppServer::builder()+ .with_codex_home(codex_home.path())+ .with_env_overrides(&[("OPENAI_API_KEY", None)])+ .without_managed_config()+ .build_initialized()+ .await?;+ let thread = app_server+ .start_thread(ThreadStartParams::default())+ .await?+ .thread;+ let TurnStartResponse { turn } = app_server+ .request(|request_id| ClientRequest::TurnStart {+ request_id,+ params: TurnStartParams {+ thread_id: thread.id.clone(),+ input: vec![V2UserInput::Text {+ text: "Exercise clock tools".to_string(),+ text_elements: Vec::new(),+ }],+ ..Default::default()+ },+ })+ .await?;+ wait_for_sleep_started(&mut app_server, "call-3").await?;+ app_server+ .interrupt_turn_and_wait_for_aborted(+ thread.id.clone(),+ turn.id.clone(),+ DEFAULT_READ_TIMEOUT,+ )+ .await?;+ let turn_event = wait_for_matching_analytics_event(&server, DEFAULT_READ_TIMEOUT, |event| {+ event["event_type"] == "codex_turn_event" && event["event_params"]["turn_id"] == turn.id+ })+ .await?;+ timeout(DEFAULT_READ_TIMEOUT, app_server.shutdown_gracefully()).await??;++ let events = captured_analytics_events(&server).await;+ let mut control_events = events+ .iter()+ .filter(|event| event["event_type"] == "codex_control_tool_call_event")+ .collect::<Vec<_>>();+ control_events.sort_by_key(|event| event["event_params"]["item_id"].as_str());+ assert_eq!(+ control_events+ .iter()+ .map(|event| {+ let params = &event["event_params"];+ json!({+ "tool": params["tool_name"],+ "call": params["item_id"],+ "thread": params["thread_id"],+ "turn": params["turn_id"],+ "status": params["terminal_status"],+ "origin": params["originating_response_id"],+ "duration": params["execution_duration_ms"].is_u64(),+ })+ })+ .collect::<Vec<_>>(),+ calls+ .iter()+ .enumerate()+ .map(|(index, (tool, _, status))| json!({+ "tool": format!("clock.{tool}"),+ "call": format!("call-{index}"),+ "thread": thread.id,+ "turn": turn.id,+ "status": status,+ "origin": format!("resp-{index}"),+ "duration": true,+ }))+ .collect::<Vec<_>>()+ );+ let control_json = serde_json::to_string(&control_events)?;+ for private_content in ["PRIVATE_INVALID_DURATION", "It is ", "Sleep completed."] {+ assert!(!control_json.contains(private_content));+ }+ assert_eq!(+ json!({+ "total": turn_event["event_params"]["total_tool_call_count"],+ "dynamic": turn_event["event_params"]["dynamic_tool_call_count"],+ }),+ json!({"total": calls.len(), "dynamic": 0})+ );+ assert_eq!(response_mock.requests().len(), calls.len());+ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn external_sleep_polls_current_time_and_emits_items() -> Result<()> {const CALL_ID: &str = "sleep-1";diff --git a/codex-rs/core/src/tools/handlers/current_time.rs b/codex-rs/core/src/tools/handlers/current_time.rsindex c0a9e61201..4cd410595e 100644--- a/codex-rs/core/src/tools/handlers/current_time.rs+++ b/codex-rs/core/src/tools/handlers/current_time.rs@@ -107,4 +107,8 @@ impl ToolExecutor<ToolInvocation> for CurrentTimeHandler {}}-impl CoreToolRuntime for CurrentTimeHandler {}+impl CoreToolRuntime for CurrentTimeHandler {+ fn is_builtin_control_tool(&self) -> bool {+ true+ }+}diff --git a/codex-rs/core/src/tools/handlers/sleep.rs b/codex-rs/core/src/tools/handlers/sleep.rsindex 179157a6bf..7defc8314b 100644--- a/codex-rs/core/src/tools/handlers/sleep.rs+++ b/codex-rs/core/src/tools/handlers/sleep.rs@@ -156,4 +156,8 @@ impl ToolExecutor<ToolInvocation> for SleepHandler {}}-impl CoreToolRuntime for SleepHandler {}+impl CoreToolRuntime for SleepHandler {+ fn is_builtin_control_tool(&self) -> bool {+ true+ }+}