Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Persist generated images through turn executors (#39072)

Andrew Wilkes682f57254f8c
diff --git a/codex-rs/core/tests/suite/extension_sandbox.rs b/codex-rs/core/tests/suite/extension_sandbox.rs
index 777dd51854..f0d6fa46de 100644
--- a/codex-rs/core/tests/suite/extension_sandbox.rs
+++ b/codex-rs/core/tests/suite/extension_sandbox.rs
@@ -149,7 +149,8 @@ async fn extension_tool_receives_turn_environment_sandbox() -> Result<()> {
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn extension_tool_uses_granted_turn_permissions_without_local_persistence() -> Result<()> {
+async fn extension_tool_uses_granted_turn_permissions_without_host_local_persistence() -> Result<()>
+{
skip_if_no_network!(Ok(()));
skip_if_sandbox!(Ok(()));
@@ -302,13 +303,25 @@ async fn extension_tool_uses_granted_turn_permissions_without_local_persistence(
.last_request()
.context("missing request containing extension output")?;
let output = request.function_call_output(image_call_id);
+ let expected_path = test
+ .config
+ .cwd
+ .join("generated_images")
+ .join("image-edit-granted.png");
assert_eq!(
- output["output"],
- json!([{
+ output["output"][0],
+ json!({
"type": "input_image",
"image_url": TINY_PNG_DATA_URL,
- }])
+ })
+ );
+ assert_eq!(output["output"].as_array().map(Vec::len), Some(2));
+ assert!(
+ output["output"][1]["text"]
+ .as_str()
+ .is_some_and(|hint| hint.contains(&expected_path.display().to_string()))
);
+ assert_eq!(std::fs::read(expected_path.as_path())?, TINY_PNG_BYTES);
assert!(!test.config.codex_home.join("generated_images").exists());
Ok(())
diff --git a/codex-rs/ext/image-generation/src/tool.rs b/codex-rs/ext/image-generation/src/tool.rs
index ab973da74c..d71f6d2b30 100644
--- a/codex-rs/ext/image-generation/src/tool.rs
+++ b/codex-rs/ext/image-generation/src/tool.rs
@@ -9,7 +9,6 @@ use codex_api::ImageGenerationRequest;
use codex_api::ImageQuality;
use codex_api::ImageUrl;
use codex_exec_server::CreateDirectoryOptions;
-use codex_exec_server::ExecutorFileSystem;
use codex_exec_server::LOCAL_FS;
use codex_extension_api::ExtensionTurnItem;
use codex_extension_api::FunctionCallError;
@@ -59,6 +58,9 @@ use crate::backend::CodexImagesBackend;
const IMAGE_MODEL: &str = "gpt-image-2";
const MAX_EDIT_IMAGES: usize = 5;
+const MAX_EXECUTOR_GENERATED_IMAGE_BYTES: usize = 32 * 1024 * 1024;
+const MAX_EXECUTOR_GENERATED_IMAGE_BASE64_BYTES: usize =
+ MAX_EXECUTOR_GENERATED_IMAGE_BYTES.div_ceil(3) * 4;
const IMAGEGEN_DESCRIPTION: &str = include_str!("../imagegen_description.md");
#[derive(Clone)]
@@ -198,31 +200,14 @@ impl ImageGenerationTool {
return Err(FunctionCallError::RespondToModel(message));
}
};
- let saved_path = match self.save_root.as_ref() {
- Some(save_root) => match save_image_generation_result(
- LOCAL_FS.as_ref(),
- save_root,
- &self.thread_id,
- &call.call_id,
- &result,
- )
- .await
- {
- Ok(path) => Some(path),
- Err(error) => {
- let output_path =
- image_generation_artifact_path(save_root, &self.thread_id, &call.call_id);
- let output_dir = output_path.parent().unwrap_or_else(|| save_root.clone());
- tracing::warn!(
- call_id = %call.call_id,
- output_dir = %output_dir.display(),
- "failed to save generated image: {error}"
- );
- None
- }
- },
- None => None,
- };
+ let saved_path = save_image_generation_result(
+ self.save_root.as_ref(),
+ call.environments.first(),
+ &self.thread_id,
+ &call.call_id,
+ &result,
+ )
+ .await;
let item = ImageGenerationItem {
id: call.call_id.clone(),
status: "completed".to_string(),
@@ -275,27 +260,125 @@ fn usage_limit_failure(error: &CodexErr) -> Option<ImageGenerationFailure> {
}
async fn save_image_generation_result(
- fs: &dyn ExecutorFileSystem,
- save_root: &AbsolutePathBuf,
+ save_root: Option<&AbsolutePathBuf>,
+ environment: Option<&ToolEnvironment>,
session_id: &str,
call_id: &str,
result: &str,
-) -> io::Result<AbsolutePathBuf> {
- let bytes = BASE64_STANDARD
- .decode(result.trim().as_bytes())
- .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
- let path = image_generation_artifact_path(save_root, session_id, call_id);
- if let Some(parent) = path.parent() {
- fs.create_directory(
- &PathUri::from_abs_path(&parent),
- CreateDirectoryOptions { recursive: true },
- /*sandbox*/ None,
- )
- .await?;
+) -> Option<AbsolutePathBuf> {
+ let (output_dir, save_result) = match save_root {
+ Some(save_root) => {
+ let path = image_generation_artifact_path(save_root, session_id, call_id);
+ let output_dir = path.parent().unwrap_or_else(|| save_root.clone());
+ let save_result: io::Result<AbsolutePathBuf> = async {
+ let bytes = BASE64_STANDARD
+ .decode(result.trim().as_bytes())
+ .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
+ if let Some(parent) = path.parent() {
+ LOCAL_FS
+ .create_directory(
+ &PathUri::from_abs_path(&parent),
+ CreateDirectoryOptions { recursive: true },
+ /*sandbox*/ None,
+ )
+ .await?;
+ }
+ LOCAL_FS
+ .write_file(&PathUri::from_abs_path(&path), bytes, /*sandbox*/ None)
+ .await?;
+ Ok(path)
+ }
+ .await;
+ (output_dir, save_result)
+ }
+ None => {
+ let environment = environment?;
+ let output_dir = environment.cwd.join("generated_images");
+ let save_result: io::Result<AbsolutePathBuf> = async {
+ let result = result.trim();
+ if result.len() > MAX_EXECUTOR_GENERATED_IMAGE_BASE64_BYTES {
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidData,
+ "generated image exceeds the executor file size limit",
+ ));
+ }
+ let bytes = BASE64_STANDARD
+ .decode(result.as_bytes())
+ .map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
+ if bytes.len() > MAX_EXECUTOR_GENERATED_IMAGE_BYTES {
+ return Err(io::Error::new(
+ io::ErrorKind::InvalidData,
+ "generated image exceeds the executor file size limit",
+ ));
+ }
+
+ let artifact_path =
+ image_generation_artifact_path(&environment.cwd, session_id, call_id);
+ let path = output_dir.join(artifact_path.as_path().file_name().unwrap_or_default());
+ let sandbox = Some(&environment.file_system_sandbox_context);
+ if let Some(parent) = path.parent() {
+ let parent_uri = PathUri::from_abs_path(&parent);
+ environment
+ .file_system
+ .create_directory(
+ &parent_uri,
+ CreateDirectoryOptions { recursive: true },
+ sandbox,
+ )
+ .await?;
+
+ // Full-access executor contexts do not prevent symlinked output directories.
+ let metadata = environment
+ .file_system
+ .get_metadata(&parent_uri, sandbox)
+ .await?;
+ if metadata.is_symlink || !metadata.is_directory {
+ return Err(io::Error::new(
+ io::ErrorKind::PermissionDenied,
+ "generated image directory is not a real directory",
+ ));
+ }
+ }
+
+ // Existing destination hardlinks could otherwise overwrite files outside the workspace.
+ let path_uri = PathUri::from_abs_path(&path);
+ match environment
+ .file_system
+ .get_metadata(&path_uri, sandbox)
+ .await
+ {
+ Ok(_) => {
+ return Err(io::Error::new(
+ io::ErrorKind::AlreadyExists,
+ "generated image destination already exists",
+ ));
+ }
+ Err(error) if error.kind() == io::ErrorKind::NotFound => {}
+ Err(error) => return Err(error),
+ }
+
+ environment
+ .file_system
+ .write_file(&path_uri, bytes, sandbox)
+ .await?;
+ Ok(path)
+ }
+ .await;
+ (output_dir, save_result)
+ }
+ };
+
+ match save_result {
+ Ok(path) => Some(path),
+ Err(error) => {
+ tracing::warn!(
+ call_id = %call_id,
+ output_dir = %output_dir.display(),
+ "failed to save generated image: {error}"
+ );
+ None
+ }
}
- fs.write_file(&PathUri::from_abs_path(&path), bytes, /*sandbox*/ None)
- .await?;
- Ok(path)
}
#[derive(Debug, PartialEq)]