Use model catalog collaboration mode messages (#36351)

## What changed

- Add optional `default` and `plan` collaboration-mode messages to model catalog metadata.
- Prefer the active mode's catalog message, including an explicit empty value, while falling back to the existing developer instructions when the catalog variant is absent.
- Track the model in collaboration-mode world state so mode and model changes append the appropriate instructions, and clear prior instructions when no current message exists.
- Preserve catalog collaboration messages when instruction overrides remove other model instruction fields.

## Testing

- Cover catalog deserialization, variant selection, fallback and empty-message behavior, legacy snapshot migration, mode changes, and model changes.

GitOrigin-RevId: d4c6c0028423bc50b0e8175e55586f3e7bc1c3a8
This commit is contained in:
rhan-oai
2026-07-31 15:40:52 +00:00
committed by copyberry
parent 7b38c48da9
commit 2c005abb07
13 changed files with 556 additions and 36 deletions
@@ -3,36 +3,66 @@ use super::WorldStateSection;
use crate::context::ContextualUserFragment;
use codex_protocol::config_types::CollaborationMode;
use codex_protocol::config_types::ModeKind;
use codex_protocol::openai_models::CollaborationModeMessages;
use codex_protocol::protocol::COLLABORATION_MODE_CLOSE_TAG;
use codex_protocol::protocol::COLLABORATION_MODE_OPEN_TAG;
use serde::Deserialize;
use serde::Serialize;
/// Collaboration-mode instructions currently visible to the model.
#[derive(Clone, Debug)]
pub(crate) struct CollaborationModeState {
mode: ModeKind,
instructions: String,
model: String,
instructions: Option<String>,
}
impl CollaborationModeState {
pub(crate) fn from_collaboration_mode(collaboration_mode: &CollaborationMode) -> Option<Self> {
collaboration_mode
.settings
.developer_instructions
.clone()
.filter(|instructions| !instructions.is_empty())
.map(|instructions| Self {
mode: collaboration_mode.mode,
instructions,
})
pub(crate) fn from_collaboration_mode(
collaboration_mode: &CollaborationMode,
catalog_messages: Option<&CollaborationModeMessages>,
) -> Self {
let catalog_instructions =
catalog_messages.and_then(|messages| match collaboration_mode.mode {
ModeKind::Default => messages.default.as_ref(),
ModeKind::Plan => messages.plan.as_ref(),
ModeKind::PairProgramming | ModeKind::Execute => None,
});
Self {
mode: collaboration_mode.mode,
model: collaboration_mode.settings.model.clone(),
instructions: catalog_instructions.cloned().or_else(|| {
collaboration_mode
.settings
.developer_instructions
.clone()
.filter(|instructions| !instructions.is_empty())
}),
}
}
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(untagged)]
pub(crate) enum CollaborationModeSnapshot {
Current { mode: ModeKind, model: String },
Legacy(ModeKind),
}
impl WorldStateSection for CollaborationModeState {
const ID: &'static str = "collaboration_mode";
type Snapshot = ModeKind;
type Snapshot = CollaborationModeSnapshot;
fn snapshot(&self) -> Self::Snapshot {
self.mode
CollaborationModeSnapshot::Current {
mode: self.mode,
model: self.model.clone(),
}
}
fn should_persist(&self) -> bool {
self.instructions.is_some()
}
fn matches_legacy_fragment(role: &str, text: &str) -> bool {
@@ -51,14 +81,18 @@ impl WorldStateSection for CollaborationModeState {
&self,
previous: PreviousSectionState<'_, Self::Snapshot>,
) -> Option<Box<dyn ContextualUserFragment>> {
if matches!(previous, PreviousSectionState::Known(previous) if previous == &self.mode)
|| matches!(previous, PreviousSectionState::Unknown)
if matches!(
previous,
PreviousSectionState::Known(CollaborationModeSnapshot::Current { mode, model })
if *mode == self.mode && model == &self.model
) || matches!(previous, PreviousSectionState::Unknown)
|| (self.instructions.is_none() && matches!(previous, PreviousSectionState::Absent))
{
return None;
}
Some(Box::new(CollaborationModeInstructions {
instructions: self.instructions.clone(),
instructions: self.instructions.clone().unwrap_or_default(),
}))
}
}
@@ -5,6 +5,8 @@ use crate::context::world_state::WorldState;
use codex_protocol::config_types::ModeKind;
use codex_protocol::config_types::Settings;
use codex_protocol::models::ResponseItem;
use codex_protocol::openai_models::CollaborationModeMessages;
use pretty_assertions::assert_eq;
#[test]
fn snapshots() {
@@ -31,7 +33,7 @@ fn snapshots() {
fn persisted_instructions_are_restored_only_when_missing_from_history() {
let state = collaboration_mode_state(ModeKind::Default, "pair with the user");
let retained: ResponseItem = ContextualUserFragment::into(CollaborationModeInstructions {
instructions: state.instructions.clone(),
instructions: state.instructions.clone().expect("test instructions"),
});
let mut world_state = WorldState::default();
world_state.add_section(state);
@@ -53,14 +55,107 @@ fn persisted_instructions_are_restored_only_when_missing_from_history() {
);
}
fn collaboration_mode_state(mode: ModeKind, instructions: &str) -> CollaborationModeState {
CollaborationModeState::from_collaboration_mode(&CollaborationMode {
#[test]
fn catalog_collaboration_messages_select_mode_variant() {
let messages = CollaborationModeMessages {
default: Some("catalog default instructions".to_string()),
plan: Some("catalog plan instructions".to_string()),
};
for (mode, expected) in [
(ModeKind::Default, "catalog default instructions"),
(ModeKind::Plan, "catalog plan instructions"),
] {
let state = CollaborationModeState::from_collaboration_mode(
&collaboration_mode(mode, Some("legacy instructions")),
Some(&messages),
);
assert_eq!(state.instructions.as_deref(), Some(expected));
}
}
#[test]
fn empty_catalog_collaboration_message_suppresses_legacy_instructions() {
let messages = CollaborationModeMessages {
default: None,
plan: Some(String::new()),
};
let state = CollaborationModeState::from_collaboration_mode(
&collaboration_mode(ModeKind::Plan, Some("legacy plan instructions")),
Some(&messages),
);
assert_eq!(
state
.render_diff(PreviousSectionState::Absent)
.expect("explicit empty collaboration message")
.render(),
format!("{COLLABORATION_MODE_OPEN_TAG}{COLLABORATION_MODE_CLOSE_TAG}")
);
}
#[test]
fn missing_catalog_collaboration_message_uses_legacy_instructions() {
let messages = CollaborationModeMessages {
default: Some("catalog default instructions".to_string()),
plan: None,
};
let state = CollaborationModeState::from_collaboration_mode(
&collaboration_mode(ModeKind::Plan, Some("legacy plan instructions")),
Some(&messages),
);
assert_eq!(
state.instructions.as_deref(),
Some("legacy plan instructions")
);
}
#[test]
fn legacy_collaboration_mode_snapshots_refresh_catalog_messages_once() {
let previous = serde_json::from_str::<CollaborationModeSnapshot>("\"default\"")
.expect("legacy collaboration mode snapshot");
for instructions in ["catalog instructions", ""] {
let messages = CollaborationModeMessages {
default: Some(instructions.to_string()),
plan: None,
};
let state = CollaborationModeState::from_collaboration_mode(
&collaboration_mode(ModeKind::Default, Some("stale legacy instructions")),
Some(&messages),
);
assert_eq!(
state
.render_diff(PreviousSectionState::Known(&previous))
.expect("legacy snapshot should refresh collaboration instructions")
.render(),
format!("{COLLABORATION_MODE_OPEN_TAG}{instructions}{COLLABORATION_MODE_CLOSE_TAG}")
);
assert!(
state
.render_diff(PreviousSectionState::Known(&state.snapshot()))
.is_none()
);
}
}
fn collaboration_mode(mode: ModeKind, instructions: Option<&str>) -> CollaborationMode {
CollaborationMode {
mode,
settings: Settings {
model: "test-model".to_string(),
reasoning_effort: None,
developer_instructions: Some(instructions.to_string()),
developer_instructions: instructions.map(str::to_string),
},
})
.expect("test collaboration mode should have instructions")
}
}
fn collaboration_mode_state(mode: ModeKind, instructions: &str) -> CollaborationModeState {
CollaborationModeState::from_collaboration_mode(
&collaboration_mode(mode, Some(instructions)),
/*catalog_messages*/ None,
)
}
@@ -5,17 +5,17 @@ expression: "render_section_cases(&[(Absent, Absent), (Absent, Known(&default)),
Absent -> Absent
None
Absent -> "default" (role - developer)
Absent -> {"mode":"default","model":"test-model"} (role - developer)
<collaboration_mode>pair with the user</collaboration_mode>
"default" -> "default"
{"mode":"default","model":"test-model"} -> {"mode":"default","model":"test-model"}
None
"default" -> "default"
{"mode":"default","model":"test-model"} -> {"mode":"default","model":"test-model"}
None
"default" -> "plan" (role - developer)
{"mode":"default","model":"test-model"} -> {"mode":"plan","model":"test-model"} (role - developer)
<collaboration_mode>make a plan</collaboration_mode>
Unknown -> "default"
Unknown -> {"mode":"default","model":"test-model"}
None
@@ -1453,6 +1453,7 @@ mod tests {
instructions_template: None,
instructions_variables: None,
approvals: None,
collaboration_modes: None,
auto_review: Some(AutoReviewMessages {
policy: Some("Use the catalog Guardian policy.".to_string()),
policy_template: Some(catalog_template.to_string()),
@@ -1486,6 +1487,7 @@ mod tests {
instructions_template: None,
instructions_variables: None,
approvals: None,
collaboration_modes: None,
auto_review: Some(AutoReviewMessages {
policy: Some(String::new()),
policy_template: None,
@@ -1527,6 +1529,7 @@ mod tests {
instructions_template: None,
instructions_variables: None,
approvals: None,
collaboration_modes: None,
auto_review: Some(AutoReviewMessages {
policy: Some(catalog_policy.to_string()),
policy_template: Some(String::new()),
+9 -5
View File
@@ -129,11 +129,15 @@ impl Session {
.enabled(Feature::RequestPermissionsTool),
));
}
if turn_context.config.include_collaboration_mode_instructions
&& let Some(collaboration_mode) =
CollaborationModeState::from_collaboration_mode(&turn_context.collaboration_mode())
{
world_state.add_section(collaboration_mode);
if turn_context.config.include_collaboration_mode_instructions {
world_state.add_section(CollaborationModeState::from_collaboration_mode(
&turn_context.collaboration_mode(),
turn_context
.model_info
.model_messages
.as_ref()
.and_then(|messages| messages.collaboration_modes.as_ref()),
));
}
if turn_context.config.include_environment_context {
let current_date = self