Add feature-gated standalone image generation extension (#24723)

## Why Add a standalone image generation path that can be exercised independently of hosted Responses image generation, while retaining the hosted tool as fallback unless the extension is actually available to the model. ## What changed - Added the `codex-image-generation-extension` crate with standalone generate/edit execution, prior-image selection for edits, model-visible image output, and local generated-image persistence. - Installed the extension in app-server behind the disabled-by-default `imagegenext` feature and backend eligibility checks. - Updated core tool planning so eligible `image_gen.imagegen` exposure replaces hosted `image_generation`, while unavailable configurations retain hosted fallback. - Added coverage for extension behavior, edit history reuse, feature gating, auth eligibility, and hosted-tool replacement. - The extension is installed through app-server only in this PR; other execution paths retain hosted image generation because hosted replacement occurs only when the standalone executor is actually registered and model-visible. - The initial extension contract intentionally fixes the image model to `gpt-image-2` and uses automatic image parameters. - Native generated-image history/card parity and rollout persistence cleanup are intentionally deferred follow-up work. ## Validation - `just test -p codex-image-generation-extension` - `just test -p codex-features` - `just test -p codex-core hosted_tools_follow_provider_auth_model_and_config_gates` - `just test -p codex-app-server` - `just fix -p codex-image-generation-extension -p codex-features -p codex-core -p codex-app-server` - `just fmt` - `just bazel-lock-update` - `just bazel-lock-check` --------- Co-authored-by: jif-oai <jif@openai.com>
2026-11-09 08:40:33 +00:00 · 2026-05-28 11:44:55 -07:00
1 parent 462deb0426
commit ecb41fcb64
@@ -0,0 +1,99 @@
+use std::path::PathBuf;
+use std::sync::Arc;
+
+use codex_core::config::Config;
+use codex_extension_api::ConfigContributor;
+use codex_extension_api::ExtensionData;
+use codex_extension_api::ExtensionRegistryBuilder;
+use codex_extension_api::ThreadLifecycleContributor;
+use codex_extension_api::ThreadStartInput;
+use codex_extension_api::ToolCall;
+use codex_extension_api::ToolContributor;
+use codex_extension_api::ToolExecutor;
+use codex_features::Feature;
+use codex_login::AuthManager;
+use codex_model_provider::create_model_provider;
+use codex_model_provider_info::ModelProviderInfo;
+
+use crate::backend::CodexImagesBackend;
+use crate::tool::ImageGenerationTool;
+use crate::tool::generated_image_output_dir;
+
+#[derive(Clone)]
+struct ImageGenerationExtension {
+    auth_manager: Arc<AuthManager>,
+}
+
+#[derive(Clone)]
+struct ImageGenerationExtensionConfig {
+    enabled: bool,
+    provider: ModelProviderInfo,
+    codex_home: PathBuf,
+}
+
+impl From<&Config> for ImageGenerationExtensionConfig {
+    /// Resolves whether standalone image generation should be available for a thread.
+    fn from(config: &Config) -> Self {
+        Self {
+            enabled: config.features.enabled(Feature::ImageGenExt)
+                && config.model_provider.is_openai(),
+            provider: config.model_provider.clone(),
+            codex_home: config.codex_home.to_path_buf(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl ThreadLifecycleContributor<Config> for ImageGenerationExtension {
+    /// Seeds image-generation availability when a thread begins.
+    async fn on_thread_start(&self, input: ThreadStartInput<'_, Config>) {
+        input
+            .thread_store
+            .insert(ImageGenerationExtensionConfig::from(input.config));
+    }
+}
+
+impl ConfigContributor<Config> for ImageGenerationExtension {
+    /// Refreshes image-generation availability after thread configuration changes.
+    fn on_config_changed(
+        &self,
+        _session_store: &ExtensionData,
+        thread_store: &ExtensionData,
+        _previous_config: &Config,
+        new_config: &Config,
+    ) {
+        thread_store.insert(ImageGenerationExtensionConfig::from(new_config));
+    }
+}
+
+impl ToolContributor for ImageGenerationExtension {
+    /// Creates the image-generation tool exposed by this installed extension.
+    fn tools(
+        &self,
+        _session_store: &ExtensionData,
+        thread_store: &ExtensionData,
+    ) -> Vec<Arc<dyn ToolExecutor<ToolCall>>> {
+        let Some(config) = thread_store.get::<ImageGenerationExtensionConfig>() else {
+            return Vec::new();
+        };
+        if !config.enabled || !self.auth_manager.current_auth_uses_codex_backend() {
+            return Vec::new();
+        }
+
+        vec![Arc::new(ImageGenerationTool::new(
+            CodexImagesBackend::new(create_model_provider(
+                config.provider.clone(),
+                Some(self.auth_manager.clone()),
+            )),
+            generated_image_output_dir(&config.codex_home, thread_store.level_id()),
+        ))]
+    }
+}
+
+/// Installs the feature-gated standalone image-generation extension contributors.
+pub fn install(registry: &mut ExtensionRegistryBuilder<Config>, auth_manager: Arc<AuthManager>) {
+    let extension = Arc::new(ImageGenerationExtension { auth_manager });
+    registry.thread_lifecycle_contributor(extension.clone());
+    registry.config_contributor(extension.clone());
+    registry.tool_contributor(extension);
+}