[3 of 7] Remove UserTurn (#23075)

**Stack position:** [3 of 7]

## Summary

This PR finishes the input-op consolidation by moving the remaining
`Op::UserTurn` callers onto `Op::UserInput` and deleting `Op::UserTurn`.
This touches a lot of files, but it is a low-risk mechanical migration.

## Stack

1. [1 of 7] [Add thread settings to
UserInput](https://github.com/openai/codex/pull/23080)
2. [2 of 7] [Remove
UserInputWithTurnContext](https://github.com/openai/codex/pull/23081)
3. [3 of 7] [Remove
UserTurn](https://github.com/openai/codex/pull/23075) (this PR)
4. [4 of 7] [Placeholder for OverrideTurnContext
cleanup](https://github.com/openai/codex/pull/23087)
5. [5 of 7] [Replace OverrideTurnContext with
ThreadSettings](https://github.com/openai/codex/pull/22508)
6. [6 of 7] [Add app-server thread settings
API](https://github.com/openai/codex/pull/22509)
7. [7 of 7] [Sync TUI thread
settings](https://github.com/openai/codex/pull/22510)
This commit is contained in:
Eric Traut authored and GitHub committed 2026-05-18 19:56:00 -07:00
1 parent e811234484
commit 1a25d8b6e5
42 files changed
+1139 -1024

No files matched your search

+20 -13
View File
@@ -706,22 +706,29 @@ async fn run_review_on_session(
let submit_result = run_before_review_deadline( let submit_result = run_before_review_deadline(
deadline, deadline,
params.external_cancel.as_ref(), params.external_cancel.as_ref(),
Box::pin(review_session.codex.submit(Op::UserTurn { Box::pin(review_session.codex.submit(Op::UserInput {
environments: None,
items: prompt_items.items, items: prompt_items.items,
#[allow(deprecated)] environments: None,
cwd: params.parent_turn.cwd.to_path_buf(),
approval_policy: AskForApproval::Never,
approvals_reviewer: None,
sandbox_policy: legacy_sandbox_policy,
permission_profile: Some(guardian_permission_profile),
model: params.model.clone(),
effort: params.reasoning_effort,
summary: Some(params.reasoning_summary),
service_tier: None,
final_output_json_schema: Some(params.schema.clone()), final_output_json_schema: Some(params.schema.clone()),
collaboration_mode: None, responsesapi_client_metadata: None,
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
#[allow(deprecated)]
cwd: Some(params.parent_turn.cwd.to_path_buf()),
approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(legacy_sandbox_policy),
permission_profile: Some(guardian_permission_profile),
summary: Some(params.reasoning_summary),
personality: params.personality, personality: params.personality,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: params.model.clone(),
reasoning_effort: params.reasoning_effort,
developer_instructions: None,
},
}),
..Default::default()
},
})), })),
) )
.await; .await;
+1 -54
View File
@@ -49,9 +49,6 @@ use codex_protocol::request_permissions::RequestPermissionsResponse;
use codex_protocol::request_user_input::RequestUserInputResponse; use codex_protocol::request_user_input::RequestUserInputResponse;
use crate::context_manager::is_user_turn_boundary; use crate::context_manager::is_user_turn_boundary;
use codex_protocol::config_types::CollaborationMode;
use codex_protocol::config_types::ModeKind;
use codex_protocol::config_types::Settings;
use codex_protocol::dynamic_tools::DynamicToolResponse; use codex_protocol::dynamic_tools::DynamicToolResponse;
use codex_protocol::items::UserMessageItem; use codex_protocol::items::UserMessageItem;
use codex_protocol::mcp::RequestId as ProtocolRequestId; use codex_protocol::mcp::RequestId as ProtocolRequestId;
@@ -114,56 +111,6 @@ pub(super) async fn user_input_or_turn_inner(
mirror_user_text_to_realtime: Option<()>, mirror_user_text_to_realtime: Option<()>,
) { ) {
let (items, updates, responsesapi_client_metadata) = match op { let (items, updates, responsesapi_client_metadata) = match op {
Op::UserTurn {
cwd,
approval_policy,
approvals_reviewer,
sandbox_policy,
permission_profile,
model,
effort,
summary,
service_tier,
final_output_json_schema,
items,
collaboration_mode,
personality,
environments,
} => {
let collaboration_mode = collaboration_mode.or_else(|| {
Some(CollaborationMode {
mode: ModeKind::Default,
settings: Settings {
model: model.clone(),
reasoning_effort: effort,
developer_instructions: None,
},
})
});
(
items,
SessionSettingsUpdate {
cwd: Some(cwd),
approval_policy: Some(approval_policy),
approvals_reviewer,
sandbox_policy: Some(sandbox_policy),
workspace_roots: None,
profile_workspace_roots: None,
permission_profile,
active_permission_profile: None,
windows_sandbox_level: None,
collaboration_mode,
reasoning_summary: summary,
service_tier,
final_output_json_schema: Some(final_output_json_schema),
environments,
personality,
app_server_client_name: None,
app_server_client_version: None,
},
None,
)
}
Op::UserInput { Op::UserInput {
items, items,
environments, environments,
@@ -826,7 +773,7 @@ pub(super) async fn submission_loop(
.await; .await;
false false
} }
Op::UserInput { .. } | Op::UserTurn { .. } => { Op::UserInput { .. } => {
user_input_or_turn(&sess, sub.id.clone(), sub.op).await; user_input_or_turn(&sess, sub.id.clone(), sub.op).await;
false false
} }
+20 -13
View File
@@ -5197,7 +5197,7 @@ fn submission_dispatch_span_uses_debug_for_realtime_audio() {
} }
#[test] #[test]
fn op_kind_distinguishes_turn_ops() { fn op_kind_for_input_and_context_ops() {
assert_eq!( assert_eq!(
Op::OverrideTurnContext { Op::OverrideTurnContext {
cwd: None, cwd: None,
@@ -5237,24 +5237,31 @@ async fn user_turn_updates_approvals_reviewer() {
handlers::user_input_or_turn( handlers::user_input_or_turn(
&session, &session,
"sub-1".to_string(), "sub-1".to_string(),
Op::UserTurn { Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello".to_string(), text: "hello".to_string(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
cwd: config.cwd.to_path_buf(), environments: None,
approval_policy: config.permissions.approval_policy.value(),
approvals_reviewer: Some(codex_config::types::ApprovalsReviewer::AutoReview),
sandbox_policy: config.legacy_sandbox_policy(),
permission_profile: None,
model: turn_context.model_info.slug.clone(),
effort: config.model_reasoning_effort,
summary: config.model_reasoning_summary,
service_tier: None,
final_output_json_schema: None, final_output_json_schema: None,
collaboration_mode: None, responsesapi_client_metadata: None,
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(config.cwd.to_path_buf()),
approval_policy: Some(config.permissions.approval_policy.value()),
approvals_reviewer: Some(codex_config::types::ApprovalsReviewer::AutoReview),
sandbox_policy: Some(config.legacy_sandbox_policy()),
summary: config.model_reasoning_summary,
personality: config.personality, personality: config.personality,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: turn_context.model_info.slug.clone(),
reasoning_effort: config.model_reasoning_effort,
developer_instructions: None,
},
}),
..Default::default()
},
}, },
) )
.await; .await;
+25 -13
View File
@@ -190,8 +190,14 @@ pub enum ApplyPatchModelOutput {
ShellCommandViaHeredoc, ShellCommandViaHeredoc,
} }
/// Returns the permission fields required by `Op::UserTurn` for tests that /// A collection of different ways the model can output an apply_patch call
/// construct the op directly. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum ShellModelOutput {
ShellCommand,
// UnifiedExec has its own set of tests
}
/// Returns the permission fields required by test thread-settings overrides.
pub fn turn_permission_fields( pub fn turn_permission_fields(
permission_profile: PermissionProfile, permission_profile: PermissionProfile,
cwd: &Path, cwd: &Path,
@@ -754,24 +760,30 @@ impl TestCodex {
turn_permission_fields(permission_profile, self.config.cwd.as_path()); turn_permission_fields(permission_profile, self.config.cwd.as_path());
let session_model = self.session_configured.model.clone(); let session_model = self.session_configured.model.clone();
self.codex self.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: prompt.into(), text: prompt.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments,
final_output_json_schema: None, final_output_json_schema: None,
cwd: self.config.cwd.to_path_buf(), responsesapi_client_metadata: None,
approval_policy, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(self.config.cwd.to_path_buf()),
sandbox_policy, approval_policy: Some(approval_policy),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
model: session_model,
effort: None,
summary: None,
service_tier, service_tier,
collaboration_mode: None, collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
personality: None, mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model,
reasoning_effort: None,
developer_instructions: None,
},
}),
..Default::default()
},
}) })
.await?; .await?;
+16 -11
View File
@@ -83,24 +83,29 @@ async fn submit_without_wait_with_turn_permissions(
let test = harness.test(); let test = harness.test();
let session_model = test.session_configured.model.clone(); let session_model = test.session_configured.model.clone();
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: prompt.into(), text: prompt.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: harness.cwd().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(harness.cwd().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
Ok(()) Ok(())
+32 -21
View File
@@ -644,24 +644,29 @@ async fn submit_turn(
let session_model = test.session_configured.model.clone(); let session_model = test.session_configured.model.clone();
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: prompt.into(), text: prompt.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(test.cwd.path().to_path_buf()),
approval_policy: Some(approval_policy),
approvals_reviewer: Some(ApprovalsReviewer::User), approvals_reviewer: Some(ApprovalsReviewer::User),
sandbox_policy, sandbox_policy: Some(sandbox_policy),
permission_profile: None, collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -2578,24 +2583,30 @@ async fn matched_prefix_rule_runs_unsandboxed_under_zsh_fork() -> Result<()> {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(permission_profile, test.cwd.path()); turn_permission_fields(permission_profile, test.cwd.path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "run allowed touch under zsh fork".into(), text: "run allowed touch under zsh fork".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(test.cwd.path().to_path_buf()),
approval_policy: Some(approval_policy),
approvals_reviewer: Some(ApprovalsReviewer::User), approvals_reviewer: Some(ApprovalsReviewer::User),
sandbox_policy, sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+29 -31
View File
@@ -1758,12 +1758,7 @@ async fn user_turn_collaboration_mode_overrides_model_and_effort() -> anyhow::Re
sse(vec![ev_response_created("resp1"), ev_completed("resp1")]), sse(vec![ev_response_created("resp1"), ev_completed("resp1")]),
) )
.await; .await;
let TestCodex { let TestCodex { codex, config, .. } = test_codex().with_model("gpt-5.4").build(&server).await?;
codex,
config,
session_configured,
..
} = test_codex().with_model("gpt-5.4").build(&server).await?;
let collaboration_mode = CollaborationMode { let collaboration_mode = CollaborationMode {
mode: ModeKind::Default, mode: ModeKind::Default,
@@ -1775,28 +1770,26 @@ async fn user_turn_collaboration_mode_overrides_model_and_effort() -> anyhow::Re
}; };
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello".into(), text: "hello".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
cwd: config.cwd.to_path_buf(), environments: None,
approval_policy: config.permissions.approval_policy.value(), final_output_json_schema: None,
approvals_reviewer: None, responsesapi_client_metadata: None,
sandbox_policy: config.legacy_sandbox_policy(), thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
permission_profile: None, cwd: Some(config.cwd.to_path_buf()),
model: session_configured.model.clone(), approval_policy: Some(config.permissions.approval_policy.value()),
effort: Some(ReasoningEffort::Low), sandbox_policy: Some(config.legacy_sandbox_policy()),
summary: Some( summary: Some(
config config
.model_reasoning_summary .model_reasoning_summary
.unwrap_or(ReasoningSummary::Auto), .unwrap_or(ReasoningSummary::Auto),
), ),
service_tier: None,
collaboration_mode: Some(collaboration_mode), collaboration_mode: Some(collaboration_mode),
final_output_json_schema: None, ..Default::default()
personality: None, },
}) })
.await?; .await?;
@@ -1898,24 +1891,29 @@ async fn user_turn_explicit_reasoning_summary_overrides_model_catalog_default()
.await?; .await?;
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello".into(), text: "hello".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
cwd: config.cwd.to_path_buf(), environments: None,
approval_policy: config.permissions.approval_policy.value(),
approvals_reviewer: None,
sandbox_policy: config.legacy_sandbox_policy(),
permission_profile: None,
model: session_configured.model,
effort: None,
summary: Some(ReasoningSummary::Concise),
service_tier: None,
collaboration_mode: None,
final_output_json_schema: None, final_output_json_schema: None,
personality: None, responsesapi_client_metadata: None,
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(config.cwd.to_path_buf()),
approval_policy: Some(config.permissions.approval_policy.value()),
sandbox_policy: Some(config.legacy_sandbox_policy()),
summary: Some(ReasoningSummary::Concise),
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_configured.model,
reasoning_effort: None,
developer_instructions: None,
},
}),
..Default::default()
},
}) })
.await .await
.unwrap(); .unwrap();
+16 -11
View File
@@ -2584,24 +2584,29 @@ text(
turn_permission_fields(PermissionProfile::Disabled, cwd.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd.as_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "use exec to inspect and call hidden tools".into(), text: "use exec to inspect and call hidden tools".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: test.session_configured.model.clone(), model: test.session_configured.model.clone(),
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -178,28 +178,26 @@ async fn collaboration_instructions_added_on_user_turn() -> Result<()> {
let collaboration_mode = collab_mode_with_instructions(Some(collab_text)); let collaboration_mode = collab_mode_with_instructions(Some(collab_text));
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello".into(), text: "hello".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
cwd: test.config.cwd.to_path_buf(), environments: None,
approval_policy: test.config.permissions.approval_policy.value(), final_output_json_schema: None,
approvals_reviewer: None, responsesapi_client_metadata: None,
sandbox_policy: test.config.legacy_sandbox_policy(), thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
permission_profile: None, cwd: Some(test.config.cwd.to_path_buf()),
model: test.session_configured.model.clone(), approval_policy: Some(test.config.permissions.approval_policy.value()),
effort: None, sandbox_policy: Some(test.config.legacy_sandbox_policy()),
summary: Some( summary: Some(
test.config test.config
.model_reasoning_summary .model_reasoning_summary
.unwrap_or(codex_protocol::config_types::ReasoningSummary::Auto), .unwrap_or(codex_protocol::config_types::ReasoningSummary::Auto),
), ),
service_tier: None,
collaboration_mode: Some(collaboration_mode), collaboration_mode: Some(collaboration_mode),
final_output_json_schema: None, ..Default::default()
personality: None, },
}) })
.await?; .await?;
wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
@@ -230,28 +228,26 @@ async fn collaboration_instructions_omitted_when_disabled() -> Result<()> {
let collaboration_mode = collab_mode_with_instructions(Some("turn instructions")); let collaboration_mode = collab_mode_with_instructions(Some("turn instructions"));
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello".into(), text: "hello".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
cwd: test.config.cwd.to_path_buf(), environments: None,
approval_policy: test.config.permissions.approval_policy.value(), final_output_json_schema: None,
approvals_reviewer: None, responsesapi_client_metadata: None,
sandbox_policy: test.config.legacy_sandbox_policy(), thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
permission_profile: None, cwd: Some(test.config.cwd.to_path_buf()),
model: test.session_configured.model.clone(), approval_policy: Some(test.config.permissions.approval_policy.value()),
effort: None, sandbox_policy: Some(test.config.legacy_sandbox_policy()),
summary: Some( summary: Some(
test.config test.config
.model_reasoning_summary .model_reasoning_summary
.unwrap_or(codex_protocol::config_types::ReasoningSummary::Auto), .unwrap_or(codex_protocol::config_types::ReasoningSummary::Auto),
), ),
service_tier: None,
collaboration_mode: Some(collaboration_mode), collaboration_mode: Some(collaboration_mode),
final_output_json_schema: None, ..Default::default()
personality: None, },
}) })
.await?; .await?;
wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
@@ -355,28 +351,26 @@ async fn user_turn_overrides_collaboration_instructions_after_override() -> Resu
.await?; .await?;
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello".into(), text: "hello".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
cwd: test.config.cwd.to_path_buf(), environments: None,
approval_policy: test.config.permissions.approval_policy.value(), final_output_json_schema: None,
approvals_reviewer: None, responsesapi_client_metadata: None,
sandbox_policy: test.config.legacy_sandbox_policy(), thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
permission_profile: None, cwd: Some(test.config.cwd.to_path_buf()),
model: test.session_configured.model.clone(), approval_policy: Some(test.config.permissions.approval_policy.value()),
effort: None, sandbox_policy: Some(test.config.legacy_sandbox_policy()),
summary: Some( summary: Some(
test.config test.config
.model_reasoning_summary .model_reasoning_summary
.unwrap_or(codex_protocol::config_types::ReasoningSummary::Auto), .unwrap_or(codex_protocol::config_types::ReasoningSummary::Auto),
), ),
service_tier: None,
collaboration_mode: Some(turn_mode), collaboration_mode: Some(turn_mode),
final_output_json_schema: None, ..Default::default()
personality: None, },
}) })
.await?; .await?;
wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
+16 -11
View File
@@ -88,24 +88,29 @@ fn ev_shell_command_call(call_id: &str, command: &str) -> serde_json::Value {
fn disabled_permission_user_turn(text: impl Into<String>, cwd: PathBuf, model: String) -> Op { fn disabled_permission_user_turn(text: impl Into<String>, cwd: PathBuf, model: String) -> Op {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, cwd.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd.as_path());
Op::UserTurn { Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: text.into(), text: text.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model, model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
} }
} }
+34 -22
View File
@@ -46,24 +46,31 @@ async fn submit_user_turn(
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(permission_profile, test.config.cwd.as_path()); turn_permission_fields(permission_profile, test.config.cwd.as_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: prompt.into(), text: prompt.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd_path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.cwd_path().to_path_buf()),
sandbox_policy, approval_policy: Some(approval_policy),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: collaboration_mode.or({
Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode, })
personality: None, }),
..Default::default()
},
}) })
.await?; .await?;
Ok(()) Ok(())
@@ -126,24 +133,29 @@ async fn execpolicy_blocks_shell_invocation() -> Result<()> {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, test.config.cwd.as_path()); turn_permission_fields(PermissionProfile::Disabled, test.config.cwd.as_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "run shell command".into(), text: "run shell command".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd_path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.cwd_path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+32 -22
View File
@@ -113,8 +113,7 @@ async fn copy_paste_local_image_persists_rollout_request_shape() -> anyhow::Resu
turn_permission_fields(PermissionProfile::Disabled, cwd.path()); turn_permission_fields(PermissionProfile::Disabled, cwd.path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![ items: vec![
UserInput::LocalImage { UserInput::LocalImage {
path: abs_path.clone(), path: abs_path.clone(),
@@ -125,18 +124,24 @@ async fn copy_paste_local_image_persists_rollout_request_shape() -> anyhow::Resu
text_elements: Vec::new(), text_elements: Vec::new(),
}, },
], ],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd.path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -204,8 +209,7 @@ async fn drag_drop_image_persists_rollout_request_shape() -> anyhow::Result<()>
turn_permission_fields(PermissionProfile::Disabled, cwd.path()); turn_permission_fields(PermissionProfile::Disabled, cwd.path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![ items: vec![
UserInput::Image { UserInput::Image {
image_url: image_url.clone(), image_url: image_url.clone(),
@@ -216,18 +220,24 @@ async fn drag_drop_image_persists_rollout_request_shape() -> anyhow::Result<()>
text_elements: Vec::new(), text_elements: Vec::new(),
}, },
], ],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd.path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+10 -12
View File
@@ -44,30 +44,28 @@ use std::path::PathBuf;
fn disabled_plan_turn( fn disabled_plan_turn(
text: &str, text: &str,
model: String, _model: String,
collaboration_mode: CollaborationMode, collaboration_mode: CollaborationMode,
) -> anyhow::Result<Op> { ) -> anyhow::Result<Op> {
let cwd = std::env::current_dir()?; let cwd = std::env::current_dir()?;
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, cwd.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd.as_path());
Ok(Op::UserTurn { Ok(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: text.into(), text: text.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
model,
effort: None,
summary: None,
service_tier: None,
collaboration_mode: Some(collaboration_mode), collaboration_mode: Some(collaboration_mode),
personality: None, ..Default::default()
},
}) })
} }
+16 -11
View File
@@ -75,24 +75,29 @@ async fn codex_returns_json_result(model: String) -> anyhow::Result<()> {
// 1) Normal user input – should hit server once. // 1) Normal user input – should hit server once.
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello world".into(), text: "hello world".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: Some(serde_json::from_str(SCHEMA)?), final_output_json_schema: Some(serde_json::from_str(SCHEMA)?),
cwd: cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd.path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model, model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+20 -12
View File
@@ -64,27 +64,35 @@ async fn submit_user_turn(
approval_policy: AskForApproval, approval_policy: AskForApproval,
collaboration_mode: Option<CollaborationMode>, collaboration_mode: Option<CollaborationMode>,
) -> Result<()> { ) -> Result<()> {
let session_model = test.session_configured.model.clone();
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, test.cwd.path()); turn_permission_fields(PermissionProfile::Disabled, test.cwd.path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: text.to_string(), text: text.to_string(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.cwd.path().to_path_buf()),
sandbox_policy, approval_policy: Some(approval_policy),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
model: test.session_configured.model.clone(), collaboration_mode: collaboration_mode.or({
effort: None, Some(codex_protocol::config_types::CollaborationMode {
summary: None, mode: codex_protocol::config_types::ModeKind::Default,
service_tier: None, settings: codex_protocol::config_types::Settings {
collaboration_mode, model: session_model,
personality: None, reasoning_effort: None,
developer_instructions: None,
},
})
}),
..Default::default()
},
}) })
.await?; .await?;
Ok(()) Ok(())
+16 -11
View File
@@ -42,21 +42,26 @@ use wiremock::MockServer;
fn read_only_user_turn(test: &TestCodex, items: Vec<UserInput>, model: String) -> Op { fn read_only_user_turn(test: &TestCodex, items: Vec<UserInput>, model: String) -> Op {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::read_only(), test.cwd_path()); turn_permission_fields(PermissionProfile::read_only(), test.cwd_path());
Op::UserTurn { Op::UserInput {
environments: None,
items, items,
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd_path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.cwd_path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model, model,
effort: test.config.model_reasoning_effort, reasoning_effort: test.config.model_reasoning_effort,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
} }
} }
@@ -117,24 +117,29 @@ async fn snapshot_model_visible_layout_turn_overrides() -> Result<()> {
turn_permission_fields(PermissionProfile::read_only(), first_turn_cwd.as_path()); turn_permission_fields(PermissionProfile::read_only(), first_turn_cwd.as_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "first turn".into(), text: "first turn".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: first_turn_cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(first_turn_cwd),
sandbox_policy: first_sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(first_sandbox_policy),
permission_profile: first_permission_profile, permission_profile: first_permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: test.session_configured.model.clone(), model: test.session_configured.model.clone(),
effort: test.config.model_reasoning_effort, reasoning_effort: test.config.model_reasoning_effort,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
wait_for_event(&test.codex, |event| { wait_for_event(&test.codex, |event| {
@@ -147,24 +152,30 @@ async fn snapshot_model_visible_layout_turn_overrides() -> Result<()> {
preturn_context_diff_cwd.as_path(), preturn_context_diff_cwd.as_path(),
); );
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "second turn with context updates".into(), text: "second turn with context updates".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: preturn_context_diff_cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::OnRequest, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(preturn_context_diff_cwd),
sandbox_policy: second_sandbox_policy, approval_policy: Some(AskForApproval::OnRequest),
sandbox_policy: Some(second_sandbox_policy),
permission_profile: second_permission_profile, permission_profile: second_permission_profile,
model: test.session_configured.model.clone(),
effort: test.config.model_reasoning_effort,
summary: None,
service_tier: None,
collaboration_mode: None,
personality: Some(Personality::Friendly), personality: Some(Personality::Friendly),
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: test.session_configured.model.clone(),
reasoning_effort: test.config.model_reasoning_effort,
developer_instructions: None,
},
}),
..Default::default()
},
}) })
.await?; .await?;
wait_for_event(&test.codex, |event| { wait_for_event(&test.codex, |event| {
@@ -230,24 +241,29 @@ async fn snapshot_model_visible_layout_cwd_change_does_not_refresh_agents() -> R
turn_permission_fields(PermissionProfile::read_only(), cwd_one.as_path()); turn_permission_fields(PermissionProfile::read_only(), cwd_one.as_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "first turn in agents_one".into(), text: "first turn in agents_one".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd_one.clone(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd_one.clone()),
sandbox_policy: first_sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(first_sandbox_policy),
permission_profile: first_permission_profile, permission_profile: first_permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: test.session_configured.model.clone(), model: test.session_configured.model.clone(),
effort: test.config.model_reasoning_effort, reasoning_effort: test.config.model_reasoning_effort,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
wait_for_event(&test.codex, |event| { wait_for_event(&test.codex, |event| {
@@ -258,24 +274,29 @@ async fn snapshot_model_visible_layout_cwd_change_does_not_refresh_agents() -> R
let (second_sandbox_policy, second_permission_profile) = let (second_sandbox_policy, second_permission_profile) =
turn_permission_fields(PermissionProfile::read_only(), cwd_two.as_path()); turn_permission_fields(PermissionProfile::read_only(), cwd_two.as_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "second turn in agents_two".into(), text: "second turn in agents_two".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd_two, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd_two),
sandbox_policy: second_sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(second_sandbox_policy),
permission_profile: second_permission_profile, permission_profile: second_permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: test.session_configured.model.clone(), model: test.session_configured.model.clone(),
effort: test.config.model_reasoning_effort, reasoning_effort: test.config.model_reasoning_effort,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
wait_for_event(&test.codex, |event| { wait_for_event(&test.codex, |event| {
@@ -377,24 +398,30 @@ async fn snapshot_model_visible_layout_resume_with_personality_change() -> Resul
); );
resumed resumed
.codex .codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "resume and change personality".into(), text: "resume and change personality".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: resume_override_cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(resume_override_cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
model: resumed.session_configured.model.clone(),
effort: resumed.config.model_reasoning_effort,
summary: None,
service_tier: None,
collaboration_mode: None,
personality: Some(Personality::Friendly), personality: Some(Personality::Friendly),
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: resumed.session_configured.model.clone(),
reasoning_effort: resumed.config.model_reasoning_effort,
developer_instructions: None,
},
}),
..Default::default()
},
}) })
.await?; .await?;
wait_for_event(&resumed.codex, |event| { wait_for_event(&resumed.codex, |event| {
+16 -11
View File
@@ -92,24 +92,29 @@ async fn renews_cache_ttl_on_matching_models_etag() -> Result<()> {
turn_permission_fields(PermissionProfile::Disabled, test.cwd_path()); turn_permission_fields(PermissionProfile::Disabled, test.cwd_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hi".into(), text: "hi".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd_path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: codex_protocol::protocol::AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.cwd_path().to_path_buf()),
sandbox_policy, approval_policy: Some(codex_protocol::protocol::AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: test.session_configured.model.clone(), model: test.session_configured.model.clone(),
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -104,24 +104,29 @@ async fn refresh_models_on_models_etag_mismatch_and_avoid_duplicate_models_fetch
.await; .await;
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "please run a tool".into(), text: "please run a tool".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd_path, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd_path),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+16 -11
View File
@@ -113,24 +113,29 @@ async fn submit_danger_full_access_user_turn(test: &TestCodex, text: &str) {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, test.config.cwd.as_path()); turn_permission_fields(PermissionProfile::Disabled, test.config.cwd.as_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: text.to_string(), text: text.to_string(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.config.cwd.to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.config.cwd.to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: test.session_configured.model.clone(), model: test.session_configured.model.clone(),
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await .await
.unwrap_or_else(|err| panic!("submit user turn: {err}")); .unwrap_or_else(|err| panic!("submit user turn: {err}"));
+17 -11
View File
@@ -60,24 +60,30 @@ fn read_only_text_turn_with_personality(
) -> Op { ) -> Op {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::read_only(), test.cwd_path()); turn_permission_fields(PermissionProfile::read_only(), test.cwd_path());
Op::UserTurn { Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: text.into(), text: text.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd_path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.cwd_path().to_path_buf()),
sandbox_policy, approval_policy: Some(approval_policy),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
model,
effort: test.config.model_reasoning_effort,
summary: None,
service_tier: None,
collaboration_mode: None,
personality, personality,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model,
reasoning_effort: test.config.model_reasoning_effort,
developer_instructions: None,
},
}),
..Default::default()
},
} }
} }
+87 -66
View File
@@ -714,7 +714,7 @@ async fn per_turn_overrides_keep_cached_prefix_and_key_constant() -> anyhow::Res
.await?; .await?;
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
// Second turn using per-turn overrides via UserTurn // Second turn using per-turn thread-settings overrides.
let new_cwd = TempDir::new().unwrap(); let new_cwd = TempDir::new().unwrap();
let writable = TempDir::new().unwrap(); let writable = TempDir::new().unwrap();
let permission_profile = PermissionProfile::workspace_write_with( let permission_profile = PermissionProfile::workspace_write_with(
@@ -726,24 +726,24 @@ async fn per_turn_overrides_keep_cached_prefix_and_key_constant() -> anyhow::Res
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(permission_profile, new_cwd.path()); turn_permission_fields(permission_profile, new_cwd.path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello 2".into(), text: "hello 2".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
cwd: new_cwd.path().to_path_buf(), environments: None,
approval_policy: AskForApproval::Never,
approvals_reviewer: None,
sandbox_policy,
permission_profile,
model: "o3".to_string(),
effort: Some(ReasoningEffort::High),
summary: Some(ReasoningSummary::Detailed),
service_tier: None,
collaboration_mode: None,
final_output_json_schema: None, final_output_json_schema: None,
personality: None, responsesapi_client_metadata: None,
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(new_cwd.path().to_path_buf()),
approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile,
model: Some("o3".to_string()),
effort: Some(Some(ReasoningEffort::High)),
summary: Some(ReasoningSummary::Detailed),
..Default::default()
},
}) })
.await?; .await?;
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
@@ -840,47 +840,57 @@ async fn send_user_turn_with_no_changes_does_not_send_environment_context() -> a
let default_summary = config.model_reasoning_summary; let default_summary = config.model_reasoning_summary;
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello 1".into(), text: "hello 1".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
cwd: default_cwd.to_path_buf(), environments: None,
approval_policy: default_approval_policy,
approvals_reviewer: None,
sandbox_policy: default_sandbox_policy.clone(),
permission_profile: None,
model: default_model.clone(),
effort: default_effort,
summary: Some(default_summary.unwrap_or(ReasoningSummary::Auto)),
service_tier: None,
collaboration_mode: None,
final_output_json_schema: None, final_output_json_schema: None,
personality: None, responsesapi_client_metadata: None,
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(default_cwd.to_path_buf()),
approval_policy: Some(default_approval_policy),
sandbox_policy: Some(default_sandbox_policy.clone()),
summary: Some(default_summary.unwrap_or(ReasoningSummary::Auto)),
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: default_model.clone(),
reasoning_effort: default_effort,
developer_instructions: None,
},
}),
..Default::default()
},
}) })
.await?; .await?;
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello 2".into(), text: "hello 2".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
cwd: default_cwd.to_path_buf(), environments: None,
approval_policy: default_approval_policy,
approvals_reviewer: None,
sandbox_policy: default_sandbox_policy.clone(),
permission_profile: None,
model: default_model.clone(),
effort: default_effort,
summary: Some(default_summary.unwrap_or(ReasoningSummary::Auto)),
service_tier: None,
collaboration_mode: None,
final_output_json_schema: None, final_output_json_schema: None,
personality: None, responsesapi_client_metadata: None,
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(default_cwd.to_path_buf()),
approval_policy: Some(default_approval_policy),
sandbox_policy: Some(default_sandbox_policy.clone()),
summary: Some(default_summary.unwrap_or(ReasoningSummary::Auto)),
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: default_model.clone(),
reasoning_effort: default_effort,
developer_instructions: None,
},
}),
..Default::default()
},
}) })
.await?; .await?;
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
@@ -969,24 +979,29 @@ async fn send_user_turn_with_changes_sends_environment_context() -> anyhow::Resu
let default_summary = config.model_reasoning_summary; let default_summary = config.model_reasoning_summary;
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello 1".into(), text: "hello 1".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
cwd: default_cwd.to_path_buf(), environments: None,
approval_policy: default_approval_policy,
approvals_reviewer: None,
sandbox_policy: default_sandbox_policy.clone(),
permission_profile: None,
model: default_model,
effort: default_effort,
summary: Some(default_summary.unwrap_or(ReasoningSummary::Auto)),
service_tier: None,
collaboration_mode: None,
final_output_json_schema: None, final_output_json_schema: None,
personality: None, responsesapi_client_metadata: None,
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(default_cwd.to_path_buf()),
approval_policy: Some(default_approval_policy),
sandbox_policy: Some(default_sandbox_policy.clone()),
summary: Some(default_summary.unwrap_or(ReasoningSummary::Auto)),
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: default_model,
reasoning_effort: default_effort,
developer_instructions: None,
},
}),
..Default::default()
},
}) })
.await?; .await?;
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
@@ -994,24 +1009,30 @@ async fn send_user_turn_with_changes_sends_environment_context() -> anyhow::Resu
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, default_cwd.as_path()); turn_permission_fields(PermissionProfile::Disabled, default_cwd.as_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello 2".into(), text: "hello 2".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
cwd: default_cwd.to_path_buf(), environments: None,
approval_policy: AskForApproval::Never,
approvals_reviewer: None,
sandbox_policy,
permission_profile,
model: "o3".to_string(),
effort: Some(ReasoningEffort::High),
summary: Some(ReasoningSummary::Detailed),
service_tier: None,
collaboration_mode: None,
final_output_json_schema: None, final_output_json_schema: None,
personality: None, responsesapi_client_metadata: None,
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(default_cwd.to_path_buf()),
approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile,
summary: Some(ReasoningSummary::Detailed),
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: "o3".to_string(),
reasoning_effort: Some(ReasoningEffort::High),
developer_instructions: None,
},
}),
..Default::default()
},
}) })
.await?; .await?;
wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await; wait_for_event(&codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
+16 -11
View File
@@ -67,24 +67,29 @@ async fn submit_turn_with_approval_and_environments(
environments: Vec<TurnEnvironmentSelection>, environments: Vec<TurnEnvironmentSelection>,
) -> Result<()> { ) -> Result<()> {
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: Some(environments),
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: prompt.into(), text: prompt.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: Some(environments),
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::OnRequest, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(test.cwd.path().to_path_buf()),
approval_policy: Some(AskForApproval::OnRequest),
approvals_reviewer: Some(ApprovalsReviewer::User), approvals_reviewer: Some(ApprovalsReviewer::User),
sandbox_policy: SandboxPolicy::new_read_only_policy(), sandbox_policy: Some(SandboxPolicy::new_read_only_policy()),
permission_profile: None, collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: test.session_configured.model.clone(), model: test.session_configured.model.clone(),
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+47 -110
View File
@@ -142,9 +142,7 @@ async fn remote_models_config_context_window_override_clamps_to_max_context_wind
) )
.await; .await;
let TestCodex { let TestCodex { codex, .. } = test_codex()
codex, cwd, config, ..
} = test_codex()
.with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing()) .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
.with_config(|config| { .with_config(|config| {
config.model = Some(requested_model.to_string()); config.model = Some(requested_model.to_string());
@@ -154,24 +152,15 @@ async fn remote_models_config_context_window_override_clamps_to_max_context_wind
.await?; .await?;
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "check context window".into(), text: "check context window".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
final_output_json_schema: None,
cwd: cwd.path().to_path_buf(),
approval_policy: config.permissions.approval_policy.value(),
approvals_reviewer: None,
sandbox_policy: config.legacy_sandbox_policy(),
model: requested_model.to_string(),
effort: None,
summary: None,
service_tier: None,
collaboration_mode: None,
permission_profile: None,
personality: None,
environments: None, environments: None,
final_output_json_schema: None,
responsesapi_client_metadata: None,
thread_settings: Default::default(),
}) })
.await?; .await?;
@@ -220,9 +209,7 @@ async fn remote_models_config_override_above_max_uses_max_context_window() -> Re
) )
.await; .await;
let TestCodex { let TestCodex { codex, .. } = test_codex()
codex, cwd, config, ..
} = test_codex()
.with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing()) .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
.with_config(|config| { .with_config(|config| {
config.model = Some(requested_model.to_string()); config.model = Some(requested_model.to_string());
@@ -232,24 +219,15 @@ async fn remote_models_config_override_above_max_uses_max_context_window() -> Re
.await?; .await?;
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "check context window".into(), text: "check context window".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
final_output_json_schema: None,
cwd: cwd.path().to_path_buf(),
approval_policy: config.permissions.approval_policy.value(),
approvals_reviewer: None,
sandbox_policy: config.legacy_sandbox_policy(),
model: requested_model.to_string(),
effort: None,
summary: None,
service_tier: None,
collaboration_mode: None,
permission_profile: None,
personality: None,
environments: None, environments: None,
final_output_json_schema: None,
responsesapi_client_metadata: None,
thread_settings: Default::default(),
}) })
.await?; .await?;
@@ -298,9 +276,7 @@ async fn remote_models_use_context_window_when_config_override_is_absent() -> Re
) )
.await; .await;
let TestCodex { let TestCodex { codex, .. } = test_codex()
codex, cwd, config, ..
} = test_codex()
.with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing()) .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
.with_config(|config| { .with_config(|config| {
config.model = Some(requested_model.to_string()); config.model = Some(requested_model.to_string());
@@ -309,24 +285,15 @@ async fn remote_models_use_context_window_when_config_override_is_absent() -> Re
.await?; .await?;
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "check context window".into(), text: "check context window".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
final_output_json_schema: None,
cwd: cwd.path().to_path_buf(),
approval_policy: config.permissions.approval_policy.value(),
approvals_reviewer: None,
sandbox_policy: config.legacy_sandbox_policy(),
model: requested_model.to_string(),
effort: None,
summary: None,
service_tier: None,
collaboration_mode: None,
permission_profile: None,
personality: None,
environments: None, environments: None,
final_output_json_schema: None,
responsesapi_client_metadata: None,
thread_settings: Default::default(),
}) })
.await?; .await?;
@@ -388,9 +355,7 @@ async fn remote_models_long_model_slug_is_sent_with_high_reasoning() -> Result<(
) )
.await; .await;
let TestCodex { let TestCodex { codex, .. } = test_codex()
codex, cwd, config, ..
} = test_codex()
.with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing()) .with_auth(CodexAuth::create_dummy_chatgpt_auth_for_testing())
.with_config(|config| { .with_config(|config| {
config.model = Some(requested_model.to_string()); config.model = Some(requested_model.to_string());
@@ -399,24 +364,15 @@ async fn remote_models_long_model_slug_is_sent_with_high_reasoning() -> Result<(
.await?; .await?;
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "check model slug".into(), text: "check model slug".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
final_output_json_schema: None,
cwd: cwd.path().to_path_buf(),
approval_policy: config.permissions.approval_policy.value(),
approvals_reviewer: None,
sandbox_policy: config.legacy_sandbox_policy(),
permission_profile: None,
model: requested_model.to_string(),
effort: None,
summary: None,
service_tier: None,
collaboration_mode: None,
personality: None,
environments: None, environments: None,
final_output_json_schema: None,
responsesapi_client_metadata: None,
thread_settings: Default::default(),
}) })
.await?; .await?;
@@ -452,36 +408,21 @@ async fn namespaced_model_slug_uses_catalog_metadata_without_fallback_warning()
) )
.await; .await;
let TestCodex { let TestCodex { codex, .. } = test_codex()
codex, cwd, config, ..
} = test_codex()
.with_model(requested_model) .with_model(requested_model)
.build(&server) .build(&server)
.await?; .await?;
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "check namespaced model metadata".into(), text: "check namespaced model metadata".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
final_output_json_schema: None,
cwd: cwd.path().to_path_buf(),
approval_policy: config.permissions.approval_policy.value(),
approvals_reviewer: None,
sandbox_policy: config.legacy_sandbox_policy(),
permission_profile: None,
model: requested_model.to_string(),
effort: None,
summary: Some(
config
.model_reasoning_summary
.unwrap_or(ReasoningSummary::Auto),
),
service_tier: None,
collaboration_mode: None,
personality: None,
environments: None, environments: None,
final_output_json_schema: None,
responsesapi_client_metadata: None,
thread_settings: Default::default(),
}) })
.await?; .await?;
@@ -633,24 +574,22 @@ async fn remote_models_remote_model_uses_unified_exec() -> Result<()> {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "run call".into(), text: "run call".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
final_output_json_schema: None,
cwd: cwd_path,
approval_policy: AskForApproval::Never,
approvals_reviewer: None,
sandbox_policy,
permission_profile,
model: REMOTE_MODEL_SLUG.to_string(),
effort: None,
summary: Some(ReasoningSummary::Auto),
service_tier: None,
collaboration_mode: None,
personality: None,
environments: None, environments: None,
final_output_json_schema: None,
responsesapi_client_metadata: None,
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(cwd_path),
approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile,
summary: Some(ReasoningSummary::Auto),
..Default::default()
},
}) })
.await?; .await?;
@@ -865,24 +804,22 @@ async fn remote_models_apply_remote_base_instructions() -> Result<()> {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello remote".into(), text: "hello remote".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
final_output_json_schema: None,
cwd: cwd_path,
approval_policy: AskForApproval::Never,
approvals_reviewer: None,
sandbox_policy,
permission_profile,
model: model.to_string(),
effort: None,
summary: Some(ReasoningSummary::Auto),
service_tier: None,
collaboration_mode: None,
personality: None,
environments: None, environments: None,
final_output_json_schema: None,
responsesapi_client_metadata: None,
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(cwd_path),
approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile,
summary: Some(ReasoningSummary::Auto),
..Default::default()
},
}) })
.await?; .await?;
@@ -190,24 +190,30 @@ async fn submit_turn(
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(permission_profile, test.cwd.path()); turn_permission_fields(permission_profile, test.cwd.path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: prompt.into(), text: prompt.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(test.cwd.path().to_path_buf()),
approval_policy: Some(approval_policy),
approvals_reviewer: Some(ApprovalsReviewer::User), approvals_reviewer: Some(ApprovalsReviewer::User),
sandbox_policy, sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
Ok(()) Ok(())
@@ -142,24 +142,30 @@ async fn submit_turn(
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(permission_profile, test.config.cwd.as_path()); turn_permission_fields(permission_profile, test.config.cwd.as_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: prompt.into(), text: prompt.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(test.cwd.path().to_path_buf()),
approval_policy: Some(approval_policy),
approvals_reviewer, approvals_reviewer,
sandbox_policy, sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
Ok(()) Ok(())
+27 -34
View File
@@ -132,27 +132,23 @@ async fn request_user_input_round_trip_for_mode(mode: ModeKind) -> anyhow::Resul
]); ]);
let second_mock = responses::mount_sse_once(&server, second_response).await; let second_mock = responses::mount_sse_once(&server, second_response).await;
let session_model = session_configured.model.clone();
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, cwd.path()); turn_permission_fields(PermissionProfile::Disabled, cwd.path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "please confirm".into(), text: "please confirm".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd.path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
model: session_model,
effort: None,
summary: None,
service_tier: None,
collaboration_mode: Some(CollaborationMode { collaboration_mode: Some(CollaborationMode {
mode, mode,
settings: Settings { settings: Settings {
@@ -161,7 +157,8 @@ async fn request_user_input_round_trip_for_mode(mode: ModeKind) -> anyhow::Resul
developer_instructions: None, developer_instructions: None,
}, },
}), }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -282,22 +279,19 @@ async fn request_user_input_interrupt_emits_deferred_token_count() -> anyhow::Re
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, cwd.path()); turn_permission_fields(PermissionProfile::Disabled, cwd.path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "please confirm".into(), text: "please confirm".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd.path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
model: session_configured.model.clone(),
effort: None,
summary: None,
service_tier: None,
collaboration_mode: Some(CollaborationMode { collaboration_mode: Some(CollaborationMode {
mode: ModeKind::Plan, mode: ModeKind::Plan,
settings: Settings { settings: Settings {
@@ -306,7 +300,8 @@ async fn request_user_input_interrupt_emits_deferred_token_count() -> anyhow::Re
developer_instructions: None, developer_instructions: None,
}, },
}), }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -388,24 +383,22 @@ where
turn_permission_fields(PermissionProfile::Disabled, cwd.path()); turn_permission_fields(PermissionProfile::Disabled, cwd.path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "please confirm".into(), text: "please confirm".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd.path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
model: session_model,
effort: None,
summary: None,
service_tier: None,
collaboration_mode: Some(collaboration_mode), collaboration_mode: Some(collaboration_mode),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -130,24 +130,29 @@ async fn submit_turn_with_timeout(test: &TestCodex, prompt: &str) -> Result<()>
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::workspace_write(), cwd.as_path()); turn_permission_fields(PermissionProfile::workspace_write(), cwd.as_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: prompt.into(), text: prompt.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::OnRequest, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd),
sandbox_policy, approval_policy: Some(AskForApproval::OnRequest),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+18 -13
View File
@@ -105,24 +105,29 @@ fn read_only_user_turn_with_model(
let cwd = fixture.cwd.path().to_path_buf(); let cwd = fixture.cwd.path().to_path_buf();
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::read_only(), cwd.as_path()); turn_permission_fields(PermissionProfile::read_only(), cwd.as_path());
Op::UserTurn { Op::UserInput {
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: text.into(), text: text.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
final_output_json_schema: None,
cwd,
approval_policy: AskForApproval::Never,
approvals_reviewer: None,
sandbox_policy,
permission_profile,
model,
effort: None,
summary: None,
service_tier: None,
collaboration_mode: None,
personality: None,
environments: None, environments: None,
final_output_json_schema: None,
responsesapi_client_metadata: None,
thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
cwd: Some(cwd),
approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model,
reasoning_effort: None,
developer_instructions: None,
},
}),
..Default::default()
},
} }
} }
@@ -37,24 +37,29 @@ const CYBER_POLICY_MESSAGE: &str =
fn disabled_text_turn(test: &TestCodex, text: &str) -> Op { fn disabled_text_turn(test: &TestCodex, text: &str) -> Op {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, test.cwd_path()); turn_permission_fields(PermissionProfile::Disabled, test.cwd_path());
Op::UserTurn { Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: text.to_string(), text: text.to_string(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd_path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.cwd_path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: REQUESTED_MODEL.to_string(), model: REQUESTED_MODEL.to_string(),
effort: test.config.model_reasoning_effort, reasoning_effort: test.config.model_reasoning_effort,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
} }
} }
+64 -44
View File
@@ -159,24 +159,29 @@ async fn run_snapshot_command_with_options(
turn_permission_fields(PermissionProfile::Disabled, cwd.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd.as_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "run unified exec with shell snapshot".into(), text: "run unified exec with shell snapshot".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -254,24 +259,29 @@ async fn run_shell_command_snapshot_with_options(
turn_permission_fields(PermissionProfile::Disabled, cwd.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd.as_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "run shell_command with shell snapshot".into(), text: "run shell_command with shell snapshot".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -329,24 +339,29 @@ async fn run_tool_turn_on_harness(
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, cwd.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd.as_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: prompt.into(), text: prompt.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -567,24 +582,29 @@ async fn shell_command_snapshot_still_intercepts_apply_patch() -> Result<()> {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, cwd.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd.as_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "apply patch via shell_command with snapshot".into(), text: "apply patch via shell_command with snapshot".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd.clone(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd.clone()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model, model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+16 -11
View File
@@ -46,24 +46,29 @@ async fn submit_turn_with_policies(
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(permission_profile, test.cwd_path()); turn_permission_fields(permission_profile, test.cwd_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: prompt.to_string(), text: prompt.to_string(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd_path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.cwd_path().to_path_buf()),
sandbox_policy, approval_policy: Some(approval_policy),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: test.session_configured.model.clone(), model: test.session_configured.model.clone(),
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
Ok(()) Ok(())
+16 -11
View File
@@ -74,8 +74,7 @@ async fn user_turn_includes_skill_instructions() -> Result<()> {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, test.config.cwd.as_path()); turn_permission_fields(PermissionProfile::Disabled, test.config.cwd.as_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![ items: vec![
UserInput::Text { UserInput::Text {
text: "please use $demo".to_string(), text: "please use $demo".to_string(),
@@ -86,18 +85,24 @@ async fn user_turn_includes_skill_instructions() -> Result<()> {
path: skill_path.clone(), path: skill_path.clone(),
}, },
], ],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.config.cwd.to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.config.cwd.to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+16 -11
View File
@@ -405,24 +405,29 @@ async fn mcp_call_marks_thread_memory_mode_polluted_when_configured() -> Result<
turn_permission_fields(PermissionProfile::read_only(), cwd.as_path()); turn_permission_fields(PermissionProfile::read_only(), cwd.as_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "call the rmcp echo tool".to_string(), text: "call the rmcp echo tool".to_string(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: test.session_configured.model.clone(), model: test.session_configured.model.clone(),
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
wait_for_event(&test.codex, |event| { wait_for_event(&test.codex, |event| {
+80 -55
View File
@@ -102,24 +102,29 @@ async fn shell_command_tool_executes_command_and_streams_output() -> anyhow::Res
turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "please run the shell command".into(), text: "please run the shell command".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd_path, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd_path),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -178,24 +183,29 @@ async fn update_plan_tool_emits_plan_update_event() -> anyhow::Result<()> {
turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "please update the plan".into(), text: "please update the plan".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd_path, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd_path),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -264,24 +274,29 @@ async fn update_plan_tool_rejects_malformed_payload() -> anyhow::Result<()> {
turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "please update the plan".into(), text: "please update the plan".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd_path, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd_path),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -360,24 +375,29 @@ async fn apply_patch_tool_executes_and_emits_patch_events() -> anyhow::Result<()
turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "please apply a patch".into(), text: "please apply a patch".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd_path, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd_path),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -493,24 +513,29 @@ async fn apply_patch_reports_parse_diagnostics() -> anyhow::Result<()> {
turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path()); turn_permission_fields(PermissionProfile::Disabled, cwd_path.as_path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "please apply a patch".into(), text: "please apply a patch".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd_path, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd_path),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+32 -22
View File
@@ -37,24 +37,29 @@ async fn run_turn(test: &TestCodex, prompt: &str) -> anyhow::Result<()> {
turn_permission_fields(PermissionProfile::Disabled, test.cwd.path()); turn_permission_fields(PermissionProfile::Disabled, test.cwd.path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: prompt.into(), text: prompt.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.cwd.path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -358,24 +363,29 @@ async fn shell_tools_start_before_response_completed_when_stream_delayed() -> an
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, test.cwd.path()); turn_permission_fields(PermissionProfile::Disabled, test.cwd.path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "stream delayed completion".into(), text: "stream delayed completion".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.cwd.path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+16 -11
View File
@@ -515,24 +515,29 @@ async fn mcp_image_output_preserves_image_and_no_text_summary() -> Result<()> {
fixture fixture
.codex .codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "call the rmcp image tool".into(), text: "call the rmcp image tool".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: fixture.cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(fixture.cwd.path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile: Some(permission_profile), permission_profile: Some(permission_profile),
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+112 -78
View File
@@ -192,24 +192,29 @@ async fn submit_unified_exec_turn(
turn_permission_fields(permission_profile, test.config.cwd.as_path()); turn_permission_fields(permission_profile, test.config.cwd.as_path());
test.codex test.codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: prompt.into(), text: prompt.into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.config.cwd.to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.config.cwd.to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -278,24 +283,29 @@ async fn unified_exec_intercepts_apply_patch_exec_command() -> Result<()> {
turn_permission_fields(PermissionProfile::Disabled, &cwd); turn_permission_fields(PermissionProfile::Disabled, &cwd);
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "apply patch via unified exec".into(), text: "apply patch via unified exec".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -2120,24 +2130,29 @@ async fn unified_exec_keeps_long_running_session_after_turn_end() -> Result<()>
turn_permission_fields(PermissionProfile::Disabled, &turn_cwd); turn_permission_fields(PermissionProfile::Disabled, &turn_cwd);
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "keep unified exec process after turn end".into(), text: "keep unified exec process after turn end".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: turn_cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(turn_cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -2218,24 +2233,29 @@ async fn unified_exec_interrupt_preserves_long_running_session() -> Result<()> {
turn_permission_fields(PermissionProfile::Disabled, &turn_cwd); turn_permission_fields(PermissionProfile::Disabled, &turn_cwd);
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "interrupt long-running unified exec".into(), text: "interrupt long-running unified exec".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: turn_cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(turn_cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -2685,25 +2705,29 @@ async fn unified_exec_runs_under_sandbox() -> Result<()> {
turn_permission_fields(PermissionProfile::read_only(), &turn_cwd); turn_permission_fields(PermissionProfile::read_only(), &turn_cwd);
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "summarize large output".into(), text: "summarize large output".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: turn_cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(turn_cwd),
// Important! approval_policy: Some(AskForApproval::Never),
sandbox_policy, sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -2803,24 +2827,29 @@ async fn unified_exec_enforces_glob_deny_read_policy() -> Result<()> {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::read_only(), &turn_cwd); turn_permission_fields(PermissionProfile::read_only(), &turn_cwd);
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "read the fixture files".into(), text: "read the fixture files".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: turn_cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(turn_cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
@@ -2936,24 +2965,29 @@ async fn unified_exec_python_prompt_under_seatbelt() -> Result<()> {
turn_permission_fields(PermissionProfile::read_only(), &turn_cwd); turn_permission_fields(PermissionProfile::read_only(), &turn_cwd);
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "start python under seatbelt".into(), text: "start python under seatbelt".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: turn_cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(turn_cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_model, model: session_model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+16 -11
View File
@@ -174,24 +174,29 @@ async fn user_shell_command_does_not_replace_active_turn() -> anyhow::Result<()>
fixture fixture
.codex .codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "run model shell command".to_string(), text: "run model shell command".to_string(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd, responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: fixture.session_configured.model.clone(), model: fixture.session_configured.model.clone(),
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
+16 -11
View File
@@ -72,21 +72,26 @@ const VIEW_IMAGE_TURN_COMPLETE_TIMEOUT: Duration = Duration::from_secs(30);
fn disabled_user_turn(test: &TestCodex, items: Vec<UserInput>, model: String) -> Op { fn disabled_user_turn(test: &TestCodex, items: Vec<UserInput>, model: String) -> Op {
let (sandbox_policy, permission_profile) = let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, test.config.cwd.as_path()); turn_permission_fields(PermissionProfile::Disabled, test.config.cwd.as_path());
Op::UserTurn { Op::UserInput {
environments: None,
items, items,
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: test.config.cwd.to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(test.config.cwd.to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model, model,
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
} }
} }
+16 -11
View File
@@ -152,24 +152,29 @@ async fn websocket_fallback_hides_first_websocket_retry_stream_error() -> Result
turn_permission_fields(PermissionProfile::Disabled, cwd.path()); turn_permission_fields(PermissionProfile::Disabled, cwd.path());
codex codex
.submit(Op::UserTurn { .submit(Op::UserInput {
environments: None,
items: vec![UserInput::Text { items: vec![UserInput::Text {
text: "hello".into(), text: "hello".into(),
text_elements: Vec::new(), text_elements: Vec::new(),
}], }],
environments: None,
final_output_json_schema: None, final_output_json_schema: None,
cwd: cwd.path().to_path_buf(), responsesapi_client_metadata: None,
approval_policy: AskForApproval::Never, thread_settings: codex_protocol::protocol::ThreadSettingsOverrides {
approvals_reviewer: None, cwd: Some(cwd.path().to_path_buf()),
sandbox_policy, approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile, permission_profile,
collaboration_mode: Some(codex_protocol::config_types::CollaborationMode {
mode: codex_protocol::config_types::ModeKind::Default,
settings: codex_protocol::config_types::Settings {
model: session_configured.model.clone(), model: session_configured.model.clone(),
effort: None, reasoning_effort: None,
summary: None, developer_instructions: None,
service_tier: None, },
collaboration_mode: None, }),
personality: None, ..Default::default()
},
}) })
.await?; .await?;
-69
View File
@@ -518,74 +518,6 @@ pub enum Op {
thread_settings: ThreadSettingsOverrides, thread_settings: ThreadSettingsOverrides,
}, },
/// Similar to [`Op::UserInput`], but contains additional context required
/// for a turn of a [`crate::codex_thread::CodexThread`].
UserTurn {
/// User input items, see `InputItem`
items: Vec<UserInput>,
/// `cwd` to use with the [`SandboxPolicy`] and potentially tool calls
/// such as `local_shell`.
cwd: PathBuf,
/// Policy to use for command approval.
approval_policy: AskForApproval,
/// Reviewer to use for approval requests raised during this turn.
///
/// When omitted, the session keeps the current setting
approvals_reviewer: Option<ApprovalsReviewer>,
/// Policy to use for tool calls such as `local_shell`.
sandbox_policy: SandboxPolicy,
/// Full permissions profile to use for tool calls such as `local_shell`.
///
/// When omitted, `sandbox_policy` is used as a legacy compatibility
/// projection.
#[serde(default, skip_serializing_if = "Option::is_none")]
permission_profile: Option<PermissionProfile>,
/// Must be a valid model slug for the configured client session
/// associated with this conversation.
model: String,
/// Will only be honored if the model is configured to use reasoning.
#[serde(skip_serializing_if = "Option::is_none")]
effort: Option<ReasoningEffortConfig>,
/// Will only be honored if the model is configured to use reasoning.
///
/// When omitted, the session keeps the current setting (which allows core to
/// fall back to the selected model's default on new sessions).
#[serde(default, skip_serializing_if = "Option::is_none")]
summary: Option<ReasoningSummaryConfig>,
/// Optional service tier override for this turn.
///
/// Use `Some(Some(_))` to set a specific tier for this turn, `Some(None)` to
/// explicitly clear the tier for this turn, or `None` to keep the existing
/// session preference.
#[serde(default, skip_serializing_if = "Option::is_none")]
service_tier: Option<Option<String>>,
// The JSON schema to use for the final assistant message
final_output_json_schema: Option<Value>,
/// EXPERIMENTAL - set a pre-set collaboration mode.
/// Takes precedence over model, effort, and developer instructions if set.
#[serde(skip_serializing_if = "Option::is_none")]
collaboration_mode: Option<CollaborationMode>,
/// Optional personality override for this turn.
#[serde(skip_serializing_if = "Option::is_none")]
personality: Option<Personality>,
/// Optional turn-scoped environments.
#[serde(default, skip_serializing_if = "Option::is_none")]
environments: Option<Vec<TurnEnvironmentSelection>>,
},
/// Inter-agent communication that should be recorded as assistant history /// Inter-agent communication that should be recorded as assistant history
/// while still using the normal thread submission lifecycle. /// while still using the normal thread submission lifecycle.
InterAgentCommunication { InterAgentCommunication {
@@ -843,7 +775,6 @@ impl Op {
Self::RealtimeConversationClose => "realtime_conversation_close", Self::RealtimeConversationClose => "realtime_conversation_close",
Self::RealtimeConversationListVoices => "realtime_conversation_list_voices", Self::RealtimeConversationListVoices => "realtime_conversation_list_voices",
Self::UserInput { .. } => "user_input", Self::UserInput { .. } => "user_input",
Self::UserTurn { .. } => "user_turn",
Self::InterAgentCommunication { .. } => "inter_agent_communication", Self::InterAgentCommunication { .. } => "inter_agent_communication",
Self::OverrideTurnContext { .. } => "override_turn_context", Self::OverrideTurnContext { .. } => "override_turn_context",
Self::ExecApproval { .. } => "exec_approval", Self::ExecApproval { .. } => "exec_approval",