refactor(media): remove Codex image generation (#6742) (#6746)

* refactor(media): remove Codex image generation

* fix(media): preserve HyperFrames video default

* test(media): keep Vela coverage image-only

* fix(media): persist Home image model selection

(cherry picked from commit a723012)

Co-authored-by: Caprika <56862773+alchemistklk@users.noreply.github.com>

Author: open-design-release-bot[bot]

apps/daemon/src/media/config.ts

@@ -39,9 +39,7 @@ import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { MEDIA_PROVIDERS } from './models.js';
-import { agentCliEnvForAgent, appConfigDir, readAppConfig } from '../app-config.js';
 import { expandHomePrefix } from '../home-expansion.js';
-import { spawnEnvForAgent } from '../runtimes/env.js';
 import { resolveXAIBearer } from '../integrations/xai-credentials.js';
 import { isSandboxModeEnabled } from '../sandbox-mode.js';
 
@@ -51,7 +49,6 @@ type ProviderMap = Record<string, ProviderEntry>;
 type ModelAliasMap = Record<string, string>;
 type JsonRecord = Record<string, unknown>;
 type OAuthCredential = { apiKey: string; source: string };
-export type CodexSubscriptionStatus = { available: boolean };
 
 // Single env var carries the full alias map as JSON so we don't have
 // to dynamically lift `OD_MEDIA_MODEL_ALIAS_<id>=value` into a record
@@ -292,41 +289,6 @@ async function readJsonIfPresent(file: string): Promise<JsonRecord | null> {
   }
 }
 
-export async function resolveCodexImagegenEnv(projectRoot?: string): Promise<NodeJS.ProcessEnv> {
-  if (projectRoot) {
-    const dataDir = appConfigDir(projectRoot);
-    try {
-      const appConfig = await readAppConfig(dataDir);
-      const configuredEnv = agentCliEnvForAgent(appConfig.agentCliEnv, 'codex');
-      return spawnEnvForAgent('codex', process.env, configuredEnv);
-    } catch {
-      return spawnEnvForAgent('codex', process.env);
-    }
-  }
-  return spawnEnvForAgent('codex', process.env);
-}
-
-function codexHomeFromEnv(env: NodeJS.ProcessEnv): string {
-  const home = env.CODEX_HOME?.trim() || path.join(os.homedir(), '.codex');
-  const resolvedHome = home.startsWith('~/')
-    ? path.join(os.homedir(), home.slice(2))
-    : home;
-  return path.resolve(resolvedHome);
-}
-
-export async function resolveCodexSubscriptionStatus(
-  projectRoot?: string,
-): Promise<CodexSubscriptionStatus> {
-  if (isSandboxModeEnabled(process.env)) return { available: false };
-  const env = await resolveCodexImagegenEnv(projectRoot);
-  const codexAuth = await readJsonIfPresent(
-    path.join(codexHomeFromEnv(env), 'auth.json'),
-  );
-  const authMode = readNestedString(codexAuth, ['auth_mode']);
-  const accessToken = readNestedString(codexAuth, ['tokens', 'access_token']);
-  return { available: authMode === 'chatgpt' || Boolean(accessToken) };
-}
-
 function apiKeyFromCodexAuth(data: unknown): string {
   return readNestedString(data, ['OPENAI_API_KEY']);
 }

apps/daemon/src/media/index.ts

@@ -20,7 +20,6 @@
 //                              plus text-to-speech via /v1/audio/speech,
 //                              with auto-detection for Azure OpenAI
 //                              deployments based on the configured base URL
-//   * provider 'codex'      → local Codex CLI subscription imagegen
 //   * provider 'volcengine' → Volcengine Ark async tasks API for
 //                              Doubao Seedance 2.0 (video) and Seedream
 //                              (image)
@@ -51,7 +50,7 @@
 // so the CLI can exit non-zero and the agent can't silently narrate the
 // placeholder as the final result.
 
