Lightweight coding agent that runs in your terminal
Rust
Skip host skill discovery for Guardian reviews (#49584)
jifa5cce8895a14
diff --git a/codex-rs/core/src/session/session.rs b/codex-rs/core/src/session/session.rsindex e92aaeef8a..68a9fef1c0 100644--- a/codex-rs/core/src/session/session.rs+++ b/codex-rs/core/src/session/session.rs@@ -619,7 +619,12 @@ async fn warm_plugins_and_skills_for_session_init(skills_service: Arc<HostSkillsService>,turn_environments: &TurnEnvironmentSnapshot,extensions: &codex_extension_api::ExtensionRegistry<Config>,+ session_source: &SessionSource,) -> Vec<SkillError> {+ // Guardian does not consume skills, including the legacy empty-registry catalog.+ if crate::guardian::is_basic_session_source(session_source) {+ return Vec::new();+ }let plugins_input = config.plugins_config_input();let plugin_outcome = plugins_manager.plugins_for_config(&plugins_input).await;if config.features.enabled(Feature::SkipHostSkillDiscovery)@@ -1450,6 +1455,7 @@ impl Session {Arc::clone(&skills_service),&resolved_environments,extensions.as_ref(),+ &session_configuration.session_source,).instrument(info_span!("session_init.plugin_skill_warmup",diff --git a/codex-rs/core/src/session/turn_context.rs b/codex-rs/core/src/session/turn_context.rsindex 0d7b59d77e..777da7411b 100644--- a/codex-rs/core/src/session/turn_context.rs+++ b/codex-rs/core/src/session/turn_context.rs@@ -1205,6 +1205,7 @@ impl Session {per_turn_config.codex_home.as_path(),);let skills_snapshot = if matches!(build_mode, TurnContextBuildMode::InjectItems)+ || crate::guardian::is_basic_session_source(&session_configuration.session_source)|| (per_turn_config.features.enabled(Feature::SkipHostSkillDiscovery)diff --git a/codex-rs/core/tests/suite/guardian_environments_tests.rs b/codex-rs/core/tests/suite/guardian_environments_tests.rsindex 2fceca3f12..452387a53e 100644--- a/codex-rs/core/tests/suite/guardian_environments_tests.rs+++ b/codex-rs/core/tests/suite/guardian_environments_tests.rs@@ -291,6 +291,174 @@ async fn guardian_reviews_target_environment_and_reuses_prefix(tool: &str) -> ReOk(())}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn guardian_reviews_with_offline_primary_executor() -> Result<()> {+ skip_if_no_network!(Ok(()));+ let listener = TcpListener::bind("127.0.0.1:0").await?;+ let executor_url = format!("ws://{}", listener.local_addr()?);+ let (attach, connection) = tokio::sync::oneshot::channel();+ let (disconnect, stop) = tokio::sync::oneshot::channel();+ let executor = AbortOnDropHandle::new(tokio::spawn(serve_environment_with_instruction_files(+ listener,+ "",+ Some(+ "---\nname: guardian-fixture-skill\ndescription: Source executor skill catalog entry.\n---\nUse the source skill.\n",+ ),+ connection,+ stop,+ )));+ attach.send(()).expect("attach primary executor");++ let environment_id = "guardian-primary";+ let (request_permission, pending_permission) = tokio::sync::oneshot::channel();+ let (model, _) = start_streaming_sse_server(vec![+ vec![StreamingSseChunk {+ gate: Some(pending_permission),+ body: sse(vec![+ ev_function_call(+ "permission",+ "request_permissions",+ &json!({+ "environment_id": environment_id,+ "permissions": {"network": {"enabled": true}},+ "reason": "Review permission while the executor is offline.",+ })+ .to_string(),+ ),+ ev_completed("parent"),+ ]),+ }],+ vec![StreamingSseChunk {+ gate: None,+ body: sse(vec![+ ev_assistant_message("deny", r#"{"outcome":"deny"}"#),+ ev_completed("review"),+ ]),+ }],+ vec![StreamingSseChunk {+ gate: None,+ body: sse(vec![ev_completed("done")]),+ }],+ ])+ .await;++ let mut extensions = ExtensionRegistryBuilder::<Config>::new();+ codex_skills_extension::install(&mut extensions, |config: &Config| {+ codex_skills_extension::SkillsExtensionConfig {+ include_instructions: config.include_skill_instructions,+ max_context_tokens: config.skill_max_context_tokens,+ bundled_skills_enabled: false,+ cloud_skill_enabled: false,+ shadow_selection_enabled: false,+ }+ });+ let test = test_codex()+ .with_extensions(Arc::new(extensions.build()))+ .with_model_info_override("guardian-offline-skills-parent", |info| {+ info.guardian = None;+ info.auto_review_model_override = Some(info.slug.clone());+ })+ .with_config(|config| {+ // Isolate skill discovery from the unchanged repository-instruction discovery path.+ config.project_doc_max_bytes = 0;+ config.permissions.approval_policy = Constrained::allow_any(AskForApproval::OnRequest);+ // Start the reviewer only after the executor goes offline, not during prewarm.+ config.approvals_reviewer = ApprovalsReviewer::User;+ config+ .permissions+ .set_permission_profile(PermissionProfile::read_only())+ .expect("set read-only permissions");+ config+ .features+ .enable(Feature::RequestPermissionsTool)+ .expect("enable permission requests");+ config+ .features+ .disable(Feature::SkipHostSkillDiscovery)+ .expect("keep host skill discovery enabled for the parent");+ config+ .features+ .disable(Feature::DeferredExecutor)+ .expect("disable deferred executor");+ })+ // This test supplies its own executor mock, using host-native paths.+ .build_with_streaming_server(&model)+ .await?;+ let manager = test.thread_manager.environment_manager();+ manager.upsert_environment(+ environment_id.to_owned(),+ executor_url,+ /*connect_timeout*/ None,+ )?;+ manager+ .get_environment(environment_id)+ .context("primary executor")?+ .wait_until_ready()+ .await?;+ let mut primary = test.executor_environment().selection().clone();+ primary.environment_id = environment_id.to_owned();+ primary.config =+ EnvironmentConfigState::Ready(environment_config_for_selection(&test.config, &primary));++ test.codex+ .start_or_steer_turn(+ TurnInputRequest::user_input(vec![UserInput::Text {+ text: "Do not grant network permission.".to_owned(),+ text_elements: Vec::new(),+ }])+ .with_thread_settings(ThreadSettingsOverrides {+ approvals_reviewer: Some(ApprovalsReviewer::AutoReview),+ environments: Some(TurnEnvironmentSelections::new(+ test.config.cwd.clone(),+ vec![primary],+ )),+ ..Default::default()+ }),+ )+ .await?;+ timeout(+ Duration::from_secs(/*secs*/ 10),+ model.wait_for_request_count(/*count*/ 1),+ )+ .await+ .context("parent must discover skills and reach the model while online")?;+ disconnect.send(()).expect("disconnect primary executor");+ executor.await?;+ request_permission.send(()).expect("request permission");++ timeout(+ Duration::from_secs(/*secs*/ 10),+ model.wait_for_request_count(/*count*/ 2),+ )+ .await+ .context("Guardian startup and turn creation must not wait for host skill discovery")?;+ let requests = model.requests().await;+ let parent: Value = serde_json::from_slice(&requests[0])?;+ let review: Value = serde_json::from_slice(&requests[1])?;+ assert!(+ parent["input"]+ .to_string()+ .contains("guardian-fixture-skill"),+ "parent must advertise the skill discovered on its executor"+ );+ assert_eq!(+ review["client_metadata"]["x-openai-subagent"],+ json!("guardian")+ );+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::GuardianAssessment(assessment)+ if assessment.status == GuardianAssessmentStatus::Denied)+ })+ .await;+ wait_for_event(&test.codex, |event| {+ matches!(event, EventMsg::TurnComplete(_))+ })+ .await;+ test.codex.shutdown_and_wait().await?;+ model.shutdown().await;+ Ok(())+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn guardian_revalidates_allow_with_offline_secondary_executor() -> Result<()> {skip_if_no_network!(Ok(()));diff --git a/codex-rs/core/tests/suite/remote_env.rs b/codex-rs/core/tests/suite/remote_env.rsindex 4b8c919240..622a031e52 100644--- a/codex-rs/core/tests/suite/remote_env.rs+++ b/codex-rs/core/tests/suite/remote_env.rs@@ -1446,6 +1446,19 @@ async fn serve_environment_with_agents_md(listener: TcpListener,contents: &str,attach: tokio::sync::oneshot::Receiver<()>,+ shutdown: tokio::sync::oneshot::Receiver<()>,+) -> usize {+ serve_environment_with_instruction_files(+ listener, contents, /*skill*/ None, attach, shutdown,+ )+ .await+}++async fn serve_environment_with_instruction_files(+ listener: TcpListener,+ contents: &str,+ skill: Option<&str>,+ attach: tokio::sync::oneshot::Receiver<()>,mut shutdown: tokio::sync::oneshot::Receiver<()>,) -> usize {let mut websocket = accept_initialized_exec_server(listener).await;@@ -1461,6 +1474,10 @@ async fn serve_environment_with_agents_md(let is_agents_md = request["params"]["path"].as_str().is_some_and(|path| path.ends_with("/AGENTS.md"));+ let is_skill_root = skill.is_some()+ && request["params"]["path"]+ .as_str()+ .is_some_and(|path| path.ends_with("/.agents/skills"));let response = match request["method"].as_str() {Some("environment/info") => json!({"id": request["id"],@@ -1470,16 +1487,38 @@ async fn serve_environment_with_agents_md("id": request["id"],"result": { "path": request["params"]["path"] }}),- Some("fs/walk") => json!({- "id": request["id"],- "result": { "entries": [], "errors": [], "truncated": false }- }),- Some("fs/getMetadata") if is_agents_md => {+ Some("fs/walk") => {+ let root = request["params"]["path"].as_str().expect("walk root");+ let entries = if is_skill_root {+ vec![json!({+ "path": format!("{root}/guardian-fixture-skill/SKILL.md"),+ "kind": "file",+ })]+ } else {+ Vec::new()+ };+ json!({+ "id": request["id"],+ "result": { "entries": entries, "errors": [], "truncated": false }+ })+ }+ Some("fs/readFile")+ if skill.is_some()+ && request["params"]["path"]+ .as_str()+ .is_some_and(|path| path.ends_with("/guardian-fixture-skill/SKILL.md")) =>+ {+ json!({+ "id": request["id"],+ "result": { "dataBase64": BASE64_STANDARD.encode(skill.expect("skill contents")) }+ })+ }+ Some("fs/getMetadata") if is_agents_md || is_skill_root => {json!({"id": request["id"],"result": {- "isDirectory": false,- "isFile": true,+ "isDirectory": is_skill_root,+ "isFile": is_agents_md,"isSymlink": false,"size": contents.len(),"createdAtMs": 0,