Files
codex/codex-rs/core/tests/suite/image_rollout.rs
T
Sean Huang db9778b73c Distinguish image and tool audio attachment uploads (#62047)
## What changed

Introduce `UploadContent::Image` and `UploadContent::ToolAudio` in `UploadRequest`. Keep image filenames and policy tags on the image variant, and carry tool audio's declared MIME type explicitly instead of encoding its type and MIME metadata in tags.

Update image preparation, image generation, and tool audio callers to use the typed content. Preserve inline bytes for both variants and redact their payloads from debug output. Document that persistent backends must verify the declared audio MIME type against the uploaded bytes.

## Testing

Add coverage for inline tool audio byte preservation and audio debug redaction. Update integration assertions for typed image and audio uploads, and verify that Code Mode does not upload audio when `FileBackedToolAudio` is disabled.

GitOrigin-RevId: 7dbd69922b377aead2dc28d1e5b3938cce6343b7
2026-11-17 13:38:34 +00:00

896 lines
31 KiB
Rust

use anyhow::Context;
use base64::Engine;
use base64::engine::general_purpose::STANDARD as BASE64_STANDARD;
use codex_attachment_store::AttachmentMetadata;
use codex_attachment_store::AttachmentStore;
use codex_attachment_store::AttachmentStoreError;
use codex_attachment_store::AttachmentStoreErrorKind;
use codex_attachment_store::IsResolvableFuture;
use codex_attachment_store::ResolveFuture;
use codex_attachment_store::ResolveRequest;
use codex_attachment_store::UploadContent;
use codex_attachment_store::UploadFuture;
use codex_attachment_store::UploadRequest;
use codex_attachment_store::UploadResult;
use codex_core::TurnInputRequest;
use codex_features::Feature;
use codex_history::RolloutItem;
use codex_protocol::config_types::CollaborationMode;
use codex_protocol::config_types::ModeKind;
use codex_protocol::config_types::Settings;
use codex_protocol::items::TurnItem;
use codex_protocol::models::ContentItem;
use codex_protocol::models::DEFAULT_IMAGE_DETAIL;
use codex_protocol::models::ImageDetail;
use codex_protocol::models::ImageReference;
use codex_protocol::models::PermissionProfile;
use codex_protocol::models::ResponseInputItem;
use codex_protocol::models::ResponseItem;
use codex_protocol::protocol::AskForApproval;
use codex_protocol::protocol::EventMsg;
use codex_protocol::protocol::Op;
use codex_protocol::protocol::ThreadHistoryMode;
use codex_protocol::protocol::ThreadSettingsOverrides;
use codex_protocol::user_input::ByteRange;
use codex_protocol::user_input::TextElement;
use codex_protocol::user_input::UserInput;
use codex_utils_image::data_url_from_bytes;
use core_test_support::TempDirExt;
use core_test_support::responses;
use core_test_support::responses::ev_assistant_message;
use core_test_support::responses::ev_completed;
use core_test_support::responses::ev_response_created;
use core_test_support::responses::sse;
use core_test_support::responses::start_mock_server;
use core_test_support::responses::strip_metadata;
use core_test_support::responses::strip_response_item_id;
use core_test_support::skip_if_no_network;
use core_test_support::test_codex::TestCodex;
use core_test_support::test_codex::local_requests;
use core_test_support::test_codex::test_codex;
use core_test_support::test_codex::turn_permission_fields;
use core_test_support::wait_for_event;
use core_test_support::wait_for_event_match;
use image::GenericImageView;
use image::ImageBuffer;
use image::Rgba;
use pretty_assertions::assert_eq;
use serde_json::Value;
use std::collections::HashMap;
use std::fs;
use std::path::Path;
use std::sync::Arc;
use std::sync::Mutex;
use std::time::Duration;
const UPLOADED_FILE_ID: &str = "file_uploaded_image";
#[derive(Default)]
pub(super) struct RecordingFileAttachmentStore {
pub(super) uploads: Mutex<Vec<UploadRequest>>,
pub(super) resolve_errors: Mutex<HashMap<String, AttachmentStoreErrorKind>>,
pub(super) resolves: Mutex<HashMap<String, usize>>,
pub(super) resolve_barrier: Option<Arc<tokio::sync::Barrier>>,
}
impl AttachmentStore for RecordingFileAttachmentStore {
fn is_resolvable<'a>(&'a self, file_id: &'a str) -> IsResolvableFuture<'a> {
Box::pin(async move {
match self
.resolve(ResolveRequest {
file_id,
tags: HashMap::new(),
download_url_ttl: None,
})
.await
{
Ok(_) => true,
Err(error) => error.kind() != AttachmentStoreErrorKind::NotFound,
}
})
}
fn upload(&self, request: UploadRequest) -> UploadFuture<'_> {
self.uploads.lock().expect("uploads lock").push(request);
Box::pin(async {
Ok(UploadResult::File {
file_id: UPLOADED_FILE_ID.to_string(),
})
})
}
fn resolve<'a>(&'a self, request: ResolveRequest<'a>) -> ResolveFuture<'a> {
*self
.resolves
.lock()
.expect("resolves lock")
.entry(request.file_id.to_string())
.or_default() += 1;
let error_kind = self
.resolve_errors
.lock()
.expect("resolve errors lock")
.get(request.file_id)
.copied();
let barrier = self.resolve_barrier.clone();
Box::pin(async move {
if let Some(barrier) = barrier {
barrier.wait().await;
}
match error_kind {
Some(kind) => Err(AttachmentStoreError::new(kind, "attachment unavailable")),
None => Ok(AttachmentMetadata::default()),
}
})
}
}
fn find_user_message_with_image(text: &str) -> Option<ResponseItem> {
for line in text.lines() {
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
let rollout = match codex_rollout::parse_rollout_line(trimmed) {
Ok(rollout) => rollout,
Err(_) => continue,
};
if let RolloutItem::ResponseItem(envelope) = &rollout.item
&& let ResponseItem::Message { role, content, .. } = &envelope.item
&& role == "user"
&& content
.iter()
.any(|span| matches!(span, ContentItem::InputImage { .. }))
{
return Some(envelope.item.clone());
}
}
None
}
fn extract_image_url(item: &ResponseItem) -> Option<String> {
match item {
ResponseItem::Message { content, .. } => content.iter().find_map(|span| match span {
ContentItem::InputImage {
image: ImageReference::Inline { image_url },
..
} => Some(image_url.clone()),
_ => None,
}),
_ => None,
}
}
async fn read_rollout_text(path: &Path) -> anyhow::Result<String> {
for _ in 0..50 {
if path.exists()
&& let Ok(text) = std::fs::read_to_string(path)
&& !text.trim().is_empty()
{
return Ok(text);
}
tokio::time::sleep(Duration::from_millis(20)).await;
}
std::fs::read_to_string(path)
.with_context(|| format!("read rollout file at {}", path.display()))
}
fn write_test_png(path: &Path, color: [u8; 4]) -> anyhow::Result<()> {
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)?;
}
let image = ImageBuffer::from_pixel(2, 2, Rgba(color));
image.save(path)?;
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn copy_paste_local_image_persists_rollout_request_shape() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let TestCodex {
codex,
cwd,
session_configured,
home: _home,
..
} = test_codex().build(&server).await?;
let rel_path = "images/paste.png";
let abs_path = cwd.path().join(rel_path);
write_test_png(&abs_path, [12, 34, 56, 255])?;
let response = sse(vec![
ev_response_created("resp-1"),
ev_assistant_message("msg-1", "done"),
ev_completed("resp-1"),
]);
responses::mount_sse_once(&server, response).await;
let session_model = session_configured.model.clone();
let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, cwd.path());
codex
.start_or_steer_turn(
TurnInputRequest::user_input(vec![
UserInput::LocalImage {
path: abs_path.clone(),
detail: None,
},
UserInput::Text {
text: "pasted image".to_string(),
text_elements: Vec::new(),
},
])
.with_thread_settings(ThreadSettingsOverrides {
environments: Some(local_requests(cwd.abs())),
approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile,
collaboration_mode: Some(CollaborationMode {
mode: ModeKind::Default,
settings: Settings {
model: session_model,
reasoning_effort: None,
developer_instructions: None,
},
}),
..Default::default()
}),
)
.await?;
wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
codex.submit(Op::Shutdown).await?;
wait_for_event(&codex, |event| matches!(event, EventMsg::ShutdownComplete)).await;
let rollout_path = codex.rollout_path().expect("rollout path");
let rollout_text = read_rollout_text(&rollout_path).await?;
let actual = find_user_message_with_image(&rollout_text)
.expect("expected user message with input image in rollout");
let image_url = extract_image_url(&actual).expect("expected image url in rollout");
let expected = ResponseItem::Message {
status: None,
encrypted_content: None,
id: None,
role: "user".to_string(),
content: vec![
ContentItem::InputText {
text: codex_protocol::models::local_image_open_tag_text_with_path(
/*label_number*/ 1, &abs_path,
),
},
ContentItem::InputImage {
image: ImageReference::Inline { image_url },
detail: Some(ImageDetail::Original),
},
ContentItem::InputText {
text: codex_protocol::models::image_close_tag_text(),
},
ContentItem::InputText {
text: "pasted image".to_string(),
},
],
phase: None,
internal_chat_message_metadata_passthrough: None,
};
assert_eq!(strip_response_item_id(strip_metadata(actual)), expected);
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn drag_drop_image_persists_rollout_request_shape() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let TestCodex {
codex,
cwd,
session_configured,
home: _home,
..
} = test_codex().build(&server).await?;
let image_url = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR4nGP4z8DwHwAFAAH/iZk9HQAAAABJRU5ErkJggg==".to_string();
let response = sse(vec![
ev_response_created("resp-1"),
ev_assistant_message("msg-1", "done"),
ev_completed("resp-1"),
]);
responses::mount_sse_once(&server, response).await;
let session_model = session_configured.model.clone();
let (sandbox_policy, permission_profile) =
turn_permission_fields(PermissionProfile::Disabled, cwd.path());
codex
.start_or_steer_turn(
TurnInputRequest::user_input(vec![
UserInput::Image {
image: ImageReference::Inline {
image_url: image_url.clone(),
},
detail: None,
},
UserInput::Text {
text: "dropped image".to_string(),
text_elements: Vec::new(),
},
])
.with_thread_settings(ThreadSettingsOverrides {
environments: Some(local_requests(cwd.abs())),
approval_policy: Some(AskForApproval::Never),
sandbox_policy: Some(sandbox_policy),
permission_profile,
collaboration_mode: Some(CollaborationMode {
mode: ModeKind::Default,
settings: Settings {
model: session_model,
reasoning_effort: None,
developer_instructions: None,
},
}),
..Default::default()
}),
)
.await?;
wait_for_event(&codex, |event| matches!(event, EventMsg::TurnComplete(_))).await;
codex.submit(Op::Shutdown).await?;
wait_for_event(&codex, |event| matches!(event, EventMsg::ShutdownComplete)).await;
let rollout_path = codex.rollout_path().expect("rollout path");
let rollout_text = read_rollout_text(&rollout_path).await?;
let actual = find_user_message_with_image(&rollout_text)
.expect("expected user message with input image in rollout");
let image_url = extract_image_url(&actual).expect("expected image url in rollout");
let expected = ResponseItem::Message {
status: None,
encrypted_content: None,
id: None,
role: "user".to_string(),
content: vec![
ContentItem::InputImage {
image: ImageReference::Inline { image_url },
detail: Some(ImageDetail::Original),
},
ContentItem::InputText {
text: "dropped image".to_string(),
},
],
phase: None,
internal_chat_message_metadata_passthrough: None,
};
assert_eq!(strip_response_item_id(strip_metadata(actual)), expected);
Ok(())
}
/// Core must forward an opaque file ID and persist that same reference in canonical history.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn file_image_passes_through_request_and_rollout() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let test = test_codex().build_with_auto_env(&server).await?;
let response_mock = responses::mount_sse_once(
&server,
sse(vec![
ev_response_created("resp-file"),
ev_assistant_message("msg-file", "done"),
ev_completed("resp-file"),
]),
)
.await;
test.codex
.start_or_steer_turn(TurnInputRequest::user_input(vec![
UserInput::Image {
image: ImageReference::File {
file_id: "file_123".to_string(),
},
detail: None,
},
UserInput::Text {
text: "file-backed image".to_string(),
text_elements: Vec::new(),
},
]))
.await?;
wait_for_event(&test.codex, |event| {
matches!(event, EventMsg::TurnComplete(_))
})
.await;
let request = response_mock.single_request();
assert!(request.input().iter().any(|item| {
item.get("content")
.and_then(Value::as_array)
.is_some_and(|content| {
content.iter().any(|item| {
item.get("type").and_then(Value::as_str) == Some("input_image")
&& item.get("file_id").and_then(Value::as_str) == Some("file_123")
})
})
}));
test.codex.shutdown_and_wait().await?;
let rollout_path = test.codex.rollout_path().expect("rollout path");
let rollout_text = read_rollout_text(&rollout_path).await?;
let actual = find_user_message_with_image(&rollout_text)
.expect("expected user message with file image in rollout");
assert_eq!(
strip_response_item_id(strip_metadata(actual)),
ResponseItem::Message {
status: None,
encrypted_content: None,
id: None,
role: "user".to_string(),
content: vec![
ContentItem::InputImage {
image: ImageReference::File {
file_id: "file_123".to_string(),
},
detail: Some(DEFAULT_IMAGE_DETAIL),
},
ContentItem::InputText {
text: "file-backed image".to_string(),
},
],
phase: None,
internal_chat_message_metadata_passthrough: None,
}
);
Ok(())
}
/// Uploaded images keep their original input positions and text spans in live and durable display
/// history, even when earlier images fail preparation or expand into multiple model content items.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn uploaded_images_preserve_user_message_display_history() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let test = test_codex()
.with_image_store(Arc::new(RecordingFileAttachmentStore::default()))
.with_history_mode(ThreadHistoryMode::Paginated)
.build_with_auto_env(&server)
.await?;
let image_path = test.cwd.path().join("display-image.png");
write_test_png(&image_path, [12, 34, 56, 255])?;
let image_url = data_url_from_bytes("image/png", &fs::read(&image_path)?);
let input = vec![
UserInput::Text {
text: "inspect these images".to_string(),
text_elements: vec![TextElement::new(
ByteRange { start: 0, end: 7 },
Some("<file>".to_string()),
)],
},
UserInput::LocalImage {
path: test.cwd.path().join("missing-image.png"),
detail: None,
},
UserInput::Image {
image: ImageReference::Inline {
image_url: "data:image/png;base64,bm90IGFuIGltYWdl".to_string(),
},
detail: None,
},
UserInput::LocalImage {
path: image_path,
detail: Some(ImageDetail::High),
},
UserInput::Image {
image: ImageReference::Inline {
image_url: image_url.clone(),
},
detail: None,
},
UserInput::Text {
text: "and this copy".to_string(),
text_elements: Vec::new(),
},
UserInput::Image {
image: ImageReference::File {
file_id: "file_existing".to_string(),
},
detail: Some(ImageDetail::Original),
},
UserInput::Image {
image: ImageReference::Inline { image_url },
detail: None,
},
];
let mut expected_input = input.clone();
for index in [3, 4, 7] {
let detail = match &input[index] {
UserInput::Image { detail, .. } | UserInput::LocalImage { detail, .. } => *detail,
_ => unreachable!("these inputs are images"),
};
expected_input[index] = UserInput::Image {
image: ImageReference::File {
file_id: UPLOADED_FILE_ID.to_string(),
},
detail,
};
}
let response_mock = responses::mount_sse_once(
&server,
sse(vec![
ev_response_created("resp-display"),
ev_completed("resp-display"),
]),
)
.await;
test.codex
.start_or_steer_turn(TurnInputRequest::user_input(input))
.await?;
let started = wait_for_event_match(&test.codex, |event| match event {
EventMsg::ItemStarted(event) => match &event.item {
TurnItem::UserMessage(item) => Some(item.clone()),
_ => None,
},
_ => None,
})
.await;
let completed = wait_for_event_match(&test.codex, |event| match event {
EventMsg::ItemCompleted(event) => match &event.item {
TurnItem::UserMessage(item) => Some(item.clone()),
_ => None,
},
_ => None,
})
.await;
assert_eq!(started.content, expected_input);
assert_eq!(completed.id, started.id);
assert_eq!(completed.client_id, started.client_id);
assert_eq!(completed.content, started.content);
wait_for_event(&test.codex, |event| {
matches!(event, EventMsg::TurnComplete(_))
})
.await;
let request = response_mock.single_request();
let mut model_file_ids = Vec::new();
for item in request.input() {
if item.get("role").and_then(Value::as_str) != Some("user") {
continue;
}
if let Some(content) = item.get("content").and_then(Value::as_array) {
for content_item in content {
if content_item.get("type").and_then(Value::as_str) == Some("input_image") {
model_file_ids.push(
content_item
.get("file_id")
.and_then(Value::as_str)
.context("prepared image file ID")?
.to_string(),
);
}
}
}
}
assert_eq!(
model_file_ids,
vec![
UPLOADED_FILE_ID,
UPLOADED_FILE_ID,
"file_existing",
UPLOADED_FILE_ID,
]
);
test.codex.shutdown_and_wait().await?;
let rollout_path = test.codex.rollout_path().context("rollout path")?;
let rollout_text = read_rollout_text(&rollout_path).await?;
let mut persisted_user_items = Vec::new();
for line in rollout_text.lines() {
if let RolloutItem::EventMsg(EventMsg::ItemCompleted(event)) =
codex_rollout::parse_rollout_line(line)?.item
&& let TurnItem::UserMessage(item) = event.item
{
persisted_user_items.push(item);
}
}
let [persisted] = persisted_user_items.as_slice() else {
panic!("expected exactly one persisted user message");
};
assert_eq!(persisted.id, completed.id);
assert_eq!(persisted.client_id, completed.client_id);
assert_eq!(persisted.content, completed.content);
Ok(())
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn resumed_history_only_emits_resize_notices_for_new_images() -> anyhow::Result<()> {
skip_if_no_network!(Ok(()));
let server = start_mock_server().await;
let initial = test_codex().build_with_auto_env(&server).await?;
responses::mount_sse_once(
&server,
sse(vec![
ev_response_created("resp-initial"),
ev_assistant_message("msg-initial", "recorded"),
ev_completed("resp-initial"),
]),
)
.await;
initial.submit_turn("historical image").await?;
let rollout_path = initial
.session_configured
.rollout_path
.clone()
.context("initial rollout path")?;
initial.codex.shutdown_and_wait().await?;
let image_path = initial.cwd.path().join("large-image.png");
ImageBuffer::from_pixel(
/*width*/ 6400,
/*height*/ 256,
Rgba([12u8, 34, 56, 255]),
)
.save(&image_path)?;
let original_image_url = data_url_from_bytes("image/png", &fs::read(&image_path)?);
let mut rollout_lines = fs::read_to_string(&rollout_path)?
.lines()
.map(codex_rollout::parse_rollout_line)
.collect::<serde_json::Result<Vec<_>>>()?;
let historical_content = rollout_lines
.iter_mut()
.find_map(|line| {
let RolloutItem::ResponseItem(envelope) = &mut line.item else {
return None;
};
let ResponseItem::Message { role, content, .. } = &mut envelope.item else {
return None;
};
(role == "user"
&& content.iter().any(|item| {
matches!(item, ContentItem::InputText { text } if text == "historical image")
}))
.then_some(content)
})
.context("historical user message in rollout")?;
historical_content.insert(
/*index*/ 0,
ContentItem::InputImage {
image: ImageReference::Inline {
image_url: original_image_url.clone(),
},
detail: Some(ImageDetail::High),
},
);
let rollout = rollout_lines
.iter()
.map(serde_json::to_string)
.collect::<serde_json::Result<Vec<_>>>()?
.join("\n");
fs::write(&rollout_path, format!("{rollout}\n"))?;
let resume_image_store = Arc::new(RecordingFileAttachmentStore::default());
let mut resume_builder = test_codex()
.with_image_store(resume_image_store.clone())
.with_config(|config| {
let _ = config.features.enable(Feature::ImageResizeNotice);
let _ = config
.features
.enable(Feature::RetainClientDeveloperMessages);
});
let resumed = resume_builder
.resume(&server, initial.home.clone(), rollout_path.clone())
.await?;
let resumed_mock = responses::mount_sse_once(
&server,
sse(vec![
ev_response_created("resp-resumed"),
ev_assistant_message("msg-resumed", "done"),
ev_completed("resp-resumed"),
]),
)
.await;
resumed
.codex
.start_or_steer_turn(TurnInputRequest::user_input(vec![UserInput::Image {
image: ImageReference::Inline {
image_url: original_image_url.clone(),
},
detail: Some(ImageDetail::High),
}]))
.await?;
wait_for_event(&resumed.codex, |event| {
matches!(event, EventMsg::TurnComplete(_))
})
.await;
{
let uploads = resume_image_store.uploads.lock().expect("uploads lock");
let [upload] = uploads.as_slice() else {
panic!("only the new image should be uploaded");
};
assert_eq!(
upload.thread_id,
resumed.session_configured.thread_id.to_string(),
);
let UploadContent::Image {
file_name,
tags,
data,
} = &upload.content
else {
panic!("expected image upload");
};
assert!(file_name.is_none());
assert!(tags.is_empty());
assert_eq!(image::load_from_memory(data)?.dimensions(), (6000, 240));
}
let request = resumed_mock.single_request();
assert!(request.has_content_kinds(&["images.resize_notice"]));
assert!(request.has_content_kinds(&["user.image"]));
let input = request.input();
let image_message_indices = input
.iter()
.enumerate()
.filter_map(|(index, item)| {
(item.get("type").and_then(Value::as_str) == Some("message")
&& item
.get("content")
.and_then(Value::as_array)
.is_some_and(|content| {
content.iter().any(|item| {
item.get("type").and_then(Value::as_str) == Some("input_image")
})
}))
.then_some(index)
})
.collect::<Vec<_>>();
assert_eq!(image_message_indices.len(), 2);
let historical_image_url = input[image_message_indices[0]]
.get("content")
.and_then(Value::as_array)
.and_then(|content| {
content
.iter()
.find(|item| item.get("type").and_then(Value::as_str) == Some("input_image"))
})
.and_then(|item| item.get("image_url"))
.and_then(Value::as_str)
.context("historical image URL in resumed request")?;
let (_, encoded_image) = historical_image_url
.split_once(',')
.context("historical image data URL")?;
let historical_image = image::load_from_memory(&BASE64_STANDARD.decode(encoded_image)?)?;
// Replay honors the high detail recorded with the historical image.
assert_eq!(historical_image.dimensions(), (2048, 82));
assert_eq!(
input[image_message_indices[1]]
.get("content")
.and_then(Value::as_array)
.and_then(|content| content.first())
.and_then(|item| item.get("file_id"))
.and_then(Value::as_str),
Some(UPLOADED_FILE_ID)
);
let expected_notice = concat!(
"<image_resize_notice>\n",
"Image 1 of 1 in the preceding user message was resized from 6400x256 to 6000x240 pixels.\n",
"</image_resize_notice>"
);
let resize_notices = request
.message_input_texts("developer")
.into_iter()
.filter(|text| text.starts_with("<image_resize_notice>"))
.collect::<Vec<_>>();
assert_eq!(resize_notices, vec![expected_notice.to_string()]);
assert_eq!(
input[image_message_indices[1] + 1]
.get("content")
.and_then(Value::as_array)
.and_then(|content| content.first())
.and_then(|item| item.get("text"))
.and_then(Value::as_str),
Some(expected_notice)
);
resumed.codex.shutdown_and_wait().await?;
let replayed = resume_builder
.resume(&server, resumed.home.clone(), rollout_path.clone())
.await?;
let replayed_mock = responses::mount_sse_once(
&server,
sse(vec![
ev_response_created("resp-replayed"),
ev_assistant_message("msg-replayed", "done"),
ev_completed("resp-replayed"),
]),
)
.await;
replayed.submit_turn("preserve recorded notices").await?;
let replayed_request = replayed_mock.single_request();
assert!(replayed_request.input().iter().any(|item| {
item.get("content")
.and_then(Value::as_array)
.is_some_and(|content| {
content.iter().any(|item| {
item.get("file_id").and_then(Value::as_str) == Some(UPLOADED_FILE_ID)
})
})
}));
let replayed_notices = replayed_request
.message_input_texts("developer")
.into_iter()
.filter(|text| text.starts_with("<image_resize_notice>"))
.collect::<Vec<_>>();
assert_eq!(replayed_notices, vec![expected_notice.to_string()]);
let replayed = test_codex()
.with_config(|config| {
let _ = config.features.enable(Feature::ImageResizeNotice);
let _ = config
.features
.enable(Feature::RetainClientDeveloperMessages);
})
.restart(&server, &replayed)
.await?;
let existing_rollout_lines = fs::read_to_string(&rollout_path)?.lines().count();
replayed
.codex
.inject_response_items(vec![
ResponseInputItem::Message {
role: "user".to_string(),
content: vec![ContentItem::InputImage {
image: ImageReference::Inline {
image_url: original_image_url,
},
detail: Some(ImageDetail::High),
}],
phase: None,
}
.into(),
ResponseInputItem::Message {
role: "developer".to_string(),
content: vec![ContentItem::InputText {
text: "<image_resize_notice>client message</image_resize_notice>".to_string(),
}],
phase: None,
}
.into(),
])
.await?;
let persisted_developer_metadata = fs::read_to_string(&rollout_path)?
.lines()
.skip(existing_rollout_lines)
.filter_map(|line| {
let RolloutItem::ResponseItem(envelope) = codex_rollout::parse_rollout_line(line)
.expect("new rollout line should deserialize")
.item
else {
return None;
};
matches!(&envelope.item, ResponseItem::Message { role, .. } if role == "developer")
.then(|| envelope.is_always_retained())
})
.collect::<Vec<_>>();
assert_eq!(persisted_developer_metadata, vec![false, true]);
Ok(())
}