-import { mkdir, mkdtemp, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { mkdir, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { execFile as execFileCb, spawn } from 'node:child_process';
 import os from 'node:os';
 import path from 'node:path';
@@ -69,10 +68,7 @@ import {
   modelsForSurface,
 } from './models.js';
 import { assertAndFetchExternalAsset } from '../connectionTest.js';
-import { normalizeCodexConfigFile } from '../codex-config-normalize.js';
 import {
-  resolveCodexImagegenEnv,
-  resolveCodexSubscriptionStatus,
   resolveModelAlias,
   resolveProviderConfig,
 } from './config.js';
@@ -81,7 +77,6 @@ import {
   type ImageGenerationRequestSummary,
 } from './image-generation-retry.js';
 import { renderVelaImage, renderVelaVideo } from './vela.js';
-import { codexNeedsDangerFullAccessSandbox } from '../runtimes/defs/codex.js';
 import {
   ensureProject,
   kindFor,
@@ -180,8 +175,6 @@ const NANOBANANA_DEFAULT_MODEL = 'gemini-3.1-flash-image-preview';
 const NANOBANANA_DEFAULT_IMAGE_SIZE = '1K';
 const IMAGEROUTER_DEFAULT_BASE_URL = 'https://api.imagerouter.io/v1/openai';
 const CUSTOM_IMAGE_MODEL_ID = 'custom-image';
-const CODEX_IMAGE_ORCHESTRATOR_MODEL = 'gpt-5.5';
-
 const DEFAULT_OUTPUT_BY_SURFACE = {
   image: 'image.png',
   video: 'video.mp4',
@@ -570,17 +563,6 @@ export async function generateMedia(args: {
     ctx,
     customImageCredentials,
   );
-  const codexSubscriptionModel =
-    !customImageOverride
-    && surface === 'image'
-    && def.provider === 'openai'
-    && ctx.wireModel === ctx.model
-      ? codexSubscriptionEquivalent(ctx.model)
-      : null;
-  const useCodexSubscription =
-    codexSubscriptionModel
-      ? (await resolveCodexSubscriptionStatus(projectRoot)).available
-      : false;
   try {
     if (
       def.provider === 'openai'
@@ -592,18 +574,6 @@ export async function generateMedia(args: {
       bytes = result.bytes;
       providerNote = result.providerNote;
       suggestedExt = result.suggestedExt;
-    } else if (codexSubscriptionModel && useCodexSubscription) {
-      providerId = 'codex';
-      const result = await renderCodexImage({
-        ...ctx,
-        model: codexSubscriptionModel.id,
-        wireModel: codexSubscriptionModel.id,
-        modelDef: codexSubscriptionModel,
-        provider: findProvider('codex'),
-      });
-      bytes = result.bytes;
-      providerNote = result.providerNote;
-      suggestedExt = result.suggestedExt;
     } else if (def.provider === 'vela' && surface === 'image') {
       const result = await renderVelaImage(ctx);
       bytes = result.bytes;
@@ -622,11 +592,6 @@ export async function generateMedia(args: {
       bytes = result.bytes;
       providerNote = result.providerNote;
       suggestedExt = result.suggestedExt;
-    } else if (def.provider === 'codex' && surface === 'image') {
-      const result = await renderCodexImage(ctx);
-      bytes = result.bytes;
-      providerNote = result.providerNote;
-      suggestedExt = result.suggestedExt;
     } else if (
       def.provider === 'openai'
       && surface === 'audio'
@@ -928,9 +893,7 @@ function withMediaRequestInit(
 }
 
 const OPENAI_IMAGE_NO_CREDENTIAL_MESSAGE =
-  'no OpenAI credential - configure an API key in Settings or set OPENAI_API_KEY. ' +
-  "If you're signed into Codex with a ChatGPT subscription, use the codex-gpt-image-2 model instead; " +
-  'it renders through your local Codex login and needs no OpenAI API key.';
+  'no OpenAI credential - configure an API key in Settings or set OPENAI_API_KEY.';
 
 async function renderOpenAIImage(ctx: MediaContext, credentials: ProviderConfig): Promise<RenderResult> {
   if (!credentials.apiKey) {
@@ -1017,180 +980,6 @@ async function renderOpenAIImage(ctx: MediaContext, credentials: ProviderConfig)
   };
 }
 
-function codexGeneratedImagesRoot(env: NodeJS.ProcessEnv = process.env): string {
-  const home = env.CODEX_HOME?.trim() || path.join(os.homedir(), '.codex');
-  const resolvedHome = home.startsWith('~/') ? path.join(os.homedir(), home.slice(2)) : home;
-  return path.resolve(resolvedHome, 'generated_images');
-}
-
-function codexImageModelLabel(model: string): string {
-  return model.startsWith('codex-') ? model.slice('codex-'.length) : model;
-}
-
-function codexImagePrompt(ctx: MediaContext): string {
-  const prompt = ctx.prompt || 'A high-quality reference image.';
-  const aspect = ctx.aspect ? `\nAspect ratio: ${ctx.aspect}.` : '';
-  const prefix = ctx.imageRefs.length > 0
-    ? '$imagegen Edit the attached reference image:'
-    : '$imagegen';
-  return `${prefix} ${prompt}${aspect}`;
-}
-
-function codexImagegenArgs(ctx: MediaContext, generatedRoot: string, env: NodeJS.ProcessEnv): string[] {
-  const sandbox = codexNeedsDangerFullAccessSandbox()
-    ? ['--sandbox', 'danger-full-access']
-    : ['--sandbox', 'workspace-write', '-c', 'sandbox_workspace_write.network_access=true'];
-  const model = env.OD_CODEX_IMAGEGEN_MODEL?.trim() || CODEX_IMAGE_ORCHESTRATOR_MODEL;
-  const args = [
-    'exec',
-    '--json',
-    '--skip-git-repo-check',
-    ...sandbox,
-    '-C',
-    ctx.projectRoot,
-    '--add-dir',
-    generatedRoot,
-    '--model',
-    model,
-  ];
-  if (env.OD_CODEX_DISABLE_PLUGINS === '1') args.push('--disable', 'plugins');
-  for (const ref of ctx.imageRefs) args.push('-i', ref.abs);
-  return args;
-}
-
-function parseCodexThreadId(stdout: string): string {
-  for (const line of stdout.split(/\r?\n/)) {
-    if (!line.trim()) continue;
-    try {
-      const obj = JSON.parse(line) as { thread_id?: unknown; type?: unknown };
-      if (obj.type === 'thread.started' && typeof obj.thread_id === 'string') {
-        return obj.thread_id;
-      }
-    } catch {
-      // Non-JSON progress belongs in stdout on some CLI builds; ignore it.
-    }
-  }
-  throw new Error('codex imagegen did not emit a thread.started thread_id');
-}
-
-function summarizeCodexImagegenStdout(stdout: string): string {
-  const messages: string[] = [];
-  for (const line of stdout.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed) continue;
-    try {
-      const obj = JSON.parse(trimmed) as { item?: { text?: unknown }; text?: unknown };
-      const text = typeof obj.item?.text === 'string'
-        ? obj.item.text
-        : typeof obj.text === 'string'
-          ? obj.text
-          : '';
-      if (text.trim()) messages.push(text.trim());
-    } catch {
-      messages.push(trimmed);
-    }
-  }
-  return truncate(messages.join('\n'), 500);
-}
-
-function codexImagegenMissingOutputError(threadDir: string, stdout: string): Error {
-  const summary = summarizeCodexImagegenStdout(stdout);
-  const suffix = summary ? ` Codex stdout summary: ${summary}` : '';
-  if (/\bpreview[- ]only\b|without saving|without writing|does not write|no file|bez przenoszenia/i.test(summary)) {
-    return new Error(
-      `Codex imagegen completed in preview-only mode and did not write an image file under ${threadDir}. Use an API-backed image provider or a Codex CLI build that writes generated_images output.${suffix}`,
-    );
-  }
-  return new Error(
-    `Codex imagegen completed but did not write an ig_* or call_* image under ${threadDir}. Use an API-backed image provider or a Codex CLI build that writes generated_images output.${suffix}`,
-  );
-}
-
-async function readCodexGeneratedImage(
-  generatedRoot: string,
-  threadId: string,
-  stdout: string,
-): Promise<Buffer> {
-  const threadDir = path.join(generatedRoot, threadId);
-  let entries: string[];
-  try {
-    entries = await readdir(threadDir);
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException)?.code === 'ENOENT') {
-      throw codexImagegenMissingOutputError(threadDir, stdout);
-    }
-    throw err;
-  }
-  const supportedImagePattern = /\.(?:png|jpe?g|webp)$/i;
-  const match = entries
-    .filter((name) => /^ig_/i.test(name) && supportedImagePattern.test(name))
-    .sort()[0]
-    ?? entries
-      .filter((name) => /^call_/i.test(name) && supportedImagePattern.test(name))
-      .sort()[0];
-  if (!match) {
-    throw codexImagegenMissingOutputError(threadDir, stdout);
-  }
-  const imagePath = path.join(threadDir, match);
-  const bytes = await readFile(imagePath);
-  if (process.env.OD_CODEX_KEEP_GENERATED_IMAGES !== '1') {
-    await rm(threadDir, { recursive: true, force: true });
-  }
-  return bytes;
-}
-
-async function runCodexImagegen(
-  ctx: MediaContext,
-  generatedRoot: string,
-  env: NodeJS.ProcessEnv,
-): Promise<{ stderr: string; stdout: string }> {
-  const codexBin = env.CODEX_BIN?.trim() || 'codex';
-  const child = spawn(codexBin, codexImagegenArgs(ctx, generatedRoot, env), {
-    cwd: ctx.projectRoot,
-    env,
-    stdio: ['pipe', 'pipe', 'pipe'],
-  });
-  const stdout: Buffer[] = [];
-  const stderr: Buffer[] = [];
-  const timeoutMs = Number(process.env.OD_CODEX_IMAGEGEN_TIMEOUT_MS || 300_000);
-  return await new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      child.kill('SIGTERM');
-      reject(new Error(`codex imagegen timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-    child.stdout.on('data', (chunk) => stdout.push(Buffer.from(chunk)));
-    child.stderr.on('data', (chunk) => stderr.push(Buffer.from(chunk)));
-    child.on('error', (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-    child.on('close', (code) => {
-      clearTimeout(timer);
-      const out = Buffer.concat(stdout).toString('utf8');
-      const err = Buffer.concat(stderr).toString('utf8');
-      if (code !== 0) reject(new Error(`codex imagegen exited ${code}: ${truncate(err || out, 1000)}`));
-      else resolve({ stdout: out, stderr: err });
-    });
-    child.stdin.end(codexImagePrompt(ctx));
-  });
-}
-
-async function renderCodexImage(ctx: MediaContext): Promise<RenderResult> {
-  const env = await resolveCodexImagegenEnv(ctx.projectRoot);
-  await normalizeCodexConfigFile(env);
-  const generatedRoot = codexGeneratedImagesRoot(env);
-  await mkdir(generatedRoot, { recursive: true });
-  const { stdout } = await runCodexImagegen(ctx, generatedRoot, env);
-  const threadId = parseCodexThreadId(stdout);
-  const bytes = await readCodexGeneratedImage(generatedRoot, threadId, stdout);
-  const imageModel = codexImageModelLabel(ctx.model);
-  return {
-    bytes,
-    providerNote: `codex/${imageModel} via ${env.OD_CODEX_IMAGEGEN_MODEL?.trim() || CODEX_IMAGE_ORCHESTRATOR_MODEL} · ${ctx.aspect} · ${bytes.length} bytes`,
-    suggestedExt: sniffImageExt(bytes),
-  };
-}
-
 async function renderImageRouterImage(ctx: MediaContext, credentials: ProviderConfig): Promise<RenderResult> {
   if (!credentials.apiKey) {
     throw new Error(
@@ -1333,11 +1122,6 @@ function customImageOverridesOpenAIModel(
   return model === ctx.model || model === ctx.wireModel;
 }
 
-function codexSubscriptionEquivalent(modelId: string): MediaModel | null {
-  const candidate = findMediaModel(`codex-${modelId}`);
-  return candidate?.provider === 'codex' ? candidate : null;
-}
-
 async function parseOpenAICompatibleJson(resp: Response, providerTag: string): Promise<any> {
   const text = await resp.text();
   if (!resp.ok) {

apps/daemon/src/media/models.ts

@@ -32,7 +32,6 @@ export type MediaModel = {
 
 export const MEDIA_PROVIDERS: MediaProvider[] = [
   { id: 'openai', label: 'OpenAI', hint: 'gpt-image-2 / dall-e-3', integrated: true, defaultBaseUrl: 'https://api.openai.com/v1' },
-  { id: 'codex', label: 'Codex Subscription', hint: 'gpt-image-2 via local Codex CLI login', integrated: true, credentialsRequired: false, docsUrl: 'https://developers.openai.com/codex' },
   { id: 'vela', label: 'Open Design Cloud', hint: 'Managed image and video generation through Vela', integrated: true, credentialsRequired: false, settingsVisible: false },
   { id: 'volcengine', label: 'Volcengine Ark (Doubao)', hint: 'Seedance 2.0 / Seedream', integrated: true, defaultBaseUrl: 'https://ark.cn-beijing.volces.com/api/v3' },
   { id: 'grok', label: 'xAI Grok Imagine', hint: 'grok-imagine — image + video with native audio', integrated: true, defaultBaseUrl: 'https://api.x.ai/v1' },
@@ -86,19 +85,17 @@ export const MEDIA_PROVIDERS: MediaProvider[] = [
 ];
 
 export const IMAGE_MODELS: MediaModel[] = [
-  { id: 'vela/gpt-image-2', label: 'gpt-image-2 (Cloud)', hint: 'Open Design Cloud · managed image generation and editing', provider: 'vela', caps: ['t2i', 'i2i'] },
+  { id: 'vela/gpt-image-2', label: 'gpt-image-2 (Cloud)', hint: 'Open Design Cloud · managed image generation and editing', provider: 'vela', caps: ['t2i', 'i2i'], default: true },
   { id: 'vela/nano-banana-2', label: 'nano-banana-2 (Cloud)', hint: 'Open Design Cloud · managed image generation and editing', provider: 'vela', caps: ['t2i', 'i2i'] },
   { id: 'vela/nano-banana-2-lite', label: 'nano-banana-2-lite (Cloud)', hint: 'Open Design Cloud · fast managed image generation and editing', provider: 'vela', caps: ['t2i', 'i2i'] },
   { id: 'vela/seedream-5.0', label: 'seedream-5.0 (Cloud)', hint: 'Open Design Cloud · managed image generation and editing', provider: 'vela', caps: ['t2i', 'i2i'] },
   { id: 'vela/seedream-5.0-pro', label: 'seedream-5.0-pro (Cloud)', hint: 'Open Design Cloud · high-quality managed image generation and editing', provider: 'vela', caps: ['t2i', 'i2i'] },
-  { id: 'gpt-image-2', label: 'gpt-image-2', hint: 'OpenAI · 4K, native multimodal', provider: 'openai', caps: ['t2i', 'i2i', 'inpaint'], default: true },
+  { id: 'gpt-image-2', label: 'gpt-image-2', hint: 'OpenAI · 4K, native multimodal', provider: 'openai', caps: ['t2i', 'i2i', 'inpaint'] },
   { id: 'gpt-image-1.5', label: 'gpt-image-1.5', hint: 'OpenAI · 4× faster than gpt-image-1', provider: 'openai', caps: ['t2i', 'i2i', 'inpaint'] },
   { id: 'gpt-image-1', label: 'gpt-image-1', hint: 'OpenAI · ChatGPT native', provider: 'openai', caps: ['t2i', 'i2i', 'inpaint'] },
   { id: 'gpt-image-1-mini', label: 'gpt-image-1-mini', hint: 'OpenAI · low-cost variant', provider: 'openai', caps: ['t2i', 'i2i'] },
   { id: 'dall-e-3', label: 'dall-e-3', hint: 'OpenAI · classic', provider: 'openai', caps: ['t2i'] },
   { id: 'dall-e-2', label: 'dall-e-2', hint: 'OpenAI · legacy', provider: 'openai', caps: ['t2i'] },
-  { id: 'codex-gpt-image-2', label: 'gpt-image-2 (Codex)', hint: 'Codex Subscription · local CLI imagegen', provider: 'codex', caps: ['t2i', 'i2i'] },
-
   { id: 'doubao-seedream-3-0-t2i-250415', label: 'seedream-3.0', hint: 'ByteDance · Doubao image', provider: 'volcengine', caps: ['t2i'] },
   { id: 'doubao-seededit-3-0-i2i-250628', label: 'seededit-3.0', hint: 'ByteDance · image edit', provider: 'volcengine', caps: ['i2i'] },
 
@@ -234,6 +231,8 @@ const MEDIA_MODEL_ALIASES: Readonly<Record<string, string>> = {
   'nano-banana': 'vela/nano-banana-2',
   'nano-banana-2': 'vela/nano-banana-2',
   'nano-banana-2-lite': 'vela/nano-banana-2-lite',
+  // Preserve existing project metadata while removing the Codex renderer.
+  'codex-gpt-image-2': 'vela/gpt-image-2',
 };
 
 export function canonicalMediaModelId(id: string): string {