Add feature-gated standalone image generation extension

codex-rs/Cargo.toml

@@ -47,6 +47,7 @@ members = [
     "ext/extension-api",
     "ext/goal",
     "ext/guardian",
+    "ext/image-generation",
     "ext/memories",
     "ext/web-search",
     "external-agent-migration",
@@ -165,6 +166,7 @@ codex-execpolicy = { path = "execpolicy" }
 codex-extension-api = { path = "ext/extension-api" }
 codex-goal-extension = { path = "ext/goal" }
 codex-guardian = { path = "ext/guardian" }
+codex-image-generation-extension = { path = "ext/image-generation" }
 codex-external-agent-migration = { path = "external-agent-migration" }
 codex-external-agent-sessions = { path = "external-agent-sessions" }
 codex-experimental-api-macros = { path = "codex-experimental-api-macros" }

codex-rs/app-server/Cargo.toml

@@ -54,6 +54,7 @@ codex-backend-client = { workspace = true }
 codex-file-search = { workspace = true }
 codex-chatgpt = { workspace = true }
 codex-login = { workspace = true }
+codex-image-generation-extension = { workspace = true }
 codex-memories-extension = { workspace = true }
 codex-web-search-extension = { workspace = true }
 codex-memories-write = { workspace = true }

codex-rs/app-server/src/extensions.rs

@@ -31,7 +31,8 @@ where
     let mut builder = ExtensionRegistryBuilder::<Config>::with_event_sink(event_sink);
     codex_guardian::install(&mut builder, guardian_agent_spawner);
     codex_memories_extension::install(&mut builder, codex_otel::global());
-    codex_web_search_extension::install(&mut builder, auth_manager);
+    codex_web_search_extension::install(&mut builder, auth_manager.clone());
+    codex_image_generation_extension::install(&mut builder, auth_manager);
     Arc::new(builder.build())
 }
 

codex-rs/core/config.schema.json

@@ -473,6 +473,9 @@
             "image_generation": {
               "type": "boolean"
             },
+            "imagegenext": {
+              "type": "boolean"
+            },
             "in_app_browser": {
               "type": "boolean"
             },
@@ -4564,6 +4567,9 @@
         "image_generation": {
           "type": "boolean"
         },
+        "imagegenext": {
+          "type": "boolean"
+        },
         "in_app_browser": {
           "type": "boolean"
         },

codex-rs/core/src/tools/spec_plan.rs

@@ -85,6 +85,8 @@ use std::sync::Arc;
 use tracing::warn;
 
 const MULTI_AGENT_V2_NAMESPACE_DESCRIPTION: &str = "Tools for spawning and managing sub-agents.";
+const IMAGE_GEN_NAMESPACE: &str = "image_gen";
+const IMAGEGEN_TOOL_NAME: &str = "imagegen";
 
 type PlannedRuntime = Arc<dyn CoreToolRuntime>;
 
@@ -257,7 +259,9 @@ fn hosted_model_tool_specs(context: &CoreToolPlanContext<'_>) -> Vec<ToolSpec> {
     }) {
         specs.push(web_search_tool);
     }
