Lightweight coding agent that runs in your terminal
Rust
Preserve originating turn metadata for yielded skill calls (#47106)
Eddie Chen6a601c00da85
diff --git a/codex-rs/analytics/src/client_tests.rs b/codex-rs/analytics/src/client_tests.rsindex 5175ec1bfd..b36829758e 100644--- a/codex-rs/analytics/src/client_tests.rs+++ b/codex-rs/analytics/src/client_tests.rs@@ -161,6 +161,7 @@ fn sample_skill_track_event(thread_id: &str, plugin_id: Option<&str>) -> TrackEvfn sample_artifact_operation_event(thread_id: &str) -> TrackEventRequest {TrackEventRequest::ArtifactOperation(codex_artifact_operation_event_request(TrackEventsContext {+ turn_metadata: None,model_slug: "gpt-5.1-codex".to_string(),thread_id: thread_id.to_string(),turn_id: "turn-1".to_string(),@@ -922,6 +923,7 @@ async fn flush_is_noop_when_analytics_is_disabled() {fn app_used_preserves_first_classification_and_emits_again_next_turn() {let (client, mut receiver) = client_with_receiver();let tracking = TrackEventsContext {+ turn_metadata: None,model_slug: "gpt-5".to_string(),thread_id: "thread-1".to_string(),turn_id: "turn-1".to_string(),diff --git a/codex-rs/analytics/src/facts.rs b/codex-rs/analytics/src/facts.rsindex a61a000a1a..4042b1fe08 100644--- a/codex-rs/analytics/src/facts.rs+++ b/codex-rs/analytics/src/facts.rs@@ -43,6 +43,7 @@ pub struct TrackEventsContext {pub thread_id: String,pub turn_id: String,pub product_client_id: String,+ pub turn_metadata: Option<Arc<dyn TurnAnalyticsMetadata>>,}#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)]@@ -137,12 +138,14 @@ pub fn build_track_events_context(thread_id: String,turn_id: String,product_client_id: String,+ turn_metadata: Option<Arc<dyn TurnAnalyticsMetadata>>,) -> TrackEventsContext {TrackEventsContext {model_slug,thread_id,turn_id,product_client_id,+ turn_metadata,}}diff --git a/codex-rs/analytics/src/tests/suite/tools_tests.rs b/codex-rs/analytics/src/tests/suite/tools_tests.rsindex 7e21000f5a..fab1d9aaf0 100644--- a/codex-rs/analytics/src/tests/suite/tools_tests.rs+++ b/codex-rs/analytics/src/tests/suite/tools_tests.rs@@ -657,12 +657,25 @@ async fn mcp_elicitation_classification_survives_turn_completion_and_preserves_c&mut reducer,&mut events,/*include_initialize*/ true,- /*include_resolved_config*/ true,+ /*include_resolved_config*/ false,/*include_started*/ true,/*include_token_usage*/ false,).await;+ let turn_metadata = test_turn_metadata(/*root_turn_id*/ None);+ reducer+ .ingest(+ AnalyticsFact::Custom(CustomAnalyticsFact::TurnResolvedConfig(Box::new(+ TurnResolvedConfigFact {+ turn_metadata,+ ..sample_turn_resolved_config("thread-2", "turn-2")+ },+ ))),+ &mut events,+ )+ .await;+let mut items = Vec::new();for (item_id, connector_id, elicitation_type) in [("auth", "calendar", Some(ElicitationType::AuthOrLink)),diff --git a/codex-rs/analytics/src/tests/support.rs b/codex-rs/analytics/src/tests/support.rsindex 7f66fc3f3d..995d302d13 100644--- a/codex-rs/analytics/src/tests/support.rs+++ b/codex-rs/analytics/src/tests/support.rs@@ -92,6 +92,7 @@ pub(super) fn test_tracking_context(thread_id: &str, turn_id: &str) -> TrackEventhread_id: thread_id.to_string(),turn_id: turn_id.to_string(),product_client_id: TEST_PRODUCT_CLIENT_ID.to_string(),+ turn_metadata: None,}}diff --git a/codex-rs/core/src/hook_runtime.rs b/codex-rs/core/src/hook_runtime.rsindex e3407cd1d6..d4d568d975 100644--- a/codex-rs/core/src/hook_runtime.rs+++ b/codex-rs/core/src/hook_runtime.rs@@ -962,6 +962,7 @@ fn hook_run_analytics_payload(.clone().unwrap_or_else(|| turn_context.sub_id.clone()),turn_context.originator.clone(),+ /*turn_metadata*/ None,),HookRunFact {event_name: completed.run.event_name,diff --git a/codex-rs/core/src/mcp_tool_call.rs b/codex-rs/core/src/mcp_tool_call.rsindex ad8f420b2d..0112be0b40 100644--- a/codex-rs/core/src/mcp_tool_call.rs+++ b/codex-rs/core/src/mcp_tool_call.rs@@ -1120,6 +1120,7 @@ async fn maybe_track_codex_app_used(sess.thread_id.to_string(),turn_context.sub_id.clone(),turn_context.originator.clone(),+ Some(turn_context.turn_metadata_state.clone()),);sess.services.analytics_events_client.track_app_used(tracking,diff --git a/codex-rs/core/src/session/turn.rs b/codex-rs/core/src/session/turn.rsindex c17ff03a7e..a69f26ca9a 100644--- a/codex-rs/core/src/session/turn.rs+++ b/codex-rs/core/src/session/turn.rs@@ -1021,6 +1021,7 @@ async fn build_skills_and_plugins(sess.thread_id.to_string(),turn_context.sub_id.clone(),turn_context.originator.clone(),+ Some(turn_context.turn_metadata_state.clone()),);let connector_snapshot = step_context.mcp.config().connector_snapshot.clone();let mcp_tools = if turn_context.apps_enabled() || !mentioned_plugins.is_empty() {diff --git a/codex-rs/core/src/skills.rs b/codex-rs/core/src/skills.rsindex ef610de3a7..6dd7938fb1 100644--- a/codex-rs/core/src/skills.rs+++ b/codex-rs/core/src/skills.rs@@ -203,6 +203,7 @@ pub(crate) async fn maybe_emit_implicit_skill_invocation(sess.thread_id.to_string(),turn_context.sub_id.clone(),turn_context.originator.clone(),+ Some(turn_context.turn_metadata_state.clone()),),vec![invocation],);diff --git a/codex-rs/core/src/tasks/lifecycle.rs b/codex-rs/core/src/tasks/lifecycle.rsindex 10057aaefa..27835be8fc 100644--- a/codex-rs/core/src/tasks/lifecycle.rs+++ b/codex-rs/core/src/tasks/lifecycle.rs@@ -1,5 +1,6 @@use std::sync::Arc;+use codex_analytics::TurnAnalyticsMetadata;use codex_extension_api::ExtensionData;use codex_extension_api::ThreadIdleCause;use codex_extension_api::TurnStartPhase;@@ -17,6 +18,8 @@ impl Session {token_usage_at_turn_start: Option<&TokenUsage>,phase: TurnStartPhase,) {+ let metadata: Arc<dyn TurnAnalyticsMetadata> = turn_context.turn_metadata_state.clone();+ turn_context.extension_data.insert(metadata);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/src/thread_manager_tests.rs b/codex-rs/core/src/thread_manager_tests.rsindex 89c39d5e44..278b69fa46 100644--- a/codex-rs/core/src/thread_manager_tests.rs+++ b/codex-rs/core/src/thread_manager_tests.rs@@ -227,6 +227,7 @@ async fn thread_analytics_opt_out_overrides_shared_client() {}services.analytics_events_client.track_app_used(codex_analytics::TrackEventsContext {+ turn_metadata: None,model_slug: "test-model".to_string(),turn_id: format!("test-turn-{thread_id}"),thread_id,diff --git a/codex-rs/core/src/tools/events.rs b/codex-rs/core/src/tools/events.rsindex faa1e6df91..18733704a6 100644--- a/codex-rs/core/src/tools/events.rs+++ b/codex-rs/core/src/tools/events.rs@@ -149,6 +149,7 @@ async fn emit_exec_command_begin(ctx: ToolEventCtx<'_>, exec_input: &ExecCommandctx.session.thread_id.to_string(),ctx.turn.sub_id.clone(),ctx.turn.originator.clone(),+ /*turn_metadata*/ None,),ArtifactOperation {item_id: ctx.call_id.to_string(),diff --git a/codex-rs/core/src/tools/handlers/request_plugin_install.rs b/codex-rs/core/src/tools/handlers/request_plugin_install.rsindex cb08cc5e13..271c12f30d 100644--- a/codex-rs/core/src/tools/handlers/request_plugin_install.rs+++ b/codex-rs/core/src/tools/handlers/request_plugin_install.rs@@ -230,6 +230,7 @@ impl RequestPluginInstallHandler {session.thread_id.to_string(),turn.sub_id.clone(),turn.originator.clone(),+ /*turn_metadata*/ None,),PluginInstallRequested {suggestion_id: suggestion_id.clone(),diff --git a/codex-rs/core/tests/suite/mcp_auth_elicitation.rs b/codex-rs/core/tests/suite/mcp_auth_elicitation.rsindex c324d05fd2..7bb75287ef 100644--- a/codex-rs/core/tests/suite/mcp_auth_elicitation.rs+++ b/codex-rs/core/tests/suite/mcp_auth_elicitation.rs@@ -266,13 +266,11 @@ approvals_reviewer = "user"&app::ClientResponsePayload::ThreadStart(thread_response),);- let submitted = test- .codex- .start_or_steer_turn(TurnInputRequest::user_input(vec to create a calendar event.".to_string(),- text_elements: Vec::new(),- }]))- .await?;+ let request = TurnInputRequest::user_input(vec to create a calendar event.".to_string(),+ text_elements: Vec::new(),+ }]);+ let submitted = test.codex.start_or_steer_turn(request).await?;let TurnInputSubmission::Started { turn_id } = submitted else {anyhow::bail!("expected a new turn, got {submitted:?}");};diff --git a/codex-rs/core/tests/suite/plugins.rs b/codex-rs/core/tests/suite/plugins.rsindex 17059ac861..41c77a4a33 100644--- a/codex-rs/core/tests/suite/plugins.rs+++ b/codex-rs/core/tests/suite/plugins.rs@@ -1922,12 +1922,13 @@ async fn explicit_plugin_mentions_track_plugin_used_analytics() -> Result<()> {let codex = Arc::clone(&test_codex.codex);codex- .start_or_steer_turn(TurnInputRequest::user_input(vec![- codex_protocol::user_input::UserInput::Mention {+ .start_or_steer_turn(+ TurnInputRequest::user_input(vec![codex_protocol::user_input::UserInput::Mention {name: "sample".into(),path: format!("plugin://{SAMPLE_PLUGIN_CONFIG_NAME}"),- },- ]))+ }])+ .with_responses_metadata(Some(std::collections::HashMap::from([]))),+ ).await?;wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;diff --git a/codex-rs/core/tests/suite/skills_extension/cloud_skill_tests.rs b/codex-rs/core/tests/suite/skills_extension/cloud_skill_tests.rsindex 2963f4fc8c..86b29f1d7e 100644--- a/codex-rs/core/tests/suite/skills_extension/cloud_skill_tests.rs+++ b/codex-rs/core/tests/suite/skills_extension/cloud_skill_tests.rs@@ -4,6 +4,9 @@ use super::*;use pretty_assertions::assert_eq;use tokio::sync::Mutex;+#[path = "yielded_skill_tests.rs"]+mod yielded_skill_tests;+struct FakeCloudSkillProvider {catalog: SkillCatalog,resources: std::collections::HashMap<String, String>,diff --git a/codex-rs/core/tests/suite/skills_extension/yielded_skill_tests.rs b/codex-rs/core/tests/suite/skills_extension/yielded_skill_tests.rsnew file mode 100644index 0000000000..034c77c49a--- /dev/null+++ b/codex-rs/core/tests/suite/skills_extension/yielded_skill_tests.rs@@ -0,0 +1,156 @@+//! Skill analytics retain the originating turn when Code Mode resumes a yielded cell.++use super::*;+use codex_core::TurnInputSubmission;+use codex_protocol::openai_models::ToolMode;+use pretty_assertions::assert_eq;++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn yielded_skill_read_keeps_originating_turn_metadata() -> Result<()> {+ skip_if_no_network!(Ok(()));++ const PACKAGE: &str = "skill://demo/yielded";+ const RESOURCE: &str = "skill://demo/yielded/SKILL.md";+ let server = responses::start_mock_server().await;+ let mut extensions = ExtensionRegistryBuilder::new();+ install_with_providers(+ &mut extensions,+ SkillProviders::new().with_cloud_provider(Arc::new(FakeCloudSkillProvider {+ catalog: SkillCatalog {+ entries: vec![SkillCatalogEntry::new(+ SkillPackageId(PACKAGE.to_string()),+ SkillAuthority::new(SkillSourceKind::Cloud, CODEX_APPS_MCP_SERVER_NAME),+ "demo:yielded",+ "Instructions for the yielded skill.",+ SkillResourceId::new(RESOURCE),+ )],+ warnings: Vec::new(),+ },+ resources: std::collections::HashMap::from([(+ RESOURCE.to_string(),+ "Yielded skill instructions.".to_string(),+ )]),+ reads: Mutex::default(),+ })),+ |config: &Config| SkillsExtensionConfig {+ include_instructions: config.include_skill_instructions,+ max_context_tokens: config.skill_max_context_tokens,+ bundled_skills_enabled: false,+ cloud_skill_enabled: true,+ shadow_selection_enabled: false,+ },+ );+ let chatgpt_base_url = server.uri();+ let mut builder = test_codex()+ .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())+ .with_exec_server_url("none")+ .with_extensions(Arc::new(extensions.build()))+ .with_model_info_override("gpt-5.5", |model| {+ model.tool_mode = Some(ToolMode::CodeMode);+ model.experimental_supported_tools = vec!["test_sync_tool".to_string()];+ })+ .with_config(move |config| {+ config.chatgpt_base_url = chatgpt_base_url;+ config.cloud_skill_enabled = true;+ config.features.enable(Feature::CodeMode).unwrap();+ config.features.enable(Feature::CodeModeHost).unwrap();+ })+ .with_code_mode_host_program(codex_utils_cargo_bin::cargo_bin("codex-code-mode-host")?);+ let test = builder.build_with_auto_env(&server).await?;+ // A cannot read its skill until B has become the active turn.+ let read_after_barrier = format!(+ r#"await tools.test_sync_tool({{barrier: {{+ id: "yielded-skill-turns", participants: 2, timeout_ms: 60000+ }}}});+ text(await tools.skills__read({{package: "{PACKAGE}"}}));"#+ );+ mount_sse_once(+ &server,+ sse(vec![+ ev_response_created("resp-a"),+ responses::ev_custom_tool_call(+ "call-a",+ "exec",+ &format!("// @exec: {{\"yield_time_ms\": 1}}\n{read_after_barrier}"),+ ),+ ev_completed("resp-a"),+ ]),+ )+ .await;+ let yielded = mount_sse_once(+ &server,+ sse(vec![+ ev_response_created("resp-a-done"),+ ev_completed("resp-a-done"),+ ]),+ )+ .await;+ let request = TurnInputRequest::user_input(vec![UserInput::Text {+ text: "Start a skill read and leave it running.".to_string(),+ text_elements: Vec::new(),+ }]);+ let submitted = test.codex.start_or_steer_turn(request).await?;+ let TurnInputSubmission::Started { turn_id: turn_a } = submitted else {+ anyhow::bail!("expected turn A to start, got {submitted:?}");+ };+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;+ let (output, _) = yielded+ .single_request()+ .custom_tool_call_output_content_and_success("call-a")+ .expect("yielded cell output");+ assert!(+ output+ .expect("yielded cell status")+ .starts_with("Script running with cell ID ")+ );++ mount_sse_once(+ &server,+ sse(vec![+ ev_response_created("resp-b"),+ responses::ev_custom_tool_call(+ "call-b",+ "exec",+ &format!("// @exec: {{\"yield_time_ms\": 60000}}\n{read_after_barrier}"),+ ),+ ev_completed("resp-b"),+ ]),+ )+ .await;+ mount_sse_once(+ &server,+ sse(vec![+ ev_response_created("resp-b-done"),+ ev_completed("resp-b-done"),+ ]),+ )+ .await;+ let submitted = test+ .codex+ .start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {+ text: "Read the skill in this turn and release the previous read.".to_string(),+ text_elements: Vec::new(),+ }]))+ .await?;+ let TurnInputSubmission::Started { turn_id: turn_b } = submitted else {+ anyhow::bail!("expected turn B to start, got {submitted:?}");+ };+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;++ let events = wait_for_analytics_events(&server, "skill_invocation", /*expected_count*/ 2).await;+ assert_eq!(events.len(), 2);+ for turn_id in [&turn_a, &turn_b] {+ let event = events+ .iter()+ .find(|event| event["event_params"]["turn_id"] == *turn_id)+ .expect("each skill read should retain its originating turn");+ assert_eq!(event["skill_name"], "demo:yielded");+ }+ Ok(())+}diff --git a/codex-rs/ext/skills/src/telemetry.rs b/codex-rs/ext/skills/src/telemetry.rsindex 070cbb9762..7728119eda 100644--- a/codex-rs/ext/skills/src/telemetry.rs+++ b/codex-rs/ext/skills/src/telemetry.rs@@ -25,6 +25,7 @@ pub fn record_plugin_turn_usage(turn_store: &ExtensionData, plugin_id: Option<&spub(crate) struct SkillTurnMetrics {pub(crate) turn_id: String,+ pub(crate) turn_metadata: Option<Arc<dyn codex_analytics::TurnAnalyticsMetadata>>,model_slug: String,pub(crate) reasoning_effort: String,started_at: Instant,@@ -111,6 +112,10 @@ impl TurnLifecycleContributor for SkillTelemetry {.unwrap_or_else(|| "default".to_string());input.turn_store.insert(SkillTurnMetrics {turn_id: input.turn_id.to_string(),+ turn_metadata: input+ .turn_store+ .get::<Arc<dyn codex_analytics::TurnAnalyticsMetadata>>()+ .map(|metadata| metadata.as_ref().clone()),model_slug: sanitize_metric_tag_value(input.collaboration_mode.model()),reasoning_effort,started_at: Instant::now(),diff --git a/codex-rs/ext/skills/src/tools/mod.rs b/codex-rs/ext/skills/src/tools/mod.rsindex c2743e8551..167d35893e 100644--- a/codex-rs/ext/skills/src/tools/mod.rs+++ b/codex-rs/ext/skills/src/tools/mod.rs@@ -46,6 +46,7 @@ use crate::sources::SkillProviders;use crate::state::SkillsSessionState;use crate::state::SkillsThreadState;use crate::telemetry::ActiveSkillTurnMetrics;+use crate::telemetry::SkillTurnMetrics;mod list;mod read;@@ -99,7 +100,7 @@ pub(crate) fn skill_tools(pub(crate) struct SkillAnalytics {client: AnalyticsEventsClient,metrics: Option<Arc<dyn ExtensionMetrics>>,- active_turn: Arc<ActiveSkillTurnMetrics>,+ turn_metrics: Option<Arc<SkillTurnMetrics>>,thread_id: String,product_client_id: String,}@@ -117,7 +118,13 @@ impl SkillAnalytics {metrics: session_store.get::<SkillsSessionState>().and_then(|state| state.extension_metrics.clone()),- active_turn: thread_store.get_or_init(ActiveSkillTurnMetrics::default),+ // Code-mode callbacks retain these tools after another turn becomes active.+ turn_metrics: thread_store+ .get_or_init(ActiveSkillTurnMetrics::default)+ .0+ .lock()+ .unwrap_or_else(std::sync::PoisonError::into_inner)+ .upgrade(),thread_id: thread_store.level_id().to_string(),product_client_id: originator.0.clone(),})@@ -131,11 +138,8 @@ impl SkillAnalytics {invocation_type: InvocationType,) {let turn_metrics = self- .active_turn- .0- .lock()- .unwrap_or_else(std::sync::PoisonError::into_inner)- .upgrade()+ .turn_metrics+ .as_ref().filter(|turn| turn.turn_id == turn_id);if let Some(turn_metrics) = &turn_metrics {turn_metrics.record_plugin(skill.plugin_id.as_deref());@@ -172,6 +176,7 @@ impl SkillAnalytics {self.thread_id.clone(),turn_id,self.product_client_id.clone(),+ turn_metrics.and_then(|turn| turn.turn_metadata.clone()),),vec![SkillInvocation {skill_name: skill.name.clone(),