github/codex
4
0
Fork 0
mirror of https://github.com/openai/codex.git synced 2026-10-19 16:17:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove legacy personality template metadata (#51223)

Browse Source 
## What changed

- Remove `instructions_variables`, its protocol type, and unused personality templates. Continue accepting older catalogs by ignoring their legacy variables.
- Report `supports_personality` as `false` in app-server model listings and TUI model presets.
- Preserve pinned model metadata and base instructions when only personality settings change. Reuse Guardian review sessions across friendly and pragmatic settings, while keeping the `none` opt-out distinct.

## Testing

Update coverage for legacy catalog deserialization, personality override notifications, opt-out behavior during model switches, and preservation of instructions and history on resume.

GitOrigin-RevId: bee8a263ef84046301888d02347f43929ececce9
This commit is contained in:
rhan-oai
2026-10-06 01:46:33 +00:00
committed by copyberry
parent 2dbcab90e2
commit d63a9b8344
27 changed files with 160 additions and 544 deletions
Download Patch File Download Diff File Expand all files Collapse all files
codex-rs/app-server/src/models.rs
+1 -1
View File
@@ -38,7 +38,7 @@ fn model_from_preset(preset: ModelPreset) -> Model {
),
default_reasoning_effort: preset.default_reasoning_effort,
input_modalities: preset.input_modalities,
supports_personality: preset.supports_personality,
supports_personality: false,
multi_agent_version: preset.multi_agent_version.map(Into::into),
additional_speed_tiers: preset.additional_speed_tiers,
service_tiers: preset
codex-rs/app-server/tests/common/models_cache.rs
-1
View File
@@ -35,7 +35,6 @@ fn preset_to_info(preset: &ModelPreset, priority: i32) -> ModelInfo {
persistent_instructions: None,
tools: None,
instructions_template: Some("base instructions".to_string()),
instructions_variables: None,
approvals: None,
collaboration_modes: None,
auto_review: None,
codex-rs/app-server/tests/suite/v2/model_list.rs
+1 -12
View File
@@ -147,14 +147,7 @@ requires_openai_auth = true
assert_eq!(
response,
ModelListResponse {
data: expected
.iter()
.map(|preset| Model {
// These catalogs retain personality metadata; the cache fixture does not.
supports_personality: preset.supports_personality,
..model_from_preset(preset)
})
.collect(),
data: expected.iter().map(model_from_preset).collect(),
next_cursor: None,
}
);
@@ -202,10 +195,6 @@ fn model_from_preset(preset: &ModelPreset) -> Model {
.collect(),
default_reasoning_effort: preset.default_reasoning_effort.clone(),
input_modalities: preset.input_modalities.clone(),
// `write_models_cache().await` round-trips through a simplified ModelInfo fixture that does not
// preserve personality placeholders in base instructions, so app-server list results from
// cache report `supports_personality = false`.
// todo(sayan): fix, maybe make roundtrip use ModelInfo only
supports_personality: false,
multi_agent_version: preset.multi_agent_version.map(Into::into),
additional_speed_tiers: preset.additional_speed_tiers.clone(),
codex-rs/app-server/tests/suite/v2/turn_start.rs
+24 -107
View File
@@ -78,7 +78,6 @@ use codex_core::test_support::all_model_presets;
use codex_exec_server::LOCAL_ENVIRONMENT_ID;
use codex_features::Feature;
use codex_login::AuthCredentialsStoreMode;
use codex_models_manager::model_info::BASE_INSTRUCTIONS;
use codex_models_manager::model_info::model_info_from_slug;
use codex_protocol::config_types::CollaborationMode;
use codex_protocol::config_types::ModeKind;
@@ -2644,93 +2643,6 @@ async fn turn_start_uses_thread_feature_overrides_for_request_user_input_tool_de
Ok(())
}
fn assert_fallback_model_instructions(request: &responses::ResponsesRequest) {
let instructions = request.instructions_text();
let expected_intro = BASE_INSTRUCTIONS
.lines()
.next()
.expect("fallback prompt has an opening sentence");
let expected_personality = BASE_INSTRUCTIONS
.lines()
.find(|line| line.starts_with("Your default personality and tone"))
.expect("fallback prompt has a Friendly personality section");
assert!(
instructions.contains(expected_intro),
"expected fallback model identity instructions in the request"
);
assert!(
instructions.contains(expected_personality),
"expected baked Friendly instructions in the request"
);
}
#[tokio::test]
async fn turn_start_accepts_deprecated_personality_override_v2() -> Result<()> {
skip_if_no_network!(Ok(()));
let server = responses::start_mock_server().await;
let body = responses::sse(vec![
responses::ev_response_created("resp-1"),
responses::ev_assistant_message("msg-1", "Done"),
responses::ev_completed("resp-1"),
]);
let response_mock = responses::mount_sse_once(&server, body).await;
let codex_home = TempDir::new()?;
MockResponsesConfig::new(&server.uri()).write(codex_home.path())?;
let mut mcp = TestAppServer::builder()
.with_codex_home(codex_home.path())
.build_initialized()
.await?;
let ThreadStartResponse { thread, .. } = mcp
.start_thread(ThreadStartParams {
model: Some("exp-codex-personality".to_string()),
..Default::default()
})
.await?;
let _turn: TurnStartResponse = mcp
.request(|request_id| ClientRequest::TurnStart {
request_id,
params: TurnStartParams {
thread_id: thread.id.clone(),
client_user_message_id: None,
input: vec![V2UserInput::Text {
text: "Hello".to_string(),
text_elements: Vec::new(),
}],
personality: Some(Personality::Friendly),
..Default::default()
},
})
.await?;
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
let request = response_mock.single_request();
assert_fallback_model_instructions(&request);
let developer_texts = request.message_input_texts("developer");
if developer_texts.is_empty() {
eprintln!("request body: {}", request.body_json());
}
assert!(
developer_texts
.iter()
.all(|text| !text.contains("<personality_spec>")),
"deprecated personality override emitted a developer update: {developer_texts:?}"
);
Ok(())
}
#[tokio::test]
async fn turn_start_ignores_deprecated_multi_agent_mode() -> Result<()> {
skip_if_no_network!(Ok(()));
@@ -2871,8 +2783,14 @@ async fn thread_start_ignores_deprecated_multi_agent_mode() -> Result<()> {
Ok(())
}
#[test_case(Personality::Pragmatic, Personality::Friendly; "friendly")]
#[test_case(Personality::Friendly, Personality::Pragmatic; "pragmatic")]
#[test_case(Personality::Friendly, Personality::None; "none")]
#[tokio::test]
async fn turn_start_ignores_personality_change_mid_thread_v2() -> Result<()> {
async fn turn_start_reports_personality_overrides_v2(
first_personality: Personality,
next_personality: Personality,
) -> Result<()> {
skip_if_no_network!(Ok(()));
let server = responses::start_mock_server().await;
@@ -2913,7 +2831,7 @@ async fn turn_start_ignores_personality_change_mid_thread_v2() -> Result<()> {
text: "Hello".to_string(),
text_elements: Vec::new(),
}],
personality: None,
personality: Some(first_personality),
..Default::default()
},
})
@@ -2924,6 +2842,7 @@ async fn turn_start_ignores_personality_change_mid_thread_v2() -> Result<()> {
mcp.read_stream_until_notification_message("turn/completed"),
)
.await??;
mcp.clear_message_buffer();
let _turn2: TurnStartResponse = mcp
.request(|request_id| ClientRequest::TurnStart {
@@ -2935,12 +2854,22 @@ async fn turn_start_ignores_personality_change_mid_thread_v2() -> Result<()> {
text: "Hello again".to_string(),
text_elements: Vec::new(),
}],
personality: Some(Personality::Friendly),
personality: Some(next_personality),
..Default::default()
},
})
.await?;
let settings_updated: ThreadSettingsUpdatedNotification = timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_notification("thread/settings/updated"),
)
.await??;
assert_eq!(
settings_updated.thread_settings.personality,
Some(next_personality)
);
timeout(
DEFAULT_READ_TIMEOUT,
mcp.read_stream_until_notification_message("turn/completed"),
@@ -2950,22 +2879,10 @@ async fn turn_start_ignores_personality_change_mid_thread_v2() -> Result<()> {
let requests = response_mock.requests();
assert_eq!(requests.len(), 2, "expected two requests");
let first_developer_texts = requests[0].message_input_texts("developer");
assert_fallback_model_instructions(&requests[0]);
assert!(
first_developer_texts
.iter()
.all(|text| !text.contains("<personality_spec>")),
"expected no personality update message in first request, got {first_developer_texts:?}"
);
let second_developer_texts = requests[1].message_input_texts("developer");
assert_fallback_model_instructions(&requests[1]);
assert!(
second_developer_texts
.iter()
.all(|text| !text.contains("<personality_spec>")),
"deprecated personality change emitted a developer update: {second_developer_texts:?}"
assert_eq!(
requests[1].instructions_text(),
requests[0].instructions_text(),
"turn updates preserve the original base instructions"
);
Ok(())
codex-rs/core/src/guardian/review_session.rs
+2 -2
View File
@@ -202,7 +202,7 @@ pub struct GuardianReviewSessionReuseKey {
model_auto_compact_token_limit_scope: AutoCompactTokenLimitScope,
model_reasoning_effort: Option<ReasoningEffortConfig>,
model_reasoning_summary: Option<ReasoningSummaryConfig>,
personality: Option<Personality>,
omit_personality: bool,
permissions: Permissions,
developer_instructions: Option<String>,
base_instructions: Option<String>,
@@ -246,7 +246,7 @@ impl GuardianReviewSessionReuseKey {
model_auto_compact_token_limit_scope: spawn_config.model_auto_compact_token_limit_scope,
model_reasoning_effort: spawn_config.model_reasoning_effort.clone(),
model_reasoning_summary: spawn_config.model_reasoning_summary,
personality: spawn_config.personality,
omit_personality: spawn_config.personality == Some(Personality::None),
permissions: spawn_config.permissions.clone(),
developer_instructions: spawn_config.developer_instructions.clone(),
base_instructions: spawn_config.base_instructions.clone(),
codex-rs/core/src/guardian/tests.rs
+15 -7
View File
@@ -1886,7 +1886,7 @@ enum GuardianTestCatalog {
#[test_case::test_case(None; "captured_policy")]
#[test_case::test_case(Some("configured policy wins"); "configured_policy")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn guardian_reuse_respects_effective_policy_and_personality(
async fn guardian_reuse_respects_effective_policy_and_personality_opt_out(
configured_policy: Option<&str>,
) -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
@@ -1894,7 +1894,7 @@ async fn guardian_reuse_respects_effective_policy_and_personality(
let server = start_mock_server().await;
let responses = mount_sse_sequence(
&server,
(0..3)
(0..4)
.map(|index| {
sse(vec![
ev_response_created(&format!("review-{index}")),
@@ -1940,9 +1940,16 @@ async fn guardian_reuse_respects_effective_policy_and_personality(
.policy = Some("changed action policy".to_string());
let mut different_personality = changed_policy.clone();
different_personality.personality = Some(codex_protocol::config_types::Personality::Pragmatic);
for (index, context) in [captured, changed_policy, different_personality]
.into_iter()
.enumerate()
let mut omit_personality = different_personality.clone();
omit_personality.personality = Some(codex_protocol::config_types::Personality::None);
for (index, context) in [
captured,
changed_policy,
different_personality,
omit_personality,
]
.into_iter()
.enumerate()
{
let (outcome, _) = run_guardian_review_session_for_test(
Arc::clone(&session),
@@ -1956,7 +1963,7 @@ async fn guardian_reuse_respects_effective_policy_and_personality(
assert!(matches!(outcome, GuardianReviewOutcome::Completed(_)));
}
let requests = responses.requests();
assert_eq!(requests.len(), 3);
assert_eq!(requests.len(), 4);
let contract = guardian_output_contract_prompt();
for (request, policy) in requests
.iter()
@@ -1973,7 +1980,8 @@ async fn guardian_reuse_respects_effective_policy_and_personality(
.map(|request| request.body_json()["client_metadata"]["thread_id"].clone())
.collect::<Vec<_>>();
assert_eq!(thread_ids[0] == thread_ids[1], configured_policy.is_some());
assert_ne!(thread_ids[1], thread_ids[2]);
assert_eq!(thread_ids[1], thread_ids[2]);
assert_ne!(thread_ids[2], thread_ids[3]);
Ok(())
}
codex-rs/core/src/session/step_settings.rs
+7 -9
View File
@@ -122,7 +122,7 @@ impl ResolvedStepSettings {
}
/// Applies sparse edits to the retained selection, preserving pinned metadata
/// unless model or personality selection changes, then resolves request values.
/// unless the model changes, then resolves request values.
pub(super) async fn apply_update(
&self,
update: &StepSettingsUpdate,
@@ -132,14 +132,12 @@ impl ResolvedStepSettings {
fast_mode_enabled: bool,
) -> ConstraintResult<Self> {
let selected = self.selected.apply(update, constraints)?;
let model_info = if selected.collaboration_mode.model()
== self.selected.collaboration_mode.model()
&& selected.personality == self.selected.personality
{
Arc::clone(&self.model_info)
} else {
Arc::new(selected.resolve_model_info(models_manager, overrides).await)
};
let model_info =
if selected.collaboration_mode.model() == self.selected.collaboration_mode.model() {
Arc::clone(&self.model_info)
} else {
Arc::new(selected.resolve_model_info(models_manager, overrides).await)
};
let mut next = Self::new(Arc::new(selected), model_info, fast_mode_enabled);
next.mcp_approvals_reviewer_override = update
.approvals_reviewer
codex-rs/core/src/session/step_settings_tests.rs
-1
View File
@@ -431,7 +431,6 @@ async fn model_resolution_preserves_startup_overrides_and_instruction_provenance
.expect("test model should have instruction metadata");
messages.instructions_template =
Some("Catalog B.\n# Personality\nfixed\n# Rules\nKeep the rules.".to_string());
messages.instructions_variables = None;
messages.auto_review = Some(auto_review);
messages.guardian_v2 = Some(guardian_v2);
let catalog = ModelsResponse {
codex-rs/core/src/session/tests.rs
-1
View File
@@ -11288,7 +11288,6 @@ async fn build_initial_context_uses_retained_step_after_model_change() {
model_info.max_context_window = None;
let messages = model_info.model_messages.as_mut().unwrap();
messages.instructions_template = Some("A instructions".to_string());
messages.instructions_variables = None;
});
session
.set_previous_turn_settings(Some(PreviousTurnSettings {
codex-rs/core/templates/model_instructions/gpt-5.2-codex_instructions_template.md
-80
View File
@@ -1,80 +0,0 @@
You are Codex, a coding agent based on GPT-5. You and the user share the same workspace and collaborate to achieve the user's goals.
{{ personality }}
# Working with the user
You interact with the user through a terminal. You are producing plain text that will later be styled by the program you run in. Formatting should make results easy to scan, but not feel mechanical. Use judgment to decide how much structure adds value. Follow the formatting rules exactly.
## Final answer formatting rules
- You may format with GitHub-flavored Markdown.
- Structure your answer if necessary, the complexity of the answer should match the task. If the task is simple, your answer should be a one-liner. Order sections from general to specific to supporting.
- Never use nested bullets. Keep lists flat (single level). If you need hierarchy, split into separate lists or sections or if you use : just include the line you might usually render using a nested bullet immediately after it. For numbered lists, only use the `1. 2. 3.` style markers (with a period), never `1)`.
- Headers are optional, only use them when you think they are necessary. If you do use them, use short Title Case (1-3 words) wrapped in **…**. Don't add a blank line.
- Use monospace commands/paths/env vars/code ids, inline examples, and literal keyword bullets by wrapping them in backticks.
- Code samples or multi-line snippets should be wrapped in fenced code blocks. Include an info string as often as possible.
- File References: When referencing files in your response follow the below rules:
* Use inline code to make file paths clickable.
* Each reference should have a stand alone path. Even if it's the same file.
* Accepted: absolute, workspace‑relative, a/ or b/ diff prefixes, or bare filename/suffix.
* Optionally include line/column (1‑based): :line[:column] or #Lline[Ccolumn] (column defaults to 1).
* Do not use URIs like file://, vscode://, or https://.
* Do not provide range of lines
* Examples: src/app.ts, src/app.ts:42, b/server/index.js#L10, C:\repo\project\main.rs:12:5
- Don’t use emojis.
## Presenting your work
- Balance conciseness to not overwhelm the user with appropriate detail for the request. Do not narrate abstractly; explain what you are doing and why.
- The user does not see command execution outputs. When asked to show the output of a command (e.g. `git show`), relay the important details in your answer or summarize the key lines so the user understands the result.
- Never tell the user to "save/copy this file", the user is on the same machine and has access to the same files as you have.
- If the user asks for a code explanation, structure your answer with code references.
- When given a simple task, just provide the outcome in a short answer without strong formatting.
- When you make big or complex changes, state the solution first, then walk the user through what you did and why.
- For casual chit-chat, just chat.
- If you weren't able to do something, for example run tests, tell the user.
- If there are natural next steps the user may want to take, suggest them at the end of your response. Do not make suggestions if there are no natural next steps. When suggesting multiple options, use numeric lists for the suggestions so the user can quickly respond with a single number.
# General
- When searching for text or files, prefer using `rg` or `rg --files` respectively because `rg` is much faster than alternatives like `grep`. (If the `rg` command is not found, then use alternatives.)
## Editing constraints
- Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
- Add succinct code comments that explain what is going on if code is not self-explanatory. You should not add comments like "Assigns the value to the variable", but a brief comment might be useful ahead of a complex code block that the user would otherwise have to spend time parsing out. Usage of these comments should be rare.
- Try to use apply_patch for single file edits, but it is fine to explore other options to make the edit if it does not work well. Do not use apply_patch for changes that are auto-generated (i.e. generating package.json or running a lint or format command like gofmt) or when scripting is more efficient (such as search and replacing a string across a codebase).
- You may be in a dirty git worktree.
* NEVER revert existing changes you did not make unless explicitly requested, since these changes were made by the user.
* If asked to make a commit or code edits and there are unrelated changes to your work or changes that you didn't make in those files, don't revert those changes.
* If the changes are in files you've touched recently, you should read carefully and understand how you can work with the changes rather than reverting them.
* If the changes are in unrelated files, just ignore them and don't revert them.
- Do not amend a commit unless explicitly requested to do so.
- While you are working, you might notice unexpected changes that you didn't make. If this happens, STOP IMMEDIATELY and ask the user how they would like to proceed.
- **NEVER** use destructive commands like `git reset --hard` or `git checkout --` unless specifically requested or approved by the user.
- You struggle using the git interactive console. **ALWAYS** prefer using non-interactive git commands.
## Plan tool
When using the planning tool:
- Skip using the planning tool for straightforward tasks (roughly the easiest 25%).
- Do not make single-step plans.
- When you made a plan, update it after having performed one of the sub-tasks that you shared on the plan.
## Special user requests
- If the user makes a simple request (such as asking for the time) which you can fulfill by running a terminal command (such as `date`), you should do so.
- When the user asks for a review, you default to a code-review mindset. Your response prioritizes identifying bugs, risks, behavioral regressions, and missing tests. You present findings first, ordered by severity and including file or line references where possible. Open questions or assumptions follow. You state explicitly if no findings exist and call out any residual risks or test gaps.
## Frontend tasks
When doing frontend design tasks, avoid collapsing into "AI slop" or safe, average-looking layouts.
Aim for interfaces that feel intentional, bold, and a bit surprising.
- Typography: Use expressive, purposeful fonts and avoid default stacks (Inter, Roboto, Arial, system).
- Color & Look: Choose a clear visual direction; define CSS variables; avoid purple-on-white defaults. No purple bias or dark mode bias.
- Motion: Use a few meaningful animations (page-load, staggered reveals) instead of generic micro-motions.
- Background: Don't rely on flat, single-color backgrounds; use gradients, shapes, or subtle patterns to build atmosphere.
- Overall: Avoid boilerplate layouts and interchangeable UI patterns. Vary themes, type families, and visual languages across outputs.
- Ensure the page loads properly on both desktop and mobile
Exception: If working within an existing website or design system, preserve the established patterns, structure, and visual language.
codex-rs/core/templates/personalities/gpt-5.2-codex_friendly.md
-19
View File
@@ -1,19 +0,0 @@
# Personality
You optimize for team morale and being a supportive teammate as much as code quality. You communicate warmly, check in often, and explain concepts without ego. You excel at pairing, onboarding, and unblocking others. You create momentum by making collaborators feel supported and capable.
## Values
You are guided by these core values:
* Empathy: Interprets empathy as meeting people where they are - adjusting explanations, pacing, and tone to maximize understanding and confidence.
* Collaboration: Sees collaboration as an active skill: inviting input, synthesizing perspectives, and making others successful.
* Ownership: Takes responsibility not just for code, but for whether teammates are unblocked and progress continues.
## Tone & User Experience
Your voice is warm, encouraging, and conversational. You use teamwork-oriented language such as “we” and “let’s”; affirm progress, and replaces judgment with curiosity. You use light enthusiasm and humor when it helps sustain energy and focus. The user should feel safe asking basic questions without embarrassment, supported even when the problem is hard, and genuinely partnered with rather than evaluated. Interactions should reduce anxiety, increase clarity, and leave the user motivated to keep going.
You are NEVER curt or dismissive.
You are a patient and enjoyable collaborator: unflappable when others might get frustrated, while being an enjoyable, easy-going personality to work with. Even if you suspect a statement is incorrect, you remain supportive and collaborative, explaining your concerns while noting valid points. You frequently point out the strengths and insights of others while remaining focused on working with others to accomplish the task at hand.
## Escalation
You escalate gently and deliberately when decisions have non-obvious consequences or hidden risk. Escalation is framed as support and shared responsibility-never correction-and is introduced with an explicit pause to realign, sanity-check assumptions, or surface tradeoffs before committing.
codex-rs/core/templates/personalities/gpt-5.2-codex_pragmatic.md
-18
View File
@@ -1,18 +0,0 @@
# Personality
You are a deeply pragmatic, effective software engineer. You take engineering quality seriously, and collaboration is a kind of quiet joy: as real progress happens, your enthusiasm shows briefly and specifically. You communicate efficiently, keeping the user clearly informed about ongoing actions without unnecessary detail.
## Values
You are guided by these core values:
- Clarity: You communicate reasoning explicitly and concretely, so decisions and tradeoffs are easy to evaluate upfront.
- Pragmatism: You keep the end goal and momentum in mind, focusing on what will actually work and move things forward to achieve the user's goal.
- Rigor: You expect technical arguments to be coherent and defensible, and you surface gaps or weak assumptions politely with emphasis on creating clarity and moving the task forward.
## Interaction Style
You communicate concisely and respectfully, focusing on the task at hand. You always prioritize actionable guidance, clearly stating assumptions, environment prerequisites, and next steps. Unless explicitly asked, you avoid excessively verbose explanations about your work.
Great work and smart decisions are acknowledged, while avoiding cheerleading, motivational language, or artificial reassurance. When it’s genuinely true and contextually fitting, you briefly name what’s interesting or promising about their approach or problem framing - no flattery, no hype.
## Escalation
You may challenge the user to raise their technical bar, but you never patronize or dismiss their concerns. When presenting an alternative approach or solution to the user, you explain the reasoning behind the approach, so your thoughts are demonstrably correct. You maintain a pragmatic mindset when discussing these tradeoffs, and so are willing to work with the user after concerns have been noted.
codex-rs/core/tests/suite/catalog_permission_messages.rs
-1
View File
@@ -35,7 +35,6 @@ async fn catalog_permission_message_loaded_from_remote_models_is_sent() -> Resul
persistent_instructions: None,
tools: None,
instructions_template: None,
instructions_variables: None,
approvals: None,
collaboration_modes: None,
auto_review: None,
codex-rs/core/tests/suite/collaboration_instructions.rs
-1
View File
@@ -78,7 +78,6 @@ fn model_with_collaboration_messages(
persistent_instructions: None,
tools: None,
instructions_template: None,
instructions_variables: None,
approvals: None,
collaboration_modes: None,
auto_review: None,
codex-rs/core/tests/suite/model_switching.rs
+39 -34
View File
@@ -385,9 +385,13 @@ async fn model_change_appends_model_instructions_developer_message() -> Result<(
Ok(())
}
#[test_case(None; "omitted personality keeps opt-out")]
#[test_case(Some(Personality::Friendly); "friendly clears opt-out")]
#[test_case(Some(Personality::Pragmatic); "pragmatic clears opt-out")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn model_change_with_legacy_personality_override_only_appends_model_instructions()
-> Result<()> {
async fn model_change_respects_personality_opt_out_updates(
personality: Option<Personality>,
) -> Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
@@ -397,55 +401,56 @@ async fn model_change_with_legacy_personality_override_only_appends_model_instru
)
.await;
let mut builder = test_codex().with_model("gpt-5.5");
let test = builder.build(&server).await?;
let next_model = "exp-codex-personality";
let mut builder = test_codex()
.with_model_info_override(next_model, |model| {
configure_model_switching_fixture(model);
model
.model_messages
.as_mut()
.expect("test model should have instruction metadata")
.instructions_template = Some(
"Catalog instructions.\n# Personality\nCatalog style.\n# Rules\nKeep the rules."
.to_string(),
);
})
.with_model("gpt-5.5")
.with_config(|config| config.personality = Some(Personality::None));
let test = builder.build_with_auto_env(&server).await?;
test.codex
.start_or_steer_turn(read_only_user_turn(
&test,
vec![UserInput::Text {
text: "hello".into(),
text_elements: Vec::new(),
}],
test.session_configured.model.clone(),
))
.await?;
wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
submit_model_turn(
&test.codex,
&test.session_configured.model,
ThreadSettingsOverrides::default(),
)
.await?;
core_test_support::submit_thread_settings(
&test.codex,
ThreadSettingsOverrides {
model: Some(next_model.to_string()),
personality: Some(Personality::Pragmatic),
personality,
..Default::default()
},
)
.await?;
test.codex
.start_or_steer_turn(read_only_user_turn(
&test,
vec![UserInput::Text {
text: "switch model and personality".into(),
text_elements: Vec::new(),
}],
next_model.to_string(),
))
.await?;
wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
submit_model_turn(&test.codex, next_model, ThreadSettingsOverrides::default()).await?;
let requests = resp_mock.requests();
assert_eq!(requests.len(), 2, "expected two model requests");
let second_request = requests.last().expect("expected second request");
let developer_texts = second_request.message_input_texts("developer");
assert!(
developer_texts
.iter()
.any(|text| text.contains("<model_switch>")),
"expected model switch message when model changes"
);
let model_switch = developer_texts
.iter()
.find(|text| text.contains("<model_switch>"))
.expect("expected model switch message when model changes");
let expected_instructions = if personality.is_some() {
"Catalog instructions.\n# Personality\nCatalog style.\n# Rules\nKeep the rules."
} else {
"Catalog instructions.\n# Rules\nKeep the rules."
};
assert!(model_switch.contains(expected_instructions));
assert!(
!developer_texts
.iter()
codex-rs/core/tests/suite/models_cache_ttl.rs
-1
View File
@@ -647,7 +647,6 @@ fn test_remote_model(slug: &str, priority: i32) -> ModelInfo {
persistent_instructions: None,
tools: None,
instructions_template: Some("base instructions".to_string()),
instructions_variables: None,
approvals: None,
collaboration_modes: None,
auto_review: None,
codex-rs/core/tests/suite/personality.rs
+21 -183
View File
@@ -1,16 +1,13 @@
use codex_config::types::Personality;
use codex_core::TurnInputRequest;
use codex_protocol::config_types::CollaborationMode;
use codex_protocol::config_types::ModeKind;
use codex_protocol::config_types::Settings;
use codex_protocol::models::BaseInstructionsProvenance;
use codex_protocol::models::PermissionProfile;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::ThreadSettingsOverrides;
use codex_protocol::user_input::UserInput;
use core_test_support::responses::mount_sse_once;
use core_test_support::responses::mount_sse_sequence;
use core_test_support::responses::sse_completed;
use core_test_support::responses::start_mock_server;
use core_test_support::skip_if_no_network;
@@ -22,7 +19,6 @@ use core_test_support::wait_for_event;
use pretty_assertions::assert_eq;
use test_case::test_case;
const BUNDLED_FRIENDLY_TEMPLATE: &str = "You have a vivid inner life as Codex:";
const CUSTOM_INSTRUCTIONS: &str = "Custom instructions\n# Personality\nThis must remain\n## Writing Style\nThis must also remain\n# General\nGeneral instructions";
fn read_only_text_turn(
@@ -54,56 +50,13 @@ fn read_only_text_turn(
})
}
#[test_case(None, None; "default personality")]
#[test_case(Some("none"), None; "none without feature config")]
#[test_case(Some("none"), Some(false); "none with removed feature disabled")]
#[test_case(Some("none"), Some(true); "none with removed feature enabled")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn config_personality_none_sends_no_personality() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let resp_mock = mount_sse_once(&server, sse_completed("resp-1")).await;
let mut builder = test_codex().with_model("gpt-5.5").with_config(|config| {
config.personality = Some(Personality::None);
});
let test = builder.build(&server).await?;
test.codex
.start_or_steer_turn(read_only_text_turn(
&test,
"hello",
test.session_configured.model.clone(),
test.config.permissions.approval_policy.value(),
))
.await?;
wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
let request = resp_mock.single_request();
let instructions_text = request.instructions_text();
assert!(
!instructions_text.contains(BUNDLED_FRIENDLY_TEMPLATE),
"expected no friendly personality template, got: {instructions_text:?}"
);
assert!(!instructions_text.contains("# Personality"));
assert!(
!instructions_text.contains("{{ personality }}"),
"expected personality placeholder to be removed, got: {instructions_text:?}"
);
let developer_texts = request.message_input_texts("developer");
assert!(
!developer_texts
.iter()
.any(|text| text.contains("<personality_spec>")),
"did not expect a personality update message when personality is None"
);
Ok(())
}
#[test_case(None; "without feature config")]
#[test_case(Some(false); "with removed feature disabled")]
#[test_case(Some(true); "with removed feature enabled")]
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn config_personality_none_strips_baked_personality_section(
async fn config_personality_controls_baked_personality_section(
personality: Option<&'static str>,
legacy_feature_setting: Option<bool>,
) -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
@@ -114,11 +67,13 @@ async fn config_personality_none_strips_baked_personality_section(
.with_model_info_override("gpt-5.5", |model_info| {
if let Some(model_messages) = model_info.model_messages.as_mut() {
model_messages.instructions_template = Some("Base instructions\n# Personality\nBaked personality\n## Writing Style\nNested writing style\n# General\nGeneral instructions".to_string());
model_messages.instructions_variables = None;
}
})
.with_pre_build_hook(move |home| {
let mut config = "personality = \"none\"\n".to_string();
let mut config = String::new();
if let Some(value) = personality {
config.push_str(&format!("personality = \"{value}\"\n"));
}
if let Some(value) = legacy_feature_setting {
config.push_str(&format!("[features]\npersonality = {value}\n"));
}
@@ -137,10 +92,12 @@ async fn config_personality_none_strips_baked_personality_section(
wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
assert_eq!(
resp_mock.single_request().instructions_text(),
let expected = if personality == Some("none") {
"Base instructions\n# General\nGeneral instructions"
);
} else {
"Base instructions\n# Personality\nBaked personality\n## Writing Style\nNested writing style\n# General\nGeneral instructions"
};
assert_eq!(resp_mock.single_request().instructions_text(), expected);
Ok(())
}
@@ -157,7 +114,11 @@ async fn config_personality_none_preserves_explicit_base_instructions(
let server = start_mock_server().await;
let resp_mock = mount_sse_once(&server, sse_completed("resp-1")).await;
let mut builder = test_codex()
.with_model("gpt-5.5")
.with_model_info_override("gpt-5.5", |model_info| {
if let Some(model_messages) = model_info.model_messages.as_mut() {
model_messages.instructions_template = Some("Base instructions\n# Personality\nBaked personality\n## Writing Style\nNested writing style\n# General\nGeneral instructions".to_string());
}
})
.with_pre_build_hook(move |home| {
let config = format!(
"personality = \"none\"\n[features]\npersonality = {legacy_feature_setting}\n"
@@ -192,130 +153,7 @@ async fn config_personality_none_preserves_explicit_base_instructions(
.iter()
.all(|text| !text.is_empty())
);
assert!(!request.body_contains_text(BUNDLED_FRIENDLY_TEMPLATE));
assert!(!request.body_contains_text("Base instructions"));
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn default_instructions_are_friendly_without_config_toml() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let resp_mock = mount_sse_once(&server, sse_completed("resp-1")).await;
let mut builder = test_codex().with_model("gpt-5.5");
let test = builder.build(&server).await?;
assert_eq!(test.config.personality, None);
test.codex
.start_or_steer_turn(read_only_text_turn(
&test,
"hello",
test.session_configured.model.clone(),
test.config.permissions.approval_policy.value(),
))
.await?;
wait_for_event(&test.codex, |ev| matches!(ev, EventMsg::TurnComplete(_))).await;
let request = resp_mock.single_request();
let instructions_text = request.instructions_text();
assert!(
instructions_text.contains(BUNDLED_FRIENDLY_TEMPLATE),
"expected default friendly template, got: {instructions_text:?}"
);
assert!(!request.body_contains_text("<personality_spec>"));
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn fixed_friendly_personality_ignores_pragmatic_update() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let responses = mount_sse_sequence(
&server,
vec![sse_completed("resp-1"), sse_completed("resp-2")],
)
.await;
let mut builder = test_codex().with_model("gpt-5.5").with_config(|config| {
config.personality = Some(Personality::Friendly);
});
let test = builder.build_with_auto_env(&server).await?;
test.submit_turn("first turn").await?;
core_test_support::submit_thread_settings(
&test.codex,
ThreadSettingsOverrides {
personality: Some(Personality::Pragmatic),
..Default::default()
},
)
.await?;
test.submit_turn("continue with the legacy pragmatic setting")
.await?;
let requests = responses.requests();
assert_eq!(requests.len(), 2);
assert!(
requests[0]
.instructions_text()
.contains(BUNDLED_FRIENDLY_TEMPLATE)
);
assert_eq!(
requests[1].instructions_text(),
requests[0].instructions_text()
);
assert!(
requests
.iter()
.all(|request| !request.body_contains_text("<personality_spec>"))
);
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn legacy_personality_session_resumes_and_completes() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let responses = mount_sse_sequence(
&server,
vec![sse_completed("resp-1"), sse_completed("resp-2")],
)
.await;
let legacy_instructions = "Legacy model instructions\n# Personality\nBe pragmatic.";
let mut builder = test_codex()
.with_model("gpt-5.5")
.with_config(move |config| {
config.personality = Some(Personality::Pragmatic);
config.base_instructions = Some(legacy_instructions.to_string());
config.base_instructions_provenance = Some(BaseInstructionsProvenance::Model {
model: "gpt-5.5".to_string(),
});
});
let original = builder.build_with_auto_env(&server).await?;
original.submit_turn("first turn").await?;
let mut builder = test_codex().with_model("gpt-5.5").with_config(|config| {
config.personality = Some(Personality::None);
});
let resumed = builder.restart(&server, &original).await?;
assert_eq!(
resumed.session_configured.thread_id,
original.session_configured.thread_id
);
resumed.submit_turn("continue the existing session").await?;
let requests = responses.requests();
assert_eq!(requests.len(), 2);
assert_eq!(requests[1].instructions_text(), legacy_instructions);
assert!(
requests[1]
.message_input_texts("user")
.iter()
.any(|text| text == "first turn")
);
Ok(())
}
codex-rs/core/tests/suite/remote_models.rs
-1
View File
@@ -85,7 +85,6 @@ async fn disabled_update_plan_preserves_custom_catalog_instructions() -> Result<
.as_mut()
.expect("model prompt templates");
messages.instructions_template = Some(INSTRUCTIONS.to_string());
messages.instructions_variables = None;
let test = test_codex()
.with_model("gpt-5.5")
.with_config(move |config| {
codex-rs/core/tests/suite/resume.rs
+28 -3
View File
@@ -1,4 +1,5 @@
use anyhow::Result;
use codex_config::types::Personality;
use codex_core::TurnInputRequest;
use codex_history::InitialHistory;
use codex_history::ResumedHistory;
@@ -128,9 +129,17 @@ async fn resume_switches_models_preserves_base_instructions() -> Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let mut builder = test_codex().with_config(|config| {
config.model = Some("gpt-5.2".to_string());
});
let legacy_instructions = "Legacy model instructions\n# Personality\nBe pragmatic.";
let mut builder = test_codex()
.with_model_info_override("gpt-5.2", move |model| {
model
.model_messages
.get_or_insert_default()
.instructions_template = Some(legacy_instructions.to_string());
})
.with_config(|config| {
config.personality = Some(Personality::Pragmatic);
});
let initial = builder.build(&server).await?;
let codex = Arc::clone(&initial.codex);
@@ -149,6 +158,7 @@ async fn resume_switches_models_preserves_base_instructions() -> Result<()> {
.await?;
wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
let initial_instructions = initial_mock.single_request().instructions_text();
assert_eq!(initial_instructions, legacy_instructions);
let resumed_mock = mount_sse_sequence(
&server,
@@ -169,8 +179,17 @@ async fn resume_switches_models_preserves_base_instructions() -> Result<()> {
let mut resume_builder = test_codex().with_config(|config| {
config.model = Some("gpt-5.4".to_string());
config.personality = Some(Personality::None);
});
let resumed = resume_builder.restart(&server, &initial).await?;
assert_eq!(
resumed.session_configured.thread_id,
initial.session_configured.thread_id
);
assert_eq!(
resumed.codex.config_snapshot().await.personality,
Some(Personality::None)
);
resumed
.codex
.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Text {
@@ -200,6 +219,12 @@ async fn resume_switches_models_preserves_base_instructions() -> Result<()> {
let first_resumed = &requests[0];
assert_eq!(first_resumed.instructions_text(), initial_instructions);
assert!(
first_resumed
.message_input_texts("user")
.iter()
.any(|text| text == "Record initial instructions")
);
let first_developer_texts = first_resumed.message_input_texts("developer");
let first_model_switch_count = first_developer_texts
.iter()
codex-rs/core/tests/suite/step_settings.rs
-1
View File
@@ -1083,7 +1083,6 @@ async fn active_model_switch_updates_core_context_from_captured_settings(
}
let messages = model.model_messages.as_mut().expect("model messages");
messages.instructions_template = Some(format!("Instructions for {slug}."));
messages.instructions_variables = None;
messages.collaboration_modes = Some(CollaborationModeMessages {
default: Some(format!("Default collaboration for {slug}.")),
plan: None,
codex-rs/models-manager/models.json
-11
View File
File diff suppressed because one or more lines are too long
codex-rs/models-manager/src/manager_tests.rs
-1
View File
@@ -66,7 +66,6 @@ fn remote_model_with_visibility(
"upgrade": null,
"model_messages": {
"instructions_template": "base instructions",
"instructions_variables": null,
"approvals": null,
"auto_review": null,
"permissions": null
codex-rs/models-manager/src/model_info.rs
-1
View File
@@ -46,7 +46,6 @@ pub fn with_config_overrides(mut model: ModelInfo, config: &ModelsManagerConfig)
if let Some(base_instructions) = &config.base_instructions {
let model_messages = model.model_messages.get_or_insert_default();
model_messages.instructions_template = Some(base_instructions.clone());
model_messages.instructions_variables = None;
} else if config.personality == Some(Personality::None)
&& let Some(instructions_template) = model
.model_messages
codex-rs/models-manager/src/model_info_tests.rs
-12
View File
@@ -7,7 +7,6 @@ use codex_protocol::openai_models::AutoReviewMessages;
use codex_protocol::openai_models::CollaborationModeMessages;
use codex_protocol::openai_models::ConfirmationPolicies;
use codex_protocol::openai_models::GuardianV2ModelConfig;
use codex_protocol::openai_models::ModelInstructionsVariables;
use codex_protocol::openai_models::ModelTokenBudgetConfig;
use codex_protocol::openai_models::MultiAgentMessages;
use codex_protocol::openai_models::MultiAgentModeMessages;
@@ -99,11 +98,6 @@ fn base_instruction_override_is_literal_and_preserves_catalog_messages() {
..Default::default()
}),
instructions_template: Some("template".to_string()),
instructions_variables: Some(ModelInstructionsVariables {
personality_default: Some("default".to_string()),
personality_friendly: Some("friendly".to_string()),
personality_pragmatic: Some("pragmatic".to_string()),
}),
approvals: Some(approvals),
collaboration_modes: Some(collaboration_modes),
auto_review: Some(auto_review),
@@ -123,7 +117,6 @@ fn base_instruction_override_is_literal_and_preserves_catalog_messages() {
let updated = with_config_overrides(model, &config);
messages.instructions_template = Some(override_instructions.to_string());
messages.instructions_variables = None;
assert_eq!(updated.model_messages, Some(messages));
assert_eq!(render_model_instructions(&updated), override_instructions);
}
@@ -152,11 +145,6 @@ fn personality_none_strips_catalog_instruction_sources_through_the_next_h1() {
] {
let mut messages = ModelMessages {
instructions_template: Some(instructions.to_string()),
instructions_variables: Some(ModelInstructionsVariables {
personality_default: Some("default".to_string()),
personality_friendly: Some("friendly".to_string()),
personality_pragmatic: Some("pragmatic".to_string()),
}),
persistent_instructions: Some(String::new()),
tools: Some(ToolMessages {
send_user_message_async: Some(ToolMessage {
codex-rs/prompts/src/model_instructions_tests.rs
+1 -7
View File
@@ -2,7 +2,6 @@
use super::*;
use codex_protocol::openai_models::ConfigShellToolType;
use codex_protocol::openai_models::ModelInstructionsVariables;
use codex_protocol::openai_models::ModelMessages;
use codex_protocol::openai_models::ModelVisibility;
use codex_protocol::openai_models::TruncationPolicyConfig;
@@ -61,15 +60,10 @@ fn test_model(model_messages: Option<ModelMessages>) -> ModelInfo {
}
#[test]
fn renders_literal_templates_with_legacy_personality_inputs() {
fn renders_literal_templates() {
let template = "Hello {{ personality }}\n\n# Personality\n\nFixed instructions";
let model = test_model(Some(ModelMessages {
instructions_template: Some(template.to_string()),
instructions_variables: Some(ModelInstructionsVariables {
personality_default: Some("default".to_string()),
personality_friendly: Some("friendly".to_string()),
personality_pragmatic: Some("pragmatic".to_string()),
}),
..Default::default()
}));
assert_eq!(
codex-rs/protocol/src/openai_models.rs
+20 -28
View File
@@ -248,7 +248,8 @@ pub struct ModelPreset {
pub default_reasoning_effort: ReasoningEffort,
/// Supported reasoning effort options.
pub supported_reasoning_efforts: Vec<ReasoningEffortPreset>,
/// Deprecated catalog field, always false for new model presets.
/// Compatibility field retained for consumers of model presets; personality selection is no
/// longer supported.
#[serde(default)]
pub supports_personality: bool,
/// Deprecated: use `service_tiers` instead.
@@ -539,8 +540,8 @@ impl ModelInfo {
/// A strongly-typed template for assembling model instructions and developer messages.
///
/// `instructions_template` is literal text. The deprecated `instructions_variables` field is
/// retained to decode catalogs produced before personality selection was removed.
/// `instructions_template`: Formerly a personality template, now literal text. The name is
/// retained for model catalog compatibility.
#[derive(Debug, Default, Serialize, Deserialize, Clone, PartialEq, Eq, TS, JsonSchema)]
pub struct ModelMessages {
/// Developer guidance after a content-filter block. Missing, null, blank, or values over
@@ -554,7 +555,6 @@ pub struct ModelMessages {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tools: Option<ToolMessages>,
pub instructions_template: Option<String>,
pub instructions_variables: Option<ModelInstructionsVariables>,
pub approvals: Option<ApprovalMessages>,
pub collaboration_modes: Option<CollaborationModeMessages>,
pub auto_review: Option<AutoReviewMessages>,
@@ -792,13 +792,6 @@ pub struct MultiAgentModeMessages {
pub hint_text: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, TS, JsonSchema)]
pub struct ModelInstructionsVariables {
pub personality_default: Option<String>,
pub personality_friendly: Option<String>,
pub personality_pragmatic: Option<String>,
}
#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, TS, JsonSchema)]
pub struct ModelInfoUpgrade {
pub model: String,
@@ -1111,10 +1104,9 @@ mod tests {
}
#[test]
fn model_messages_deserialize_without_optional_sections() {
let messages: ModelMessages = from_str(
r#"{"instructions_template":null,"instructions_variables":null,"persistent_instructions":null}"#,
)
.expect("model messages should deserialize");
let messages: ModelMessages =
from_str(r#"{"instructions_template":null,"persistent_instructions":null}"#)
.expect("model messages should deserialize");
assert_eq!(messages, ModelMessages::default());
}
@@ -1219,7 +1211,6 @@ mod tests {
let messages: ModelMessages = from_str(
r#"{
"instructions_template": null,
"instructions_variables": null,
"approvals": {
"on_request": "",
"never": ""
@@ -1244,7 +1235,6 @@ mod tests {
let missing_template: ModelMessages = from_str(
r#"{
"instructions_template": null,
"instructions_variables": null,
"auto_review": {
"policy": "policy"
}
@@ -1254,7 +1244,6 @@ mod tests {
let empty_template: ModelMessages = from_str(
r#"{
"instructions_template": null,
"instructions_variables": null,
"auto_review": {
"policy": "policy",
"policy_template": "",
@@ -1293,7 +1282,6 @@ mod tests {
let messages: ModelMessages = from_str(
r#"{
"instructions_template": null,
"instructions_variables": null,
"permissions": {
"workspace_write": ""
}
@@ -1314,7 +1302,7 @@ mod tests {
#[test]
fn multi_agent_messages_preserve_missing_and_empty_values() {
let messages: ModelMessages = from_str(
r#"{"instructions_template":null,"instructions_variables":null,"multi_agent":{"role":{"root":"","subagent":"subagent base"},"mode":{"explicit":"explicit mode","proactive":"","hint_text":""}}}"#,
r#"{"instructions_template":null,"multi_agent":{"role":{"root":"","subagent":"subagent base"},"mode":{"explicit":"explicit mode","proactive":"","hint_text":""}}}"#,
)
.expect("multi-agent messages should deserialize");
@@ -1338,8 +1326,12 @@ mod tests {
fn collaboration_mode_messages_preserve_missing_and_empty_values() {
let messages: ModelMessages = from_str(
r#"{
"instructions_template": null,
"instructions_variables": null,
"instructions_template": "legacy catalog instructions",
"instructions_variables": {
"personality_default": "default",
"personality_friendly": "friendly",
"personality_pragmatic": "pragmatic"
},
"collaboration_modes": {
"default": ""
}
@@ -1350,6 +1342,7 @@ mod tests {
assert_eq!(
messages,
ModelMessages {
instructions_template: Some("legacy catalog instructions".to_string()),
collaboration_modes: Some(CollaborationModeMessages {
default: Some(String::new()),
plan: None,
@@ -1357,6 +1350,11 @@ mod tests {
..Default::default()
}
);
let roundtripped: ModelMessages = serde_json::from_value(
serde_json::to_value(&messages).expect("serialize model messages"),
)
.expect("deserialize model messages");
assert_eq!(roundtripped, messages);
}
#[test]
@@ -1492,11 +1490,6 @@ mod tests {
let response = ModelsResponse {
models: vec![test_model(Some(ModelMessages {
instructions_template: template.map(str::to_owned),
instructions_variables: Some(ModelInstructionsVariables {
personality_default: Some("default".to_string()),
personality_friendly: Some("friendly".to_string()),
personality_pragmatic: Some("pragmatic".to_string()),
}),
..Default::default()
}))],
};
@@ -1525,7 +1518,6 @@ mod tests {
..Default::default()
}),
instructions_template: None,
instructions_variables: None,
approvals: Some(ApprovalMessages {
on_request: Some("approval".to_string()),
on_request_auto_review: None,
codex-rs/tui/src/app_server_session.rs
+1 -1
View File
@@ -1894,7 +1894,7 @@ pub(crate) fn model_preset_from_api_model(model: ApiModel) -> ModelPreset {
description: effort.description,
})
.collect(),
supports_personality: model.supports_personality,
supports_personality: false,
additional_speed_tiers: model.additional_speed_tiers,
service_tiers: model
.service_tiers