Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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>) -> TrackEv
fn 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.rs
index 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.rs
index 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.rs
index 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) -> TrackEven
thread_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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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: &ExecCommand
ctx.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.rs
index 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.rs
index 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![UserInput::Text {
- text: "Use [$calendar](app://calendar) to create a calendar event.".to_string(),
- text_elements: Vec::new(),
- }]))
- .await?;
+ let request = TurnInputRequest::user_input(vec![UserInput::Text {
+ text: "Use [$calendar](app://calendar) 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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<&s
pub(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.rs
index 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(),