mirror of
https://github.com/openai/codex.git
synced 2026-11-19 22:30:42 +00:00
## What changed Stop collecting cumulative MCP tool attribution, sending it in Responses API request metadata, and writing it to rollout checkpoints. Use `model_search_state` for search provider history in new rollouts. When reading older rollouts, decode `mcp_attribution` only to determine whether Search MCP may have been used. Treat malformed or error attribution as possible Search MCP use so native search fallback stays disabled. ## Testing Add a history test that distinguishes legacy Search MCP use, an explicit record of no use, and missing attribution. GitOrigin-RevId: a145b5b6b7d2f423d989af10623ef21120f49d4d
1956 lines
70 KiB
Rust
1956 lines
70 KiB
Rust
use super::*;
|
|
|
|
use crate::responses_metadata::ANALYTICS_ENABLED_KEY;
|
|
use crate::responses_metadata::AUTO_REVIEW_ENABLED_KEY;
|
|
use crate::responses_metadata::CONTEXT_WINDOW_ID_KEY;
|
|
use crate::responses_metadata::CodexResponsesMetadata;
|
|
use crate::responses_metadata::CodexResponsesRequestKind;
|
|
use crate::responses_metadata::CompactionTurnMetadata;
|
|
use crate::responses_metadata::FORKED_FROM_ORDINAL_EXCLUSIVE_KEY;
|
|
use crate::responses_metadata::INSTALLATION_ID_KEY;
|
|
use crate::responses_metadata::LEGACY_CODE_MODE_TOOL_NAMES_KEY;
|
|
use crate::responses_metadata::NODE_REPL_AUTO_REVIEW_REQUIRED_KEY;
|
|
use crate::responses_metadata::NODE_REPL_DISABLED_KEY;
|
|
use crate::responses_metadata::PARENT_TURN_ID_KEY;
|
|
use crate::responses_metadata::ROOT_TURN_ID_KEY;
|
|
use crate::responses_metadata::SANDBOX_MODE_KEY;
|
|
use crate::responses_metadata::TOOL_NAMESPACES_INFO_KEY;
|
|
use crate::responses_metadata::TURN_TRIGGER_KEY;
|
|
use crate::responses_metadata::WINDOW_ID_KEY;
|
|
use crate::responses_metadata::WINDOW_NUMBER_KEY;
|
|
use crate::responses_metadata::validate_extra_metadata;
|
|
use crate::session::step_context::StepContext;
|
|
use crate::session::tests::make_session_and_context;
|
|
use crate::session::tests::update_turn_settings_for_test;
|
|
use codex_analytics::CompactionImplementation;
|
|
use codex_analytics::CompactionPhase;
|
|
use codex_analytics::CompactionReason;
|
|
use codex_analytics::CompactionTrigger;
|
|
use codex_analytics::TurnAnalyticsMetadata;
|
|
use codex_git_utils::GitSha;
|
|
use codex_git_utils::get_head_commit_hash;
|
|
use codex_models_manager::model_info::model_info_from_slug;
|
|
use codex_protocol::AgentPath;
|
|
use codex_protocol::config_types::WindowsSandboxLevel;
|
|
use codex_protocol::models::PermissionProfile;
|
|
use codex_protocol::openai_models::ReasoningEffort as ReasoningEffortConfig;
|
|
use codex_protocol::protocol::SessionSource;
|
|
use codex_protocol::protocol::SubAgentSource;
|
|
use codex_protocol::protocol::ThreadSource;
|
|
use codex_sandboxing::SandboxType;
|
|
use codex_sandboxing::get_platform_sandbox;
|
|
use codex_utils_absolute_path::AbsolutePathBuf;
|
|
use core_test_support::PathBufExt;
|
|
use core_test_support::PathExt;
|
|
use pretty_assertions::assert_eq;
|
|
use serde_json::Value;
|
|
use std::collections::HashMap;
|
|
use std::sync::Arc;
|
|
use std::time::Duration;
|
|
use tempfile::TempDir;
|
|
use tokio::process::Command;
|
|
|
|
fn test_mcp_turn_metadata_context() -> ExecutionMetadata<'static> {
|
|
ExecutionMetadata {
|
|
model: "gpt-5.4",
|
|
reasoning_effort: Some(ReasoningEffortConfig::High),
|
|
node_repl_disabled: false,
|
|
auto_review_enabled: true,
|
|
node_repl_auto_review_required: true,
|
|
}
|
|
}
|
|
|
|
fn test_turn_responses_metadata(
|
|
state: &TurnMetadataState,
|
|
window_id: &str,
|
|
) -> CodexResponsesMetadata {
|
|
state.to_responses_metadata(
|
|
"installation-a".to_string(),
|
|
window_id.to_string(),
|
|
CodexResponsesRequestKind::Turn,
|
|
)
|
|
}
|
|
|
|
fn test_turn_responses_metadata_json(state: &TurnMetadataState, window_id: &str) -> String {
|
|
test_turn_responses_metadata(state, window_id)
|
|
.turn_metadata_json()
|
|
.expect("turn metadata json")
|
|
}
|
|
|
|
fn test_compaction_responses_metadata_json(
|
|
state: &TurnMetadataState,
|
|
window_id: &str,
|
|
compaction: CompactionTurnMetadata,
|
|
) -> String {
|
|
state
|
|
.to_responses_metadata(
|
|
"installation-a".to_string(),
|
|
window_id.to_string(),
|
|
CodexResponsesRequestKind::Compaction(compaction),
|
|
)
|
|
.turn_metadata_json()
|
|
.expect("turn metadata json")
|
|
}
|
|
|
|
fn test_turn_metadata_header(state: &TurnMetadataState) -> String {
|
|
state
|
|
.responses_metadata_template()
|
|
.turn_metadata_json()
|
|
.expect("header")
|
|
}
|
|
|
|
async fn create_clean_git_repo(repo_name: &str) -> (TempDir, AbsolutePathBuf) {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let repo_path = temp_dir.path().join(repo_name).abs();
|
|
std::fs::create_dir_all(&repo_path).expect("create repo");
|
|
|
|
Command::new("git")
|
|
.args(["init"])
|
|
.current_dir(&repo_path)
|
|
.output()
|
|
.await
|
|
.expect("git init");
|
|
Command::new("git")
|
|
.args(["config", "user.name", "Test User"])
|
|
.current_dir(&repo_path)
|
|
.output()
|
|
.await
|
|
.expect("git config user.name");
|
|
Command::new("git")
|
|
.args(["config", "user.email", "test@example.com"])
|
|
.current_dir(&repo_path)
|
|
.output()
|
|
.await
|
|
.expect("git config user.email");
|
|
std::fs::write(repo_path.join("README.md"), "hello").expect("write file");
|
|
Command::new("git")
|
|
.args(["add", "."])
|
|
.current_dir(&repo_path)
|
|
.output()
|
|
.await
|
|
.expect("git add");
|
|
Command::new("git")
|
|
.args(["commit", "-m", "initial"])
|
|
.current_dir(&repo_path)
|
|
.output()
|
|
.await
|
|
.expect("git commit");
|
|
|
|
(temp_dir, repo_path)
|
|
}
|
|
|
|
async fn wait_for_git_enrichment(state: &TurnMetadataState) -> Value {
|
|
state.admit_git_enrichment();
|
|
tokio::time::timeout(Duration::from_secs(2), state.wait_for_git_enrichment())
|
|
.await
|
|
.expect("git enrichment should complete");
|
|
serde_json::from_str(&test_turn_metadata_header(state)).expect("json")
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn detached_memory_responses_metadata_starts_an_independent_root_turn() {
|
|
let (_temp_dir, repo_path) = create_clean_git_repo("repo-東京").await;
|
|
|
|
let thread_manager = crate::ThreadManager::with_models_provider_for_tests(
|
|
codex_login::CodexAuth::from_api_key("test"),
|
|
crate::config::test_config().await.model_provider,
|
|
);
|
|
|
|
let metadata = detached_memory_responses_metadata(
|
|
&thread_manager,
|
|
String::new(),
|
|
String::new(),
|
|
String::new(),
|
|
String::new(),
|
|
&SessionSource::Unknown,
|
|
&repo_path,
|
|
&PermissionProfile::read_only(),
|
|
Some("none"),
|
|
)
|
|
.await;
|
|
let header = metadata.turn_metadata_json().expect("header");
|
|
assert!(header.is_ascii());
|
|
assert!(!header.contains("東京"));
|
|
let parsed: Value = serde_json::from_str(&header).expect("valid json");
|
|
assert_eq!(parsed["request_kind"].as_str(), Some("memory"));
|
|
assert_eq!(
|
|
parsed["thread_source"].as_str(),
|
|
Some("memory_consolidation")
|
|
);
|
|
assert_eq!(parsed[SANDBOX_MODE_KEY].as_str(), Some("read-only"));
|
|
assert!(parsed.get("session_id").is_none());
|
|
assert!(parsed.get("thread_id").is_none());
|
|
assert!(parsed.get("forked_from_thread_id").is_none());
|
|
let turn_id = parsed["turn_id"].as_str().expect("memory turn ID");
|
|
uuid::Uuid::parse_str(turn_id).expect("memory turn ID is a UUID");
|
|
assert_eq!(parsed[ROOT_TURN_ID_KEY], parsed["turn_id"]);
|
|
let client_metadata = metadata.client_metadata(/*include_internal*/ true);
|
|
assert_eq!(
|
|
client_metadata.get("turn_id").map(String::as_str),
|
|
Some(turn_id)
|
|
);
|
|
assert_eq!(
|
|
client_metadata.get(ROOT_TURN_ID_KEY).map(String::as_str),
|
|
Some(turn_id)
|
|
);
|
|
assert!(parsed.get(WINDOW_ID_KEY).is_none());
|
|
|
|
let expected_repo_path = repo_path.to_string_lossy().into_owned();
|
|
let actual_repo_path = parsed
|
|
.get("workspaces")
|
|
.and_then(Value::as_object)
|
|
.and_then(|workspaces| workspaces.keys().next())
|
|
.expect("workspace path");
|
|
assert_eq!(actual_repo_path, &expected_repo_path);
|
|
let workspace = parsed
|
|
.get("workspaces")
|
|
.and_then(Value::as_object)
|
|
.and_then(|workspaces| workspaces.values().next())
|
|
.cloned()
|
|
.expect("workspace");
|
|
assert_eq!(
|
|
workspace.get("has_changes").and_then(Value::as_bool),
|
|
Some(false)
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn detached_memory_responses_metadata_omits_empty_workspace_metadata() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
|
|
let thread_manager = crate::ThreadManager::with_models_provider_for_tests(
|
|
codex_login::CodexAuth::from_api_key("test"),
|
|
crate::config::test_config().await.model_provider,
|
|
);
|
|
|
|
let header = detached_memory_responses_metadata(
|
|
&thread_manager,
|
|
String::new(),
|
|
String::new(),
|
|
String::new(),
|
|
String::new(),
|
|
&SessionSource::Unknown,
|
|
&cwd,
|
|
&PermissionProfile::read_only(),
|
|
/*sandbox*/ None,
|
|
)
|
|
.await
|
|
.turn_metadata_json()
|
|
.expect("detached memory should emit its request kind");
|
|
let parsed: Value = serde_json::from_str(&header).expect("valid json");
|
|
let turn_id = parsed["turn_id"].as_str().expect("memory turn ID");
|
|
uuid::Uuid::parse_str(turn_id).expect("memory turn ID is a UUID");
|
|
|
|
assert_eq!(
|
|
parsed,
|
|
serde_json::json!({
|
|
"turn_id": turn_id,
|
|
"root_turn_id": turn_id,
|
|
"request_kind": "memory",
|
|
"sandbox_mode": "read-only",
|
|
"thread_source": "memory_consolidation",
|
|
"turn_trigger": "memory_consolidation",
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test(start_paused = true)]
|
|
async fn memory_workspaces_times_out_pending_git_discovery() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
|
|
let workspaces = tokio::time::timeout(
|
|
Duration::from_secs(2),
|
|
memory_workspaces(&cwd, std::future::pending()),
|
|
)
|
|
.await
|
|
.expect("memory metadata should stop waiting for Git discovery");
|
|
|
|
assert!(workspaces.is_empty());
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[tokio::test]
|
|
async fn memory_workspaces_keep_observed_refs_when_status_exceeds_the_deadline() {
|
|
let (_temp_dir, repo) = create_clean_git_repo("repo").await;
|
|
let head = get_head_commit_hash(&repo).await.expect("read HEAD");
|
|
let url = "https://example.invalid/repo.git";
|
|
assert!(
|
|
Command::new("git")
|
|
.args(["remote", "add", "origin", url])
|
|
.current_dir(&repo)
|
|
.status()
|
|
.await
|
|
.expect("add remote")
|
|
.success()
|
|
);
|
|
|
|
// Only status reads the index; block it without delaying HEAD or remote discovery.
|
|
let index = repo.join(".git/index");
|
|
std::fs::remove_file(&index).expect("remove index");
|
|
assert!(
|
|
Command::new("mkfifo")
|
|
.arg(index.as_path())
|
|
.status()
|
|
.await
|
|
.expect("create index FIFO")
|
|
.success()
|
|
);
|
|
|
|
let started = tokio::time::Instant::now();
|
|
let workspaces = memory_workspaces(
|
|
&repo,
|
|
std::future::ready(Some(repo.as_path().to_path_buf())),
|
|
)
|
|
.await;
|
|
assert!(started.elapsed() >= MEMORY_GIT_METADATA_TIMEOUT);
|
|
assert_eq!(
|
|
serde_json::to_value(workspaces).expect("serialize workspaces"),
|
|
serde_json::json!({
|
|
(repo.to_string_lossy().into_owned()): {
|
|
"associated_remote_urls": {"origin": url},
|
|
"latest_git_commit_hash": head.0,
|
|
}
|
|
}),
|
|
);
|
|
}
|
|
|
|
#[test_case::test_case(true, false; "pending remotes")]
|
|
#[test_case::test_case(false, true; "pending HEAD")]
|
|
#[tokio::test(start_paused = true)]
|
|
async fn git_collection_keeps_independently_observed_refs_until_the_deadline(
|
|
head_ready: bool,
|
|
remotes_ready: bool,
|
|
) {
|
|
let head = "0123456789abcdef0123456789abcdef01234567";
|
|
let url = "https://example.invalid/repo.git";
|
|
let (send_head, head_probe) = tokio::sync::oneshot::channel();
|
|
let (send_remotes, remotes_probe) = tokio::sync::oneshot::channel();
|
|
let (send_status, status_probe) = tokio::sync::oneshot::channel();
|
|
if head_ready {
|
|
send_head.send(GitSha::new(head)).expect("send HEAD");
|
|
}
|
|
if remotes_ready {
|
|
let remotes =
|
|
BTreeMap::from([("origin".to_string(), url.try_into().expect("valid remote"))]);
|
|
send_remotes.send(remotes).expect("send remotes");
|
|
}
|
|
|
|
let start = tokio::time::Instant::now();
|
|
let mut latest = None;
|
|
let collect = collect_workspace_git_metadata(
|
|
async { GitHeadState::Commit(head_probe.await.expect("HEAD probe")) },
|
|
|updates| async move {
|
|
if let Ok(urls) = remotes_probe.await {
|
|
updates.send_replace(urls);
|
|
}
|
|
},
|
|
async { status_probe.await.ok() },
|
|
|workspace| latest = Some(workspace),
|
|
);
|
|
let _ = tokio::time::timeout(MEMORY_GIT_METADATA_TIMEOUT, collect).await;
|
|
|
|
assert_eq!(start.elapsed(), MEMORY_GIT_METADATA_TIMEOUT);
|
|
assert!(send_status.is_closed());
|
|
let workspace = latest.expect("workspace before deadline");
|
|
assert_eq!(
|
|
workspace.latest_git_commit_hash.as_deref(),
|
|
head_ready.then_some(head)
|
|
);
|
|
assert_eq!(
|
|
workspace
|
|
.associated_remote_urls
|
|
.as_ref()
|
|
.and_then(|urls| urls.get("origin"))
|
|
.map(SanitizedGitUrl::as_str),
|
|
remotes_ready.then_some(url),
|
|
);
|
|
assert_eq!(workspace.has_changes, None);
|
|
}
|
|
|
|
#[test]
|
|
fn turn_metadata_state_includes_sandbox_metadata() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
let permission_profile = PermissionProfile::read_only();
|
|
|
|
let state = TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
cwd,
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ true,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
);
|
|
|
|
let header = test_turn_metadata_header(&state);
|
|
let json: Value = serde_json::from_str(&header).expect("json");
|
|
let sandbox_name = json.get("sandbox").and_then(Value::as_str);
|
|
let sandbox_mode = json.get(SANDBOX_MODE_KEY).and_then(Value::as_str);
|
|
let auto_review_enabled = json.get(AUTO_REVIEW_ENABLED_KEY).and_then(Value::as_bool);
|
|
let session_id = json.get("session_id").and_then(Value::as_str);
|
|
let thread_id = json.get("thread_id").and_then(Value::as_str);
|
|
|
|
assert!(json.get("request_kind").is_none());
|
|
let expected_sandbox = get_platform_sandbox(/*windows_sandbox_enabled*/ false)
|
|
.map(SandboxType::as_metric_tag)
|
|
.unwrap_or("none");
|
|
assert_eq!(sandbox_name, Some(expected_sandbox));
|
|
assert_eq!(sandbox_mode, Some("read-only"));
|
|
assert_eq!(auto_review_enabled, Some(true));
|
|
assert_eq!(session_id, Some("session-a"));
|
|
assert_eq!(thread_id, Some("thread-a"));
|
|
assert_eq!(json["agent_name"].as_str(), Some("/root"));
|
|
assert!(json.get("forked_from_thread_id").is_none());
|
|
assert!(json.get("parent_thread_id").is_none());
|
|
assert!(json.get("subagent_kind").is_none());
|
|
assert!(json.get("session_source").is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn turn_metadata_state_includes_root_fork_lineage() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
let permission_profile = PermissionProfile::read_only();
|
|
let source_thread_id =
|
|
ThreadId::from_string("11111111-1111-4111-8111-111111111111").expect("thread id");
|
|
|
|
let state = TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
Some(source_thread_id),
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
cwd,
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
);
|
|
|
|
let header = test_turn_metadata_header(&state);
|
|
let json: Value = serde_json::from_str(&header).expect("json");
|
|
|
|
assert_eq!(
|
|
json["forked_from_thread_id"].as_str(),
|
|
Some("11111111-1111-4111-8111-111111111111")
|
|
);
|
|
assert!(json.get("parent_thread_id").is_none());
|
|
assert!(json.get("subagent_kind").is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn turn_metadata_state_includes_thread_spawn_subagent_parent_without_fork() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
let permission_profile = PermissionProfile::read_only();
|
|
let parent_thread_id =
|
|
ThreadId::from_string("22222222-2222-4222-8222-222222222222").expect("thread id");
|
|
|
|
let state = TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
Some(parent_thread_id),
|
|
&SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
|
|
parent_thread_id,
|
|
depth: 1,
|
|
agent_path: Some(AgentPath::root().join("worker").expect("agent path")),
|
|
agent_nickname: None,
|
|
agent_role: None,
|
|
}),
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
cwd,
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
);
|
|
|
|
let header = test_turn_metadata_header(&state);
|
|
let json: Value = serde_json::from_str(&header).expect("json");
|
|
|
|
assert!(json.get("forked_from_thread_id").is_none());
|
|
assert_eq!(
|
|
json["parent_thread_id"].as_str(),
|
|
Some("22222222-2222-4222-8222-222222222222")
|
|
);
|
|
assert_eq!(json["subagent_kind"].as_str(), Some("thread_spawn"));
|
|
assert_eq!(json["agent_name"].as_str(), Some("/root/worker"));
|
|
}
|
|
|
|
#[test]
|
|
fn turn_metadata_state_omits_fork_lineage_for_context_inheriting_subagent() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
let permission_profile = PermissionProfile::read_only();
|
|
let parent_thread_id =
|
|
ThreadId::from_string("33333333-3333-4333-8333-333333333333").expect("thread id");
|
|
|
|
let state = TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
Some(parent_thread_id),
|
|
Some(parent_thread_id),
|
|
&SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
|
|
parent_thread_id,
|
|
depth: 1,
|
|
agent_path: None,
|
|
agent_nickname: None,
|
|
agent_role: None,
|
|
}),
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
cwd,
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
);
|
|
|
|
let header = test_turn_metadata_header(&state);
|
|
let json: Value = serde_json::from_str(&header).expect("json");
|
|
|
|
assert!(json.get("forked_from_thread_id").is_none());
|
|
assert!(json.get(FORKED_FROM_ORDINAL_EXCLUSIVE_KEY).is_none());
|
|
assert_eq!(
|
|
json["parent_thread_id"].as_str(),
|
|
Some("33333333-3333-4333-8333-333333333333")
|
|
);
|
|
assert_eq!(json["subagent_kind"].as_str(), Some("thread_spawn"));
|
|
// V1 subagents have no canonical agent path and are intentionally unsupported by
|
|
// agent-name-addressed history and notes; their metadata falls back to the root agent.
|
|
assert_eq!(json["agent_name"].as_str(), Some("/root"));
|
|
|
|
let mcp_metadata = state
|
|
.current_meta_value_for_mcp_request(test_mcp_turn_metadata_context())
|
|
.expect("MCP request metadata");
|
|
assert_eq!(
|
|
mcp_metadata["forked_from_thread_id"].as_str(),
|
|
Some("33333333-3333-4333-8333-333333333333")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn turn_metadata_state_includes_known_parent_for_non_thread_spawn_subagents_without_fork() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
let permission_profile = PermissionProfile::read_only();
|
|
let parent_thread_id =
|
|
ThreadId::from_string("44444444-4444-4444-8444-444444444444").expect("thread id");
|
|
let sources = [
|
|
(SubAgentSource::Review, "review"),
|
|
(SubAgentSource::Other("guardian".to_string()), "guardian"),
|
|
];
|
|
|
|
for (subagent_source, subagent_kind) in sources {
|
|
let state = TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
Some(parent_thread_id),
|
|
&SessionSource::SubAgent(subagent_source),
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
cwd.clone(),
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
);
|
|
|
|
let header = test_turn_metadata_header(&state);
|
|
let json: Value = serde_json::from_str(&header).expect("json");
|
|
|
|
assert!(json.get("forked_from_thread_id").is_none());
|
|
assert_eq!(
|
|
json["parent_thread_id"].as_str(),
|
|
Some("44444444-4444-4444-8444-444444444444")
|
|
);
|
|
assert_eq!(json["subagent_kind"].as_str(), Some(subagent_kind));
|
|
assert_eq!(json["agent_name"].as_str(), Some("/root"));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn turn_metadata_state_includes_turn_started_at_unix_ms_after_start() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
let permission_profile = PermissionProfile::read_only();
|
|
|
|
let state = TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
cwd,
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
);
|
|
state.set_turn_started_at_unix_ms(/*turn_started_at_unix_ms*/ 1_700_000_000_123);
|
|
|
|
let header = test_turn_metadata_header(&state);
|
|
let json: Value = serde_json::from_str(&header).expect("json");
|
|
|
|
assert_eq!(
|
|
json["turn_started_at_unix_ms"].as_i64(),
|
|
Some(1_700_000_000_123)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn turn_metadata_state_includes_model_and_reasoning_effort_only_in_request_meta() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
let permission_profile = PermissionProfile::read_only();
|
|
|
|
let state = TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
cwd,
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
);
|
|
|
|
let header = test_turn_metadata_header(&state);
|
|
let header_json: Value = serde_json::from_str(&header).expect("json");
|
|
assert_eq!(header_json["agent_name"].as_str(), Some("/root"));
|
|
assert!(header_json.get("model").is_none());
|
|
assert!(header_json.get("reasoning_effort").is_none());
|
|
|
|
let meta = state
|
|
.current_meta_value_for_mcp_request(test_mcp_turn_metadata_context())
|
|
.expect("turn metadata should be present");
|
|
assert!(meta.get("agent_name").is_none());
|
|
assert!(meta.get("request_kind").is_none());
|
|
assert_eq!(meta["model"].as_str(), Some("gpt-5.4"));
|
|
assert_eq!(meta["reasoning_effort"].as_str(), Some("high"));
|
|
assert_eq!(meta[AUTO_REVIEW_ENABLED_KEY].as_bool(), Some(true));
|
|
assert_eq!(
|
|
meta[NODE_REPL_AUTO_REVIEW_REQUIRED_KEY].as_bool(),
|
|
Some(true)
|
|
);
|
|
|
|
let meta_without_reasoning_effort = state
|
|
.current_meta_value_for_mcp_request(ExecutionMetadata {
|
|
model: "gpt-5.4",
|
|
reasoning_effort: None,
|
|
node_repl_disabled: false,
|
|
auto_review_enabled: false,
|
|
node_repl_auto_review_required: false,
|
|
})
|
|
.expect("turn metadata should be present");
|
|
assert_eq!(
|
|
meta_without_reasoning_effort["model"].as_str(),
|
|
Some("gpt-5.4")
|
|
);
|
|
assert!(
|
|
meta_without_reasoning_effort
|
|
.get("reasoning_effort")
|
|
.is_none()
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn execution_metadata_applies_captured_settings_to_responses_metadata() {
|
|
let (_session, mut turn) = make_session_and_context().await;
|
|
let config = Arc::make_mut(&mut turn.config);
|
|
config.approvals_reviewer = codex_protocol::config_types::ApprovalsReviewer::AutoReview;
|
|
config.permissions.approval_policy =
|
|
crate::config::Constrained::allow_any(codex_protocol::protocol::AskForApproval::OnRequest);
|
|
update_turn_settings_for_test(&mut turn, |settings| {
|
|
let model_info = Arc::make_mut(&mut settings.model_info);
|
|
model_info.slug = "captured-step-model".to_string();
|
|
model_info.node_repl_auto_review_required = true;
|
|
model_info.node_repl_disabled = true;
|
|
});
|
|
let step_context = StepContext::for_test(Arc::new(turn));
|
|
|
|
let mut metadata = step_context.turn.turn_metadata_state.to_responses_metadata(
|
|
"installation-a".to_string(),
|
|
"window-a".to_string(),
|
|
CodexResponsesRequestKind::Turn,
|
|
);
|
|
ExecutionMetadata::from_settings(&step_context.settings).apply_to(&mut metadata);
|
|
let metadata = metadata.turn_metadata_value().expect("turn metadata");
|
|
|
|
assert_eq!(metadata["model"], "captured-step-model");
|
|
assert_eq!(metadata[AUTO_REVIEW_ENABLED_KEY], true);
|
|
assert_eq!(metadata[NODE_REPL_AUTO_REVIEW_REQUIRED_KEY], true);
|
|
assert_eq!(metadata[NODE_REPL_DISABLED_KEY], true);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn guardian_affinity_requires_the_captured_parent_and_stays_out_of_metadata() {
|
|
let uri = "wss://metadata-affinity.chatgpt.com/backend-api/codex/responses"
|
|
.parse()
|
|
.unwrap();
|
|
let mut headers = http::HeaderMap::new();
|
|
headers.insert(
|
|
http::header::SET_COOKIE,
|
|
http::HeaderValue::from_static("__oailb=private-parent-pin; Path=/; Secure; Max-Age=3600"),
|
|
);
|
|
let affinity =
|
|
codex_http_client::ChatGptRoutingAffinity::from_response(&uri, &headers).unwrap();
|
|
for (subagent, request_parent, expected) in [
|
|
(Some("guardian"), "parent", true),
|
|
(Some("guardian"), "other-parent", false),
|
|
(None, "parent", false),
|
|
] {
|
|
let (session, mut turn) = make_session_and_context().await;
|
|
Arc::get_mut(&mut turn.turn_metadata_state)
|
|
.unwrap()
|
|
.subagent_header = subagent.map(str::to_owned);
|
|
turn.turn_metadata_state
|
|
.update_responsesapi_client_metadata(
|
|
codex_protocol::turn_input::ResponsesApiClientMetadataUpdate {
|
|
replacement: Some(HashMap::from([(
|
|
"parent_response_id".to_owned(),
|
|
request_parent.to_owned(),
|
|
)])),
|
|
patch: None,
|
|
},
|
|
);
|
|
session
|
|
.services
|
|
.thread_extension_data
|
|
.insert(crate::guardian::PendingReviewRouting(Some(Arc::new(
|
|
crate::guardian::ParentResponse {
|
|
id: "parent".to_owned(),
|
|
routing_affinity: Some(affinity.clone()),
|
|
},
|
|
))));
|
|
let step = StepContext::for_test(Arc::new(turn));
|
|
let metadata = session
|
|
.responses_metadata(&step, CodexResponsesRequestKind::Turn)
|
|
.await;
|
|
assert_eq!(
|
|
metadata
|
|
.parent_routing_affinity
|
|
.as_ref()
|
|
.and_then(|pin| pin.cookie_header(&uri)),
|
|
expected.then(|| http::HeaderValue::from_static("__oailb=private-parent-pin"))
|
|
);
|
|
assert!(
|
|
!metadata
|
|
.turn_metadata_json()
|
|
.unwrap()
|
|
.contains("private-parent-pin")
|
|
);
|
|
assert!(
|
|
!serde_json::to_string(&metadata.client_metadata(/*include_internal*/ true))
|
|
.unwrap()
|
|
.contains("private-parent-pin")
|
|
);
|
|
assert!(!format!("{:?}", metadata.compatibility_headers()).contains("private-parent-pin"));
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn turn_metadata_state_marks_user_input_requested_during_turn_only_for_mcp_request_meta() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
let permission_profile = PermissionProfile::read_only();
|
|
|
|
let state = TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
cwd,
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
);
|
|
|
|
let header = test_turn_metadata_header(&state);
|
|
let header_json: Value = serde_json::from_str(&header).expect("json");
|
|
assert!(
|
|
header_json
|
|
.get(USER_INPUT_REQUESTED_DURING_TURN_KEY)
|
|
.is_none()
|
|
);
|
|
|
|
let meta = state
|
|
.current_meta_value_for_mcp_request(test_mcp_turn_metadata_context())
|
|
.expect("turn metadata should be present");
|
|
assert!(meta.get(USER_INPUT_REQUESTED_DURING_TURN_KEY).is_none());
|
|
|
|
state.mark_user_input_requested_during_turn();
|
|
|
|
let header = test_turn_metadata_header(&state);
|
|
let header_json: Value = serde_json::from_str(&header).expect("json");
|
|
assert!(
|
|
header_json
|
|
.get(USER_INPUT_REQUESTED_DURING_TURN_KEY)
|
|
.is_none()
|
|
);
|
|
|
|
let meta = state
|
|
.current_meta_value_for_mcp_request(test_mcp_turn_metadata_context())
|
|
.expect("turn metadata should be present");
|
|
assert_eq!(
|
|
meta.get(USER_INPUT_REQUESTED_DURING_TURN_KEY)
|
|
.and_then(Value::as_bool),
|
|
Some(true)
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn child_metadata_snapshot_excludes_parent_review_and_routing_fields() {
|
|
let (_, turn) = make_session_and_context().await;
|
|
let state = &turn.turn_metadata_state;
|
|
let client_metadata = HashMap::from([
|
|
("cost_center".to_string(), "before".to_string()),
|
|
("thread_id".to_string(), "parent-thread".to_string()),
|
|
("turn_id".to_string(), "parent-turn".to_string()),
|
|
(
|
|
"mcp_request_meta".to_string(),
|
|
r#"{"selected_connector_ids":["parent-connector"]}"#.to_string(),
|
|
),
|
|
(
|
|
"parent_response_id".to_string(),
|
|
"parent-response".to_string(),
|
|
),
|
|
(
|
|
"misalignment_override".to_string(),
|
|
r#"{"review_target":"parent-only"}"#.to_string(),
|
|
),
|
|
]);
|
|
state.update_responsesapi_client_metadata(ResponsesApiClientMetadataUpdate {
|
|
replacement: Some(client_metadata),
|
|
..Default::default()
|
|
});
|
|
let snapshot = state.client_metadata_for_child();
|
|
state.update_responsesapi_client_metadata(ResponsesApiClientMetadataUpdate {
|
|
patch: Some(HashMap::from([(
|
|
"cost_center".to_string(),
|
|
"after".to_string(),
|
|
)])),
|
|
..Default::default()
|
|
});
|
|
assert_eq!(
|
|
[snapshot, state.client_metadata_for_child()],
|
|
["before", "after"]
|
|
.map(|value| HashMap::from([("cost_center".to_string(), value.to_string(),)])),
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn turn_metadata_state_ignores_client_reserved_metadata_before_start() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
let permission_profile = PermissionProfile::read_only();
|
|
|
|
let state = TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
cwd,
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
);
|
|
let client_metadata = HashMap::from([
|
|
(
|
|
LEGACY_CODE_MODE_TOOL_NAMES_KEY.to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
(
|
|
TOOL_NAMESPACES_INFO_KEY.to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
(
|
|
"turn_started_at_unix_ms".to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
(
|
|
"forked_from_thread_id".to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
(
|
|
"parent_thread_id".to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
("parent_turn_id".to_string(), "client-supplied".to_string()),
|
|
(ROOT_TURN_ID_KEY.to_string(), "client-supplied".to_string()),
|
|
("subagent_kind".to_string(), "client-supplied".to_string()),
|
|
(
|
|
"history_initialization".to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
(
|
|
SANDBOX_MODE_KEY.to_string(),
|
|
"danger-full-access".to_string(),
|
|
),
|
|
(AUTO_REVIEW_ENABLED_KEY.to_string(), "true".to_string()),
|
|
(
|
|
NODE_REPL_AUTO_REVIEW_REQUIRED_KEY.to_string(),
|
|
"true".to_string(),
|
|
),
|
|
(NODE_REPL_DISABLED_KEY.to_string(), "true".to_string()),
|
|
]);
|
|
state.update_responsesapi_client_metadata(ResponsesApiClientMetadataUpdate {
|
|
replacement: Some(client_metadata),
|
|
..Default::default()
|
|
});
|
|
|
|
let header = test_turn_metadata_header(&state);
|
|
let json: Value = serde_json::from_str(&header).expect("json");
|
|
|
|
assert!(json.get(LEGACY_CODE_MODE_TOOL_NAMES_KEY).is_none());
|
|
assert!(json.get(TOOL_NAMESPACES_INFO_KEY).is_none());
|
|
assert!(json.get("turn_started_at_unix_ms").is_none());
|
|
assert!(json.get("forked_from_thread_id").is_none());
|
|
assert!(json.get("parent_thread_id").is_none());
|
|
assert!(json.get("parent_turn_id").is_none());
|
|
assert!(json.get(ROOT_TURN_ID_KEY).is_none());
|
|
assert!(json.get("subagent_kind").is_none());
|
|
assert!(json.get("history_initialization").is_none());
|
|
assert_eq!(json[SANDBOX_MODE_KEY].as_str(), Some("read-only"));
|
|
assert_eq!(json[AUTO_REVIEW_ENABLED_KEY].as_bool(), Some(false));
|
|
assert_eq!(
|
|
json[NODE_REPL_AUTO_REVIEW_REQUIRED_KEY].as_bool(),
|
|
Some(false)
|
|
);
|
|
assert_eq!(json[NODE_REPL_DISABLED_KEY].as_bool(), Some(false));
|
|
}
|
|
|
|
#[test]
|
|
fn turn_metadata_state_merges_client_metadata_without_replacing_reserved_fields() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
let permission_profile = PermissionProfile::read_only();
|
|
let source_thread_id =
|
|
ThreadId::from_string("44444444-4444-4444-8444-444444444444").expect("thread id");
|
|
let parent_thread_id =
|
|
ThreadId::from_string("55555555-5555-4555-8555-555555555555").expect("thread id");
|
|
|
|
let state = TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
Some(source_thread_id),
|
|
Some(parent_thread_id),
|
|
&SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
|
|
parent_thread_id,
|
|
depth: 1,
|
|
agent_path: None,
|
|
agent_nickname: None,
|
|
agent_role: None,
|
|
}),
|
|
Some(ThreadSource::Feature("automation".to_string())),
|
|
"turn-a".to_string(),
|
|
cwd,
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
);
|
|
state.set_responses_api_metadata(BTreeMap::from([
|
|
("codex_security_surface".to_string(), "sdk".to_string()),
|
|
(ANALYTICS_ENABLED_KEY.to_string(), "false".to_string()),
|
|
("source".to_string(), " Configured_Source ".to_string()),
|
|
(
|
|
WINDOW_NUMBER_KEY.to_string(),
|
|
"configured-value".to_string(),
|
|
),
|
|
(
|
|
FORKED_FROM_ORDINAL_EXCLUSIVE_KEY.to_string(),
|
|
"configured-value".to_string(),
|
|
),
|
|
]));
|
|
state.set_parent_turn_id("parent-turn-a".to_string());
|
|
state.set_root_turn_id("root-turn-a".to_string());
|
|
state.set_turn_trigger("goal".to_string());
|
|
let client_metadata = HashMap::from([
|
|
(
|
|
"codex_security_surface".to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
("fiber_run_id".to_string(), "fiber-123".to_string()),
|
|
(ANALYTICS_ENABLED_KEY.to_string(), "true".to_string()),
|
|
("origin".to_string(), "東京".to_string()),
|
|
("workspace_kind".to_string(), "projectless".to_string()),
|
|
("source".to_string(), "client-source".to_string()),
|
|
("model".to_string(), "client-supplied".to_string()),
|
|
("codex_version".to_string(), "client-supplied".to_string()),
|
|
(
|
|
"reasoning_effort".to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
("session_id".to_string(), "client-supplied".to_string()),
|
|
("thread_id".to_string(), "client-supplied".to_string()),
|
|
("agent_name".to_string(), "client-supplied".to_string()),
|
|
("installation_id".to_string(), "client-supplied".to_string()),
|
|
(
|
|
"x-codex-installation-id".to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
(
|
|
"x-codex-parent-thread-id".to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
(
|
|
"x-openai-subagent".to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
(
|
|
"forked_from_thread_id".to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
(
|
|
"parent_thread_id".to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
("parent_turn_id".to_string(), "client-supplied".to_string()),
|
|
(ROOT_TURN_ID_KEY.to_string(), "client-supplied".to_string()),
|
|
("subagent_kind".to_string(), "client-supplied".to_string()),
|
|
(
|
|
LEGACY_CODE_MODE_TOOL_NAMES_KEY.to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
(
|
|
TOOL_NAMESPACES_INFO_KEY.to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
("turn_id".to_string(), "client-supplied".to_string()),
|
|
(WINDOW_ID_KEY.to_string(), "client-supplied".to_string()),
|
|
(WINDOW_NUMBER_KEY.to_string(), "client-supplied".to_string()),
|
|
(
|
|
CONTEXT_WINDOW_ID_KEY.to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
(
|
|
FORKED_FROM_ORDINAL_EXCLUSIVE_KEY.to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
("thread_source".to_string(), "client-supplied".to_string()),
|
|
(TURN_TRIGGER_KEY.to_string(), "client-supplied".to_string()),
|
|
("request_kind".to_string(), "client-supplied".to_string()),
|
|
(
|
|
"turn_started_at_unix_ms".to_string(),
|
|
"client-supplied".to_string(),
|
|
),
|
|
]);
|
|
state.update_responsesapi_client_metadata(ResponsesApiClientMetadataUpdate {
|
|
replacement: Some(client_metadata),
|
|
..Default::default()
|
|
});
|
|
state.set_turn_started_at_unix_ms(/*turn_started_at_unix_ms*/ 1_700_000_000_123);
|
|
let header = test_turn_metadata_header(&state);
|
|
assert!(header.is_ascii());
|
|
assert!(!header.contains("東京"));
|
|
let json: Value = serde_json::from_str(&header).expect("json");
|
|
|
|
assert_eq!(json["fiber_run_id"].as_str(), Some("fiber-123"));
|
|
assert!(json.get(ANALYTICS_ENABLED_KEY).is_none());
|
|
assert_eq!(json["origin"].as_str(), Some("東京"));
|
|
assert_eq!(json["workspace_kind"].as_str(), Some("projectless"));
|
|
assert_eq!(json["codex_security_surface"].as_str(), Some("sdk"));
|
|
assert_eq!(json["model"].as_str(), Some("client-supplied"));
|
|
assert_eq!(json["reasoning_effort"].as_str(), Some("client-supplied"));
|
|
assert_eq!(json["session_id"].as_str(), Some("session-a"));
|
|
assert_eq!(json["thread_id"].as_str(), Some("thread-a"));
|
|
assert!(json.get(LEGACY_CODE_MODE_TOOL_NAMES_KEY).is_none());
|
|
assert_eq!(json["agent_name"].as_str(), Some("/root"));
|
|
assert!(json.get(TOOL_NAMESPACES_INFO_KEY).is_none());
|
|
assert!(json.get(INSTALLATION_ID_KEY).is_none());
|
|
assert!(json.get("x-codex-installation-id").is_none());
|
|
assert!(json.get("x-codex-parent-thread-id").is_none());
|
|
assert!(json.get("x-openai-subagent").is_none());
|
|
assert!(json.get("forked_from_thread_id").is_none());
|
|
assert!(json.get(FORKED_FROM_ORDINAL_EXCLUSIVE_KEY).is_none());
|
|
assert_eq!(
|
|
json["parent_thread_id"].as_str(),
|
|
Some("55555555-5555-4555-8555-555555555555")
|
|
);
|
|
assert_eq!(json["parent_turn_id"].as_str(), Some("parent-turn-a"));
|
|
assert_eq!(json[ROOT_TURN_ID_KEY].as_str(), Some("root-turn-a"));
|
|
assert_eq!(json["subagent_kind"].as_str(), Some("thread_spawn"));
|
|
assert_eq!(json["thread_source"].as_str(), Some("automation"));
|
|
assert_eq!(json[TURN_TRIGGER_KEY].as_str(), Some("goal"));
|
|
assert_eq!(json["turn_id"].as_str(), Some("turn-a"));
|
|
assert!(json.get("request_kind").is_none());
|
|
assert!(json.get(WINDOW_ID_KEY).is_none());
|
|
assert!(json.get(WINDOW_NUMBER_KEY).is_none());
|
|
assert!(json.get(CONTEXT_WINDOW_ID_KEY).is_none());
|
|
assert_eq!(
|
|
json["turn_started_at_unix_ms"].as_i64(),
|
|
Some(1_700_000_000_123)
|
|
);
|
|
|
|
let model_request_header = test_turn_responses_metadata_json(&state, "thread-a:1");
|
|
let model_request_json: Value =
|
|
serde_json::from_str(&model_request_header).expect("model request json");
|
|
assert_eq!(model_request_json["request_kind"].as_str(), Some("turn"));
|
|
assert_eq!(
|
|
model_request_json[ROOT_TURN_ID_KEY].as_str(),
|
|
Some("root-turn-a")
|
|
);
|
|
assert_eq!(
|
|
model_request_json["thread_source"].as_str(),
|
|
Some("automation")
|
|
);
|
|
assert_eq!(
|
|
model_request_json["codex_security_surface"].as_str(),
|
|
Some("sdk")
|
|
);
|
|
assert_eq!(
|
|
model_request_json[INSTALLATION_ID_KEY].as_str(),
|
|
Some("installation-a")
|
|
);
|
|
assert_eq!(
|
|
model_request_json[WINDOW_ID_KEY].as_str(),
|
|
Some("thread-a:1")
|
|
);
|
|
|
|
let compatibility_headers =
|
|
test_turn_responses_metadata(&state, "thread-a:1").compatibility_headers();
|
|
let compatibility_metadata: Value = serde_json::from_str(
|
|
compatibility_headers
|
|
.get("x-codex-turn-metadata")
|
|
.expect("compatibility turn metadata header")
|
|
.to_str()
|
|
.expect("valid compatibility header"),
|
|
)
|
|
.expect("compatibility metadata json");
|
|
assert!(
|
|
compatibility_metadata
|
|
.get(LEGACY_CODE_MODE_TOOL_NAMES_KEY)
|
|
.is_none()
|
|
);
|
|
assert!(
|
|
compatibility_metadata
|
|
.get(TOOL_NAMESPACES_INFO_KEY)
|
|
.is_none()
|
|
);
|
|
|
|
let meta = state
|
|
.current_meta_value_for_mcp_request(test_mcp_turn_metadata_context())
|
|
.expect("turn metadata should be present");
|
|
assert_eq!(meta["model"].as_str(), Some("gpt-5.4"));
|
|
assert_eq!(meta["codex_version"], env!("CARGO_PKG_VERSION"));
|
|
assert_eq!(meta["reasoning_effort"].as_str(), Some("high"));
|
|
assert!(meta.get(LEGACY_CODE_MODE_TOOL_NAMES_KEY).is_none());
|
|
assert!(meta.get(TOOL_NAMESPACES_INFO_KEY).is_none());
|
|
assert!(meta.get(PARENT_TURN_ID_KEY).is_none());
|
|
assert!(meta.get(ROOT_TURN_ID_KEY).is_none());
|
|
assert!(meta.get(WINDOW_ID_KEY).is_none());
|
|
assert!(meta.get("codex_security_surface").is_none());
|
|
assert!(meta.get(ANALYTICS_ENABLED_KEY).is_none());
|
|
let extension_meta = state
|
|
.current_meta_value_for_extension_request(test_mcp_turn_metadata_context())
|
|
.expect("extension metadata should be present");
|
|
assert_eq!(extension_meta["codex_security_surface"], "sdk");
|
|
assert_eq!(extension_meta["source"], " Configured_Source ");
|
|
assert_eq!(extension_meta[TURN_TRIGGER_KEY], "goal");
|
|
assert_eq!(extension_meta["model"], "gpt-5.4");
|
|
assert!(extension_meta.get(TOOL_NAMESPACES_INFO_KEY).is_none());
|
|
assert_eq!(state.workspace_kind().as_deref(), Some("projectless"));
|
|
assert_eq!(
|
|
(state.turn_trigger(), state.codex_turn_source()),
|
|
(
|
|
Some("goal".to_string()),
|
|
Some(" Configured_Source ".to_string())
|
|
)
|
|
);
|
|
assert_eq!(model_request_json["source"], " Configured_Source ");
|
|
|
|
for (configured, client, expected) in [
|
|
(None, None, None),
|
|
(
|
|
None,
|
|
Some(" New_Source ".to_string()),
|
|
Some(" New_Source ".to_string()),
|
|
),
|
|
(None, Some(String::new()), Some(String::new())),
|
|
(None, Some("é".repeat(/*n*/ 64)), Some("é".repeat(/*n*/ 64))),
|
|
(None, Some("é".repeat(/*n*/ 65)), None),
|
|
(
|
|
Some("x".repeat(/*n*/ 129)),
|
|
Some("client-source".to_string()),
|
|
None,
|
|
),
|
|
] {
|
|
state.set_responses_api_metadata(
|
|
configured
|
|
.map(|source| ("source".to_string(), source))
|
|
.into_iter()
|
|
.collect(),
|
|
);
|
|
state.update_responsesapi_client_metadata(ResponsesApiClientMetadataUpdate {
|
|
replacement: Some(
|
|
client
|
|
.map(|source| ("source".to_string(), source))
|
|
.into_iter()
|
|
.collect(),
|
|
),
|
|
..Default::default()
|
|
});
|
|
assert_eq!(state.codex_turn_source(), expected);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn turn_metadata_state_bounds_trigger_only_for_analytics() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
for (characters, included) in [(64, true), (65, false)] {
|
|
let state = TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
temp_dir.path().abs(),
|
|
&PermissionProfile::read_only(),
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
);
|
|
let trigger = "é".repeat(characters);
|
|
state.set_turn_trigger(trigger.clone());
|
|
let metadata: Value =
|
|
serde_json::from_str(&test_turn_metadata_header(&state)).expect("json");
|
|
assert_eq!(
|
|
(state.turn_trigger(), metadata[TURN_TRIGGER_KEY].as_str()),
|
|
(included.then(|| trigger.clone()), Some(trigger.as_str()))
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test_case::test_case(r#"{"review_target":"RB._~:-opaque"}"#, None; "target")]
|
|
#[test_case::test_case(r#"{"timestamp":1750000000}"#, Some(r#"{"timestamp":1750000000}"#); "legacy_timestamp")]
|
|
fn turn_metadata_state_overlays_compaction_only_on_compaction_requests(
|
|
continuation: &str,
|
|
compaction_override: Option<&str>,
|
|
) {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let cwd = temp_dir.path().abs();
|
|
let permission_profile = PermissionProfile::read_only();
|
|
let state = TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
cwd,
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
);
|
|
state.set_responses_api_metadata(BTreeMap::from([
|
|
("codex_security_surface".to_string(), "sdk".to_string()),
|
|
(
|
|
"misalignment_override".to_string(),
|
|
r#"{"review_target":"RC"}"#.to_string(),
|
|
),
|
|
]));
|
|
let ordinary_json: Value =
|
|
serde_json::from_str(&test_turn_responses_metadata_json(&state, "thread-a:1"))
|
|
.expect("json");
|
|
assert!(ordinary_json.get("misalignment_override").is_none());
|
|
let client_metadata = HashMap::from([
|
|
("compaction".to_string(), "client-supplied".to_string()),
|
|
(
|
|
"misalignment_override".to_string(),
|
|
continuation.to_string(),
|
|
),
|
|
]);
|
|
state.update_responsesapi_client_metadata(ResponsesApiClientMetadataUpdate {
|
|
replacement: Some(client_metadata),
|
|
..Default::default()
|
|
});
|
|
|
|
let mcp_metadata = state
|
|
.current_meta_value_for_mcp_request(test_mcp_turn_metadata_context())
|
|
.expect("MCP metadata");
|
|
assert_eq!(
|
|
mcp_metadata["misalignment_override"].as_str(),
|
|
compaction_override
|
|
);
|
|
|
|
let compact_header = test_compaction_responses_metadata_json(
|
|
&state,
|
|
"thread-a:2",
|
|
CompactionTurnMetadata::new(
|
|
CompactionTrigger::Auto,
|
|
CompactionReason::ContextLimit,
|
|
CompactionImplementation::ResponsesCompactionV2,
|
|
CompactionPhase::MidTurn,
|
|
),
|
|
);
|
|
let compact_json: Value = serde_json::from_str(&compact_header).expect("json");
|
|
assert_eq!(compact_json["request_kind"].as_str(), Some("compaction"));
|
|
assert_eq!(compact_json["turn_id"].as_str(), Some("turn-a"));
|
|
assert_eq!(compact_json[WINDOW_ID_KEY].as_str(), Some("thread-a:2"));
|
|
assert_eq!(compact_json["codex_security_surface"].as_str(), Some("sdk"));
|
|
assert_eq!(
|
|
compact_json["misalignment_override"].as_str(),
|
|
compaction_override
|
|
);
|
|
assert_eq!(
|
|
compact_json["compaction"],
|
|
serde_json::json!({
|
|
"trigger": "auto",
|
|
"reason": "context_limit",
|
|
"implementation": "responses_compaction_v2",
|
|
"phase": "mid_turn",
|
|
"strategy": "memento",
|
|
})
|
|
);
|
|
|
|
let regular_header = test_turn_responses_metadata_json(&state, "thread-a:3");
|
|
let regular_json: Value = serde_json::from_str(®ular_header).expect("json");
|
|
assert_eq!(regular_json["misalignment_override"], continuation);
|
|
assert_eq!(regular_json["request_kind"].as_str(), Some("turn"));
|
|
assert_eq!(regular_json[WINDOW_ID_KEY].as_str(), Some("thread-a:3"));
|
|
assert_eq!(regular_json["codex_security_surface"].as_str(), Some("sdk"));
|
|
assert!(regular_json.get("compaction").is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn responses_api_metadata_rejects_reserved_keys() {
|
|
for reserved_key in [
|
|
"thread_source",
|
|
TURN_TRIGGER_KEY,
|
|
WINDOW_ID_KEY,
|
|
CONTEXT_WINDOW_ID_KEY,
|
|
] {
|
|
assert_eq!(
|
|
validate_extra_metadata(
|
|
BTreeMap::from([(reserved_key.to_string(), "sdk".to_string())]).iter()
|
|
),
|
|
Err("responses_api_metadata contains a reserved key")
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn responses_api_metadata_accepts_previously_valid_reserved_keys() {
|
|
for legacy_key in [
|
|
WINDOW_NUMBER_KEY,
|
|
FORKED_FROM_ORDINAL_EXCLUSIVE_KEY,
|
|
ANALYTICS_ENABLED_KEY,
|
|
] {
|
|
assert_eq!(
|
|
validate_extra_metadata(
|
|
BTreeMap::from([(legacy_key.to_string(), "legacy-value".to_string())]).iter()
|
|
),
|
|
Ok(())
|
|
);
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn preparing_model_request_metadata_does_not_wait_for_pending_git_enrichment() {
|
|
let (session, turn) = make_session_and_context().await;
|
|
let (_updates, workspaces) = watch::channel(BTreeMap::new());
|
|
turn.turn_metadata_state
|
|
.set_git_enrichment(TurnGitEnrichment {
|
|
workspaces: Some(workspaces),
|
|
task: None,
|
|
admission: None,
|
|
});
|
|
let step = StepContext::for_test(Arc::new(turn));
|
|
|
|
let metadata = tokio::time::timeout(
|
|
Duration::from_secs(1),
|
|
session.responses_metadata(&step, CodexResponsesRequestKind::Turn),
|
|
)
|
|
.await
|
|
.expect("generation must continue while optional Git discovery is pending");
|
|
assert!(metadata.workspaces.is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn turn_git_status_waits_for_admission() {
|
|
let (admission, request) = oneshot::channel();
|
|
let started = AtomicBool::new(false);
|
|
let status =
|
|
collect_git_status_after_admission(GitCollectionAdmission::Pending(request), async {
|
|
started.store(true, Ordering::SeqCst);
|
|
None
|
|
});
|
|
tokio::pin!(status);
|
|
assert!(futures::poll!(status.as_mut()).is_pending());
|
|
assert!(!started.load(Ordering::SeqCst));
|
|
admission.send(()).expect("admit");
|
|
assert!(
|
|
tokio::time::timeout(Duration::from_secs(5), status)
|
|
.await
|
|
.expect("Git status should finish after admission")
|
|
.is_none()
|
|
);
|
|
assert!(started.load(Ordering::SeqCst));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn git_enrichment_publishes_refs_before_status_is_available() {
|
|
let (_temp_dir, repo) = create_clean_git_repo("repo").await;
|
|
let url = "https://example.invalid/repo.git";
|
|
assert!(
|
|
Command::new("git")
|
|
.args(["remote", "add", "origin", url])
|
|
.current_dir(&repo)
|
|
.status()
|
|
.await
|
|
.expect("add remote")
|
|
.success()
|
|
);
|
|
let head = get_head_commit_hash(&repo).await.expect("read HEAD");
|
|
let refs = serde_json::json!({
|
|
"associated_remote_urls": {"origin": url},
|
|
"latest_git_commit_hash": head.0,
|
|
});
|
|
let mut clean = refs.clone();
|
|
clean["has_changes"] = Value::Bool(false);
|
|
|
|
let updates =
|
|
collect_with_status_after_refs(&repo, get_worktree_status_in_repo(&repo, &repo)).await;
|
|
assert!(
|
|
updates
|
|
.first()
|
|
.expect("early refs")
|
|
.get("has_changes")
|
|
.is_none()
|
|
);
|
|
assert_eq!(updates.last(), Some(&clean));
|
|
assert_eq!(
|
|
collect_with_status_after_refs(&repo, std::future::ready(None))
|
|
.await
|
|
.last(),
|
|
Some(&refs),
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn git_enrichment_keeps_verified_remotes_while_ambiguous_lookups_are_pending() {
|
|
let urls = BTreeMap::from([(
|
|
"origin".to_string(),
|
|
SanitizedGitUrl::try_from("https://example.invalid/repo").unwrap(),
|
|
)]);
|
|
let initial = urls.clone();
|
|
let mut all_urls = urls.clone();
|
|
all_urls.insert(
|
|
"upstream".to_string(),
|
|
SanitizedGitUrl::try_from("https://example.invalid/upstream").unwrap(),
|
|
);
|
|
let final_update = all_urls.clone();
|
|
let (resume_lookup, wait_for_publication) = oneshot::channel();
|
|
let mut resume_lookup = Some(resume_lookup);
|
|
let mut observed = Vec::new();
|
|
let collect = collect_workspace_git_metadata(
|
|
std::future::ready(GitHeadState::Unavailable),
|
|
|verified| async move {
|
|
verified.send_replace(initial);
|
|
wait_for_publication.await.unwrap();
|
|
verified.send_replace(final_update);
|
|
},
|
|
std::future::ready(None),
|
|
|workspace| {
|
|
observed.push(workspace.associated_remote_urls);
|
|
if let Some(ack) = resume_lookup.take() {
|
|
ack.send(()).unwrap();
|
|
}
|
|
},
|
|
);
|
|
tokio::time::timeout(Duration::from_secs(5), collect)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(observed, vec![Some(urls), Some(all_urls)]);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn git_enrichment_publishes_verified_status_while_remotes_are_pending() {
|
|
let (_temp_dir, repo) = create_clean_git_repo("repo").await;
|
|
let head = get_head_commit_hash(&repo).await.expect("read HEAD");
|
|
let (release_remotes, wait_for_status) = tokio::sync::oneshot::channel();
|
|
let mut release_remotes = Some(release_remotes);
|
|
let collect = collect_workspace_git_metadata(
|
|
get_head_state(&repo),
|
|
|updates| {
|
|
let repo = &repo;
|
|
async move {
|
|
wait_for_status.await.expect("verified worktree status");
|
|
observe_git_remote_urls(repo, &updates).await;
|
|
}
|
|
},
|
|
get_worktree_status_in_repo(&repo, &repo),
|
|
|workspace| {
|
|
if let Some(dirty) = workspace.has_changes
|
|
&& let Some(release) = release_remotes.take()
|
|
{
|
|
assert_eq!(workspace.latest_git_commit_hash.as_ref(), Some(&head.0));
|
|
assert_eq!(workspace.associated_remote_urls, None);
|
|
assert!(!dirty);
|
|
release.send(()).expect("release remote lookup");
|
|
}
|
|
},
|
|
);
|
|
tokio::time::timeout(Duration::from_secs(5), collect)
|
|
.await
|
|
.expect("verified status should be published before remotes return");
|
|
}
|
|
|
|
#[test_case::test_case(true; "confirmed unborn HEAD")]
|
|
#[test_case::test_case(false; "HEAD still pending")]
|
|
#[tokio::test(start_paused = true)]
|
|
async fn git_enrichment_requires_confirmed_head_for_unborn_status(head_ready: bool) {
|
|
let mut published_dirty = None;
|
|
let collect = collect_workspace_git_metadata(
|
|
async {
|
|
if !head_ready {
|
|
std::future::pending::<()>().await;
|
|
}
|
|
GitHeadState::Missing
|
|
},
|
|
|_| std::future::ready(()),
|
|
std::future::ready(Some(GitWorktreeStatus {
|
|
head_commit_hash: None,
|
|
has_changes: true,
|
|
})),
|
|
|workspace| published_dirty = workspace.has_changes,
|
|
);
|
|
let _ = tokio::time::timeout(MEMORY_GIT_METADATA_TIMEOUT, collect).await;
|
|
assert_eq!(published_dirty, head_ready.then_some(true));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn git_enrichment_keeps_dirty_status_when_an_unborn_repo_contains_a_head_file() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let repo = temp_dir.path().abs();
|
|
assert!(
|
|
Command::new("git")
|
|
.args(["init", "-q"])
|
|
.current_dir(&repo)
|
|
.status()
|
|
.await
|
|
.expect("git init")
|
|
.success()
|
|
);
|
|
std::fs::write(repo.join("HEAD"), "untracked").expect("write HEAD file");
|
|
let mut workspaces = BTreeMap::new();
|
|
collect_git_workspaces(
|
|
&repo,
|
|
std::future::ready(Some(repo.as_path().to_path_buf())),
|
|
GitCollectionAdmission::Immediate,
|
|
|observed| workspaces = observed,
|
|
)
|
|
.await;
|
|
let workspace = workspaces
|
|
.get(repo.to_string_lossy().as_ref())
|
|
.expect("workspace");
|
|
assert_eq!(workspace.latest_git_commit_hash, None);
|
|
assert_eq!(workspace.has_changes, Some(true));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn git_enrichment_recovers_commit_and_status_when_independent_head_lookup_fails() {
|
|
let (_temp_dir, repo) = create_clean_git_repo("repo").await;
|
|
let head = get_head_commit_hash(&repo).await.expect("read HEAD");
|
|
std::fs::write(repo.join("untracked"), "dirty").expect("write untracked file");
|
|
let mut latest = None;
|
|
collect_workspace_git_metadata(
|
|
std::future::ready(GitHeadState::Unavailable),
|
|
|_| std::future::ready(()),
|
|
get_worktree_status_in_repo(&repo, &repo),
|
|
|workspace| latest = Some(workspace),
|
|
)
|
|
.await;
|
|
let workspace = latest.expect("workspace");
|
|
assert_eq!(
|
|
workspace.latest_git_commit_hash.as_deref(),
|
|
Some(head.0.as_str())
|
|
);
|
|
assert_eq!(workspace.has_changes, Some(true));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn git_enrichment_rejects_a_committed_status_when_head_is_missing() {
|
|
let head = GitSha::new("0123456789abcdef0123456789abcdef01234567");
|
|
let mut latest = None;
|
|
collect_workspace_git_metadata(
|
|
std::future::ready(GitHeadState::Missing),
|
|
|_| std::future::ready(()),
|
|
std::future::ready(Some(GitWorktreeStatus {
|
|
head_commit_hash: Some(head),
|
|
has_changes: false,
|
|
})),
|
|
|workspace| latest = Some(workspace),
|
|
)
|
|
.await;
|
|
assert!(latest.is_none());
|
|
}
|
|
|
|
#[test_case::test_case(false; "new HEAD is clean")]
|
|
#[test_case::test_case(true; "new HEAD is dirty")]
|
|
#[tokio::test]
|
|
async fn git_enrichment_does_not_pair_old_head_with_new_status(expected_has_changes: bool) {
|
|
let (_temp_dir, repo) = create_clean_git_repo("repo").await;
|
|
let head = get_head_commit_hash(&repo)
|
|
.await
|
|
.expect("read original HEAD");
|
|
let status = async {
|
|
assert!(
|
|
Command::new("git")
|
|
.args(["commit", "--allow-empty", "-qm", "new HEAD"])
|
|
.current_dir(&repo)
|
|
.status()
|
|
.await
|
|
.expect("commit")
|
|
.success()
|
|
);
|
|
if expected_has_changes {
|
|
std::fs::write(repo.join("untracked.txt"), "dirty\n").expect("dirty worktree");
|
|
}
|
|
let new_head = get_head_commit_hash(&repo).await.expect("read new HEAD");
|
|
let status = get_worktree_status_in_repo(&repo, &repo)
|
|
.await
|
|
.expect("read successful status for the new HEAD");
|
|
assert_eq!(status.head_commit_hash, Some(new_head));
|
|
assert_eq!(status.has_changes, expected_has_changes);
|
|
Some(status)
|
|
};
|
|
assert_eq!(
|
|
collect_with_status_after_refs(&repo, status).await,
|
|
vec![serde_json::json!({"latest_git_commit_hash": head.0})],
|
|
);
|
|
}
|
|
|
|
async fn collect_with_status_after_refs(
|
|
repo: &AbsolutePathBuf,
|
|
status: impl Future<Output = Option<GitWorktreeStatus>>,
|
|
) -> Vec<Value> {
|
|
let (send_refs_ready, refs_ready) = tokio::sync::oneshot::channel();
|
|
let mut send_refs_ready = Some(send_refs_ready);
|
|
let mut updates = Vec::new();
|
|
let status = async {
|
|
refs_ready.await.expect("refs published");
|
|
status.await
|
|
};
|
|
let collect = collect_workspace_git_metadata(
|
|
get_head_state(repo),
|
|
|updates| async move { observe_git_remote_urls(repo, &updates).await },
|
|
status,
|
|
|workspace| {
|
|
updates.push(serde_json::to_value(workspace).expect("serialize workspace"));
|
|
if let Some(ready) = send_refs_ready.take() {
|
|
ready.send(()).expect("release status scan");
|
|
}
|
|
},
|
|
);
|
|
tokio::time::timeout(Duration::from_secs(5), collect)
|
|
.await
|
|
.expect("refs should be published while status is pending");
|
|
updates
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn turn_metadata_state_preserves_subagent_parent_after_git_enrichment() {
|
|
let (_temp_dir, repo_path) = create_clean_git_repo("repo").await;
|
|
|
|
let permission_profile = PermissionProfile::read_only();
|
|
let parent_thread_id =
|
|
ThreadId::from_string("66666666-6666-4666-8666-666666666666").expect("thread id");
|
|
let state = Arc::new(TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
Some(parent_thread_id),
|
|
Some(parent_thread_id),
|
|
&SessionSource::SubAgent(SubAgentSource::ThreadSpawn {
|
|
parent_thread_id,
|
|
depth: 1,
|
|
agent_path: None,
|
|
agent_nickname: None,
|
|
agent_role: None,
|
|
}),
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
repo_path,
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
));
|
|
|
|
state.spawn_git_enrichment_task(Arc::default());
|
|
let json = wait_for_git_enrichment(&state).await;
|
|
|
|
assert!(json.get("forked_from_thread_id").is_none());
|
|
assert_eq!(
|
|
json["parent_thread_id"].as_str(),
|
|
Some("66666666-6666-4666-8666-666666666666")
|
|
);
|
|
assert_eq!(json["subagent_kind"].as_str(), Some("thread_spawn"));
|
|
}
|
|
|
|
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
|
async fn turn_metadata_state_coalesces_concurrent_git_enrichment() {
|
|
let (_temp_dir, repo_path) = create_clean_git_repo("repo").await;
|
|
let head = Command::new("git")
|
|
.args(["rev-parse", "HEAD"])
|
|
.current_dir(&repo_path)
|
|
.output()
|
|
.await
|
|
.expect("git rev-parse HEAD");
|
|
let head = String::from_utf8(head.stdout)
|
|
.expect("commit hash")
|
|
.trim()
|
|
.to_string();
|
|
let permission_profile = PermissionProfile::read_only();
|
|
let state = Arc::new(TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
repo_path.clone(),
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
));
|
|
let git_root_discovery = Arc::default();
|
|
let barrier = Arc::new(tokio::sync::Barrier::new(8));
|
|
let tasks = (0..8)
|
|
.map(|_| {
|
|
let state = Arc::clone(&state);
|
|
let barrier = Arc::clone(&barrier);
|
|
let git_root_discovery = Arc::clone(&git_root_discovery);
|
|
tokio::spawn(async move {
|
|
barrier.wait().await;
|
|
state.spawn_git_enrichment_task(git_root_discovery);
|
|
state
|
|
.git_enrichment
|
|
.lock()
|
|
.expect("enrichment task lock")
|
|
.task
|
|
.as_ref()
|
|
.expect("enrichment task")
|
|
.abort_handle()
|
|
.id()
|
|
})
|
|
})
|
|
.collect::<Vec<_>>();
|
|
let mut task_ids = Vec::new();
|
|
for task in tasks {
|
|
task_ids.push(task.await.expect("spawn task"));
|
|
}
|
|
assert!(task_ids.iter().all(|task_id| *task_id == task_ids[0]));
|
|
|
|
let json = wait_for_git_enrichment(state.as_ref()).await;
|
|
assert_eq!(
|
|
json["workspaces"],
|
|
serde_json::json!({
|
|
repo_path.to_string_lossy().as_ref(): {
|
|
"latest_git_commit_hash": head,
|
|
"has_changes": false,
|
|
}
|
|
})
|
|
);
|
|
}
|
|
|
|
#[tokio::test(flavor = "current_thread")]
|
|
async fn dropping_turn_metadata_aborts_unused_git_enrichment() {
|
|
let temp_dir = TempDir::new().expect("temp dir");
|
|
let state = Arc::new(TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
temp_dir.path().abs(),
|
|
&PermissionProfile::read_only(),
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
));
|
|
let weak_state = Arc::downgrade(&state);
|
|
state.spawn_git_enrichment_task(Arc::default());
|
|
let task = state
|
|
.git_enrichment
|
|
.lock()
|
|
.expect("enrichment task lock")
|
|
.task
|
|
.as_ref()
|
|
.expect("enrichment task")
|
|
.abort_handle();
|
|
|
|
// Drop the history-only context before its task can run. A strong task-owned
|
|
// reference would retain the metadata even after every caller has left.
|
|
drop(state);
|
|
assert!(weak_state.upgrade().is_none());
|
|
|
|
tokio::time::timeout(Duration::from_secs(2), async {
|
|
while !task.is_finished() {
|
|
tokio::task::yield_now().await;
|
|
}
|
|
})
|
|
.await
|
|
.expect("dropping turn metadata should abort its enrichment task");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn git_enrichment_discovers_the_repository_when_it_starts() {
|
|
let (workspace, repo_path) = create_clean_git_repo("repo").await;
|
|
let saved_git = workspace.path().join("saved-git");
|
|
std::fs::rename(repo_path.join(".git"), &saved_git).expect("move Git metadata");
|
|
let state = Arc::new(TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
repo_path.clone(),
|
|
&PermissionProfile::read_only(),
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
));
|
|
std::fs::rename(saved_git, repo_path.join(".git")).expect("restore Git metadata");
|
|
|
|
state.spawn_git_enrichment_task(Arc::default());
|
|
let metadata = wait_for_git_enrichment(&state).await;
|
|
assert_eq!(
|
|
metadata["workspaces"]
|
|
.as_object()
|
|
.expect("workspace metadata")
|
|
.keys()
|
|
.collect::<Vec<_>>(),
|
|
vec![&repo_path.to_string_lossy().into_owned()],
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn turn_metadata_state_git_enrichment_cancellation_is_retryable_and_errors_stay_empty() {
|
|
let (_temp_dir, repo_path) = create_clean_git_repo("repo").await;
|
|
let permission_profile = PermissionProfile::read_only();
|
|
let state = Arc::new(TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-a".to_string(),
|
|
repo_path,
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
));
|
|
let git_root_discovery = Arc::default();
|
|
state.spawn_git_enrichment_task(Arc::clone(&git_root_discovery));
|
|
state.cancel_git_enrichment_task();
|
|
assert!(
|
|
state
|
|
.git_enrichment
|
|
.lock()
|
|
.expect("enrichment task lock")
|
|
.task
|
|
.is_none()
|
|
);
|
|
tokio::time::timeout(Duration::from_secs(2), state.wait_for_git_enrichment())
|
|
.await
|
|
.expect("cancelled git enrichment should unblock waiters");
|
|
assert!(state.current_workspaces().is_empty());
|
|
|
|
state.spawn_git_enrichment_task(git_root_discovery);
|
|
let json = wait_for_git_enrichment(&state).await;
|
|
assert_eq!(
|
|
json["workspaces"].as_object().map(serde_json::Map::len),
|
|
Some(1)
|
|
);
|
|
|
|
let invalid_repo = TempDir::new().expect("invalid repo");
|
|
std::fs::create_dir(invalid_repo.path().join(".git")).expect("invalid git directory");
|
|
std::fs::write(
|
|
invalid_repo.path().join(".git/HEAD"),
|
|
"ref: refs/heads/main\n",
|
|
)
|
|
.expect("invalid git HEAD");
|
|
let invalid_state = Arc::new(TurnMetadataState::new(
|
|
"session-a".to_string(),
|
|
"thread-a".to_string(),
|
|
/*forked_from_thread_id*/ None,
|
|
/*parent_thread_id*/ None,
|
|
&SessionSource::Exec,
|
|
/*thread_source*/ None,
|
|
"turn-b".to_string(),
|
|
invalid_repo.path().abs(),
|
|
&permission_profile,
|
|
WindowsSandboxLevel::Disabled,
|
|
/*enforce_managed_network*/ false,
|
|
/*auto_review_enabled*/ false,
|
|
&model_info_from_slug("gpt-5.4"),
|
|
));
|
|
invalid_state.spawn_git_enrichment_task(Arc::default());
|
|
invalid_state.admit_git_enrichment();
|
|
tokio::time::timeout(
|
|
Duration::from_secs(2),
|
|
invalid_state.wait_for_git_enrichment(),
|
|
)
|
|
.await
|
|
.expect("failed git enrichment should complete");
|
|
assert!(invalid_state.current_workspaces().is_empty());
|
|
}
|