-    if image_generation_tool_enabled(turn_context) {
+    if image_generation_tool_enabled(turn_context)
+        && !standalone_image_generation_available(turn_context, context.extension_tool_executors)
+    {
         specs.push(create_image_generation_tool("png"));
     }
     specs
@@ -316,21 +320,41 @@ fn agent_jobs_worker_tools_enabled(turn_context: &TurnContext) -> bool {
 }
 
 fn image_generation_tool_enabled(turn_context: &TurnContext) -> bool {
+    image_generation_runtime_enabled(turn_context)
+        && turn_context
+            .features
+            .get()
+            .enabled(Feature::ImageGeneration)
+}
+
+fn image_generation_runtime_enabled(turn_context: &TurnContext) -> bool {
     turn_context
         .auth_manager
         .as_deref()
         .is_some_and(AuthManager::current_auth_uses_codex_backend)
         && turn_context.provider.capabilities().image_generation
-        && turn_context
-            .features
-            .get()
-            .enabled(Feature::ImageGeneration)
         && turn_context
             .model_info
             .input_modalities
             .contains(&InputModality::Image)
 }
 
+fn standalone_image_generation_model_visible(turn_context: &TurnContext) -> bool {
+    image_generation_runtime_enabled(turn_context)
+        && turn_context.features.get().enabled(Feature::ImageGenExt)
+        && namespace_tools_enabled(turn_context)
+}
+
+fn standalone_image_generation_available(
+    turn_context: &TurnContext,
+    extension_tools: &[Arc<dyn ToolExecutor<ExtensionToolCall>>],
+) -> bool {
+    standalone_image_generation_model_visible(turn_context)
+        && extension_tools.iter().any(|executor| {
+            executor.tool_name() == ToolName::namespaced(IMAGE_GEN_NAMESPACE, IMAGEGEN_TOOL_NAME)
+        })
+}
+
 fn wait_agent_timeout_options(turn_context: &TurnContext) -> WaitAgentTimeoutOptions {
     if multi_agent_v2_enabled(turn_context) {
         return WaitAgentTimeoutOptions {
@@ -839,6 +863,11 @@ fn append_extension_tool_executors(
 
     for executor in executors.iter().cloned() {
         let tool_name = executor.tool_name();
+        if tool_name == ToolName::namespaced(IMAGE_GEN_NAMESPACE, IMAGEGEN_TOOL_NAME)
+            && !standalone_image_generation_model_visible(turn_context)
+        {
+            continue;
+        }
         if !reserved_tool_names.insert(tool_name.clone()) {
             warn!("Skipping extension tool `{tool_name}`: tool already registered");
             continue;

codex-rs/core/src/tools/spec_plan_tests.rs

@@ -960,6 +960,16 @@ async fn hosted_tools_follow_provider_auth_model_and_config_gates() {
     .await;
     image_generation.assert_visible_contains(&["image_generation"]);
 
+    let extension_flag_without_imagegen_tool = probe(|turn| {
+        use_chatgpt_auth(turn);
+        set_feature(turn, Feature::ImageGeneration, /*enabled*/ true);
+        set_feature(turn, Feature::ImageGenExt, /*enabled*/ true);
+        turn.model_info.input_modalities = vec![InputModality::Image];
+    })
+    .await;
+    extension_flag_without_imagegen_tool.assert_visible_contains(&["image_generation"]);
+    extension_flag_without_imagegen_tool.assert_visible_lacks(&["image_gen"]);
+
     let live_web_search = probe(|turn| {
         set_web_search_mode(turn, WebSearchMode::Live);
         turn.model_info.web_search_tool_type = WebSearchToolType::TextAndImage;

codex-rs/ext/image-generation/BUILD.bazel

@@ -0,0 +1,9 @@
+load("//:defs.bzl", "codex_rust_crate")
+
+codex_rust_crate(
+    name = "image-generation",
+    crate_name = "codex_image_generation_extension",
+    compile_data = [
+        "imagegen_description.md",
+    ],
+)

codex-rs/ext/image-generation/Cargo.toml

@@ -0,0 +1,37 @@
+[package]
+edition.workspace = true
+license.workspace = true
+name = "codex-image-generation-extension"
+version.workspace = true
+
+[lib]
+name = "codex_image_generation_extension"
+path = "src/lib.rs"
+doctest = false
+
+[lints]
+workspace = true
+
+[dependencies]
+async-trait = { workspace = true }
+base64 = { workspace = true }
+codex-api = { workspace = true }
+codex-core = { workspace = true }
+codex-extension-api = { workspace = true }
+codex-features = { workspace = true }
+codex-login = { workspace = true }
+codex-model-provider = { workspace = true }
+codex-model-provider-info = { workspace = true }
+codex-protocol = { workspace = true }
+codex-tools = { workspace = true }
+http = { workspace = true }
+schemars = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+serde_json = { workspace = true }
+tokio = { workspace = true, features = ["fs"] }
+tracing = { workspace = true }
+
+[dev-dependencies]
+pretty_assertions = { workspace = true }
+tempfile = { workspace = true }
+tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }

codex-rs/ext/image-generation/imagegen_description.md

@@ -0,0 +1,11 @@
+The `image_gen.imagegen` tool enables image generation from descriptions and editing of existing images based on specific instructions. Use it when:
+
+- The user requests an image based on a scene description, such as a diagram, portrait, comic, meme, or any other visual.
+- The user wants to modify an attached or previously generated image with specific changes, including adding or removing elements, altering colors, improving quality/resolution, or transforming the style (e.g., cartoon, oil painting).
+
+Guidelines:
+- Set `action` to `generate` when the user asks for a brand new image.
+- Set `action` to `edit` when the user asks to modify an existing image from the conversation history.
+- Directly generate the image without reconfirmation or clarification.
+- After each image generation, do not mention anything related to download. Do not summarize the image. Do not ask followup question. Do not say ANYTHING after you generate an image.
+- Always use this tool for image editing unless the user explicitly requests otherwise. Do not use the `python` tool for image editing unless specifically instructed.

codex-rs/ext/image-generation/src/backend.rs

@@ -0,0 +1,60 @@
+use codex_api::ImageEditRequest;
+use codex_api::ImageGenerationRequest;
+use codex_api::ImageResponse;
+use codex_api::ImagesClient;
+use codex_api::ReqwestTransport;
+use codex_login::default_client::build_reqwest_client;
+use codex_model_provider::SharedModelProvider;
+use http::HeaderMap;
+
+#[derive(Clone)]
+pub(crate) struct CodexImagesBackend {
+    provider: SharedModelProvider,
+}
+
+impl CodexImagesBackend {
+    /// Creates a backend that sends image requests through the active model provider.
+    pub(crate) fn new(provider: SharedModelProvider) -> Self {
+        Self { provider }
+    }
+
+    /// Resolves the provider and auth required for the current image API request.
+    async fn client(&self) -> Result<ImagesClient<ReqwestTransport>, String> {
+        let provider = self
+            .provider
+            .api_provider()
+            .await
+            .map_err(|err| err.to_string())?;
+        let auth = self
+            .provider
+            .api_auth()
+            .await
+            .map_err(|err| err.to_string())?;
+        Ok(ImagesClient::new(
+            ReqwestTransport::new(build_reqwest_client()),
+            provider,
+            auth,
+        ))
+    }
+
+    /// Sends a standalone image generation request through the configured Images client.
+    pub(crate) async fn generate(
+        &self,
+        request: ImageGenerationRequest,
+    ) -> Result<ImageResponse, String> {
+        self.client()
+            .await?
+            .generate(&request, HeaderMap::new())
+            .await
+            .map_err(|err| err.to_string())
+    }
+
+    /// Sends a standalone image edit request through the configured Images client.
+    pub(crate) async fn edit(&self, request: ImageEditRequest) -> Result<ImageResponse, String> {
+        self.client()
+            .await?
+            .edit(&request, HeaderMap::new())
+            .await
+            .map_err(|err| err.to_string())
+    }
+}