restore reasoning prefix

codex-rs/core/src/analytics_client.rs

@@ -31,8 +31,8 @@ pub(crate) struct TrackEventsContext {
 #[derive(Clone)]
 pub(crate) struct TurnMetadata {
     pub(crate) sandbox_policy: SandboxPolicy,
-    pub(crate) effort: Option<ReasoningEffort>,
-    pub(crate) summary: ReasoningSummary,
+    pub(crate) reasoning_effort: Option<ReasoningEffort>,
+    pub(crate) reasoning_summary: ReasoningSummary,
     pub(crate) service_tier: Option<ServiceTier>,
     pub(crate) collaboration_mode: ModeKind,
 }
@@ -390,8 +390,8 @@ struct CodexTurnMetadata {
     product_client_id: Option<String>,
     model_slug: Option<String>,
     sandbox_policy: Option<&'static str>,
-    effort: Option<String>,
-    summary: Option<String>,
+    reasoning_effort: Option<String>,
+    reasoning_summary: Option<String>,
     service_tier: Option<String>,
     collaboration_mode: Option<&'static str>,
 }
@@ -738,8 +738,10 @@ fn codex_turn_metadata(
         product_client_id: Some(crate::default_client::originator().value),
         model_slug: Some(tracking.model_slug.clone()),
         sandbox_policy: Some(sandbox_policy_mode(&turn_metadata.sandbox_policy)),
-        effort: turn_metadata.effort.map(|value| value.to_string()),
-        summary: Some(turn_metadata.summary.to_string()),
+        reasoning_effort: turn_metadata
+            .reasoning_effort
+            .map(|value| value.to_string()),
+        reasoning_summary: Some(turn_metadata.reasoning_summary.to_string()),
         service_tier: turn_metadata.service_tier.map(|value| value.to_string()),
         collaboration_mode: Some(collaboration_mode_mode(turn_metadata.collaboration_mode)),
     }

codex-rs/core/src/analytics_client_tests.rs

@@ -206,8 +206,8 @@ fn turn_metadata_event_serializes_expected_shape() {
             &tracking,
             TurnMetadata {
                 sandbox_policy: SandboxPolicy::new_read_only_policy(),
-                effort: Some(ReasoningEffort::High),
-                summary: ReasoningSummary::Detailed,
+                reasoning_effort: Some(ReasoningEffort::High),
+                reasoning_summary: ReasoningSummary::Detailed,
                 service_tier: Some(ServiceTier::Flex),
                 collaboration_mode: ModeKind::Plan,
             },
@@ -226,8 +226,8 @@ fn turn_metadata_event_serializes_expected_shape() {
                 "product_client_id": crate::default_client::originator().value,
                 "model_slug": "gpt-5",
                 "sandbox_policy": "read_only",
-                "effort": "high",
-                "summary": "detailed",
+                "reasoning_effort": "high",
+                "reasoning_summary": "detailed",
                 "service_tier": "flex",
                 "collaboration_mode": "plan"
             }

codex-rs/core/src/codex.rs

@@ -5666,8 +5666,8 @@ pub(crate) async fn run_turn(
             tracking.clone(),
             TurnMetadata {
                 sandbox_policy: turn_context.sandbox_policy.get().clone(),
-                effort: turn_context.reasoning_effort,
-                summary: turn_context.reasoning_summary,
+                reasoning_effort: turn_context.reasoning_effort,
+                reasoning_summary: turn_context.reasoning_summary,
                 service_tier: turn_context.config.service_tier,
                 collaboration_mode: turn_context.collaboration_mode.mode,
             },

codex-rs/core/tests/suite/items.rs

@@ -215,8 +215,8 @@ async fn user_turn_tracks_turn_metadata_analytics() -> anyhow::Result<()> {
         serde_json::json!(codex_core::default_client::originator().value)
     );
     assert_eq!(event_params["model_slug"], session_configured.model);
-    assert_eq!(event_params["effort"], "high");
-    assert_eq!(event_params["summary"], "detailed");
+    assert_eq!(event_params["reasoning_effort"], "high");
+    assert_eq!(event_params["reasoning_summary"], "detailed");
     assert_eq!(event_params["service_tier"], "flex");
     assert_eq!(event_params["collaboration_mode"], "plan");
     assert!(event_params["thread_id"].as_str().is_some());