Add gpt-image-1 support as alternative to DALL-E 3

- Added AZURE_OPENAI_IMAGE_MODEL setting (dall-e-3 or gpt-image-1)
- Added AZURE_OPENAI_GPT_IMAGE_ENDPOINT for dedicated gpt-image-1 endpoint
- Image model can be configured via environment variable
- Automatic quality/size mapping between models:
  - DALL-E 3: standard/hd quality, 1024x1024/1024x1792/1792x1024 sizes
  - gpt-image-1: low/medium/high/auto quality, 1024x1024/1536x1024/1024x1536/auto sizes
- gpt-image-1 supports larger prompts (more context)
- Added generate_image alias for backwards compatibility
- Existing generate_dalle_image function still works (delegates to selected model)

Author: hunterjam

content-gen/src/backend/agents/__init__.py

@@ -4,8 +4,9 @@
 This package provides utility functions used by the orchestrator.
 """
 
-from backend.agents.image_content_agent import generate_dalle_image
+from backend.agents.image_content_agent import generate_dalle_image, generate_image
 
 __all__ = [
     "generate_dalle_image",
+    "generate_image",
 ]

content-gen/src/backend/agents/image_content_agent.py

@@ -1,8 +1,8 @@
 """
-Image Content Agent - Generates marketing images via DALL-E 3.
+"""Image Content Agent - Generates marketing images via DALL-E 3 or gpt-image-1.
 
-Provides the generate_dalle_image function used by the orchestrator
-to create marketing images using DALL-E 3.
+Provides the generate_image function used by the orchestrator
+to create marketing images using either DALL-E 3 or gpt-image-1.
 """
 
 import logging
@@ -71,8 +71,45 @@ async def generate_dalle_image(
     prompt: str,
     product_description: str = "",
     scene_description: str = "",
-    size: str = "1024x1024",
-    quality: str = "hd"
+    size: str = None,
+    quality: str = None
+) -> dict:
+    """
+    Generate a marketing image using DALL-E 3 or gpt-image-1.
+    
+    The model used is determined by AZURE_OPENAI_IMAGE_MODEL setting.
+    
+    Args:
+        prompt: The main image generation prompt
+        product_description: Auto-generated description of product image (for context)
+        scene_description: Scene/setting description from creative brief
+        size: Image size (model-specific, uses settings default if not provided)
+              - dall-e-3: 1024x1024, 1024x1792, 1792x1024
+              - gpt-image-1: 1024x1024, 1536x1024, 1024x1536, auto
+        quality: Image quality (model-specific, uses settings default if not provided)
+              - dall-e-3: standard, hd
+              - gpt-image-1: low, medium, high, auto
+    
+    Returns:
+        Dictionary containing generated image data and metadata
+    """
+    # Determine which model to use
+    image_model = app_settings.azure_openai.effective_image_model
+    logger.info(f"Using image generation model: {image_model}")
+    
+    # Use appropriate generator based on model
+    if image_model == "gpt-image-1":
+        return await _generate_gpt_image(prompt, product_description, scene_description, size, quality)
+    else:
+        return await _generate_dalle_image(prompt, product_description, scene_description, size, quality)
+
+
+async def _generate_dalle_image(
+    prompt: str,
+    product_description: str = "",
+    scene_description: str = "",
+    size: str = None,
+    quality: str = None
 ) -> dict:
     """
     Generate a marketing image using DALL-E 3.
@@ -89,6 +126,10 @@ async def generate_dalle_image(
     """
     brand = app_settings.brand_guidelines
     
+    # Use defaults from settings if not provided
+    size = size or app_settings.azure_openai.image_size
+    quality = quality or app_settings.azure_openai.image_quality
+    
     # DALL-E 3 has a 4000 character limit for prompts
     # Truncate product descriptions to essential visual info
     truncated_product_desc = _truncate_for_dalle(product_description, max_chars=1500)
@@ -171,12 +212,150 @@ async def generate_dalle_image(
             "image_base64": image_data.b64_json,
             "prompt_used": full_prompt,
             "revised_prompt": getattr(image_data, 'revised_prompt', None),
+            "model": "dall-e-3",
         }
         
     except Exception as e:
         logger.exception(f"Error generating DALL-E image: {e}")
         return {
             "success": False,
             "error": str(e),
-            "prompt_used": full_prompt
+            "prompt_used": full_prompt,
+            "model": "dall-e-3",
         }
+
+
+async def _generate_gpt_image(
+    prompt: str,
+    product_description: str = "",
+    scene_description: str = "",
+    size: str = None,
+    quality: str = None
+) -> dict:
+    """
+    Generate a marketing image using gpt-image-1.
+    
+    gpt-image-1 has different capabilities than DALL-E 3:
+    - Supports larger prompt sizes
+    - Different size options: 1024x1024, 1536x1024, 1024x1536, auto
+    - Different quality options: low, medium, high, auto
+    - May have better instruction following
+    
+    Args:
+        prompt: The main image generation prompt
+        product_description: Auto-generated description of product image (for context)
+        scene_description: Scene/setting description from creative brief
+        size: Image size (1024x1024, 1536x1024, 1024x1536, auto)
+        quality: Image quality (low, medium, high, auto)
+    
+    Returns:
+        Dictionary containing generated image data and metadata
+    """
+    brand = app_settings.brand_guidelines
+    
+    # Use defaults from settings if not provided
+    # Map DALL-E quality settings to gpt-image-1 equivalents if needed
+    size = size or app_settings.azure_openai.image_size
+    quality = quality or app_settings.azure_openai.image_quality
+    
+    # Map DALL-E quality values to gpt-image-1 equivalents
+    quality_mapping = {
+        "standard": "medium",
+        "hd": "high",
+    }
+    quality = quality_mapping.get(quality, quality)
+    
+    # Map DALL-E sizes to gpt-image-1 equivalents if needed
+    size_mapping = {
+        "1024x1792": "1024x1536",  # Closest equivalent
+        "1792x1024": "1536x1024",  # Closest equivalent
+    }
+    size = size_mapping.get(size, size)
+    
+    # gpt-image-1 can handle larger prompts, so we can include more context
+    truncated_product_desc = _truncate_for_dalle(product_description, max_chars=3000)
+    
+    main_prompt = prompt[:2000] if len(prompt) > 2000 else prompt
+    scene_desc = scene_description[:1000] if scene_description and len(scene_description) > 1000 else scene_description
+    
+    # Build the full prompt with product context and brand guidelines
+    full_prompt = f"""
+Create a professional marketing image for retail advertising.
+
+{brand.get_image_generation_prompt()}
+
+PRODUCT CONTEXT:
+{truncated_product_desc if truncated_product_desc else 'No specific product - create a lifestyle/brand image'}
+
+SCENE DESCRIPTION:
+{scene_desc if scene_desc else main_prompt}
+
+MAIN REQUIREMENT:
+{main_prompt}
+
+IMPORTANT GUIDELINES:
+- Create a polished, professional marketing image
+- Suitable for retail advertising and marketing campaigns
+- High visual impact with clean composition
+- Incorporate brand colors where appropriate: {brand.primary_color}, {brand.secondary_color}
+- Modern, aspirational aesthetic
+- Bright, optimistic lighting
+"""
+
+    try:
+        # Get credential
+        client_id = app_settings.base_settings.azure_client_id
+        if client_id:
+            credential = ManagedIdentityCredential(client_id=client_id)
+        else:
+            credential = DefaultAzureCredential()
+        
+        # Get token for Azure OpenAI
+        token = await credential.get_token("https://cognitiveservices.azure.com/.default")
+        
+        # Use gpt-image-1 specific endpoint if configured, otherwise DALL-E endpoint, otherwise main endpoint
+        image_endpoint = (
+            app_settings.azure_openai.gpt_image_endpoint or 
+            app_settings.azure_openai.dalle_endpoint or 
+            app_settings.azure_openai.endpoint
+        )
+        logger.info(f"Using gpt-image-1 endpoint: {image_endpoint}")
+        
+        client = AsyncAzureOpenAI(
+            azure_endpoint=image_endpoint,
+            azure_ad_token=token.token,
+            api_version=app_settings.azure_openai.preview_api_version,
+        )
+        
+        # gpt-image-1 API call
+        response = await client.images.generate(
+            model="gpt-image-1",
+            prompt=full_prompt,
+            size=size,
+            quality=quality,
+            n=1,
+            response_format="b64_json"
+        )
+        
+        image_data = response.data[0]
+        
+        return {
+            "success": True,
+            "image_base64": image_data.b64_json,
+            "prompt_used": full_prompt,
+            "revised_prompt": getattr(image_data, 'revised_prompt', None),
+            "model": "gpt-image-1",
+        }
+        
+    except Exception as e:
+        logger.exception(f"Error generating gpt-image-1 image: {e}")
+        return {
+            "success": False,
+            "error": str(e),
+            "prompt_used": full_prompt,
+            "model": "gpt-image-1",
+        }
+
+
+# Alias for backwards compatibility
+generate_image = generate_dalle_image

content-gen/src/backend/settings.py

@@ -62,7 +62,7 @@ class _ChatHistorySettings(BaseSettings):
 
 
 class _AzureOpenAISettings(BaseSettings):
-    """Azure OpenAI configuration for GPT-5 and DALL-E 3."""
+    """Azure OpenAI configuration for GPT and image generation models."""
     model_config = SettingsConfigDict(
         env_prefix="AZURE_OPENAI_",
         env_file=DOTENV_PATH,
@@ -72,8 +72,16 @@ class _AzureOpenAISettings(BaseSettings):
 
     gpt_model: str = Field(default="gpt-5", alias="AZURE_OPENAI_GPT_MODEL")
     model: str = "gpt-5"
-    dalle_model: str = Field(default="dall-e-3", alias="AZURE_OPENAI_DALLE_MODEL")
+    
+    # Image generation model settings
+    # Supported models: "dall-e-3" or "gpt-image-1"
+    image_model: str = Field(default="dall-e-3", alias="AZURE_OPENAI_IMAGE_MODEL")
+    dalle_model: str = Field(default="dall-e-3", alias="AZURE_OPENAI_DALLE_MODEL")  # Legacy alias
     dalle_endpoint: Optional[str] = Field(default=None, alias="AZURE_OPENAI_DALLE_ENDPOINT")
+    
+    # gpt-image-1 specific endpoint (if different from DALL-E endpoint)
+    gpt_image_endpoint: Optional[str] = Field(default=None, alias="AZURE_OPENAI_GPT_IMAGE_ENDPOINT")
+    
     resource: Optional[str] = None
     endpoint: Optional[str] = None
     temperature: float = 0.7
@@ -84,8 +92,24 @@ class _AzureOpenAISettings(BaseSettings):
     preview_api_version: str = "2024-02-01"
 
     # Image generation settings
+    # For dall-e-3: 1024x1024, 1024x1792, 1792x1024
+    # For gpt-image-1: 1024x1024, 1536x1024, 1024x1536, auto
     image_size: str = "1024x1024"
-    image_quality: str = "hd"
+    image_quality: str = "hd"  # dall-e-3: standard/hd, gpt-image-1: low/medium/high/auto
+    
+    @property
+    def effective_image_model(self) -> str:
+        """Get the effective image model, preferring image_model over dalle_model."""
+        # If image_model is explicitly set and not the default, use it
+        # Otherwise fall back to dalle_model for backwards compatibility
+        return self.image_model if self.image_model else self.dalle_model
+    
+    @property
+    def image_endpoint(self) -> Optional[str]:
+        """Get the appropriate endpoint for the configured image model."""
+        if self.effective_image_model == "gpt-image-1" and self.gpt_image_endpoint:
+            return self.gpt_image_endpoint
+        return self.dalle_endpoint
 
     @model_validator(mode="after")
     def ensure_endpoint(self) -> Self:

content-gen/src/frontend-server/frontend-deploy.zip

@@ -0,0 +1,82 @@
+"""
+Generate Solution Architecture Diagram for Content Generation Accelerator
+"""
+from diagrams import Diagram, Cluster, Edge
+from diagrams.azure.compute import ContainerInstances, AppServices, ContainerRegistries
+from diagrams.azure.database import CosmosDb, BlobStorage
+from diagrams.azure.ml import CognitiveServices, AzureOpenAI
+from diagrams.azure.web import AppServices as WebApp
+from diagrams.azure.network import VirtualNetworks, PrivateEndpoint
+from diagrams.programming.framework import React
+from diagrams.programming.language import Python
+from diagrams.generic.storage import Storage
+from diagrams.onprem.client import User
+
+# Graph attributes for dark theme matching the reference image
+graph_attr = {
+    "bgcolor": "#1a2634",
+    "fontcolor": "white",
+    "fontsize": "14",
+    "pad": "0.5",
+    "splines": "ortho",
+    "nodesep": "1.0",
+    "ranksep": "1.5",
+}
+
+node_attr = {
+    "fontcolor": "white",
+    "fontsize": "11",
+}
+
+edge_attr = {
+    "color": "#4a9eff",
+    "style": "bold",
+}
+
+with Diagram(
+    "Content Generation Solution Architecture",
+    filename="/home/jahunte/content-generation-solution-accelerator/docs/images/readme/solution_architecture",
+    outformat="png",
+    show=False,
+    direction="LR",
+    graph_attr=graph_attr,
+    node_attr=node_attr,
+    edge_attr=edge_attr,
+):
+    user = User("User")
+    
+    with Cluster("Azure Cloud", graph_attr={"bgcolor": "#243447", "fontcolor": "white"}):
+        
+        with Cluster("Frontend Tier"):
+            app_service = AppServices("App Service\n(Node.js)")
+            
+        with Cluster("Container Registry"):
+            acr = ContainerRegistries("Azure Container\nRegistry")
+        
+        with Cluster("Backend Tier (VNet Integrated)"):
+            aci = ContainerInstances("Container Instance\n(Python/Quart)")
+        
+        with Cluster("AI Services"):
+            aoai_gpt = CognitiveServices("Azure OpenAI\n(GPT-5.1)")
+            aoai_dalle = CognitiveServices("Azure OpenAI\n(DALL-E 3)")
+        
+        with Cluster("Data Storage"):
+            cosmos = CosmosDb("Cosmos DB\n(Briefs, Products,\nChat History)")
+            blob = BlobStorage("Blob Storage\n(Product Images,\nGenerated Content)")
+    
+    # User flow
+    user >> Edge(label="HTTPS") >> app_service
+    
+    # App Service to Backend
+    app_service >> Edge(label="API Proxy\n(Private VNet)") >> aci
+    
+    # Container Registry
+    acr >> Edge(label="Pull Image") >> aci
+    
+    # Backend to AI Services
+    aci >> Edge(label="Content\nGeneration") >> aoai_gpt
+    aci >> Edge(label="Image\nGeneration") >> aoai_dalle
+    
+    # Backend to Data
+    aci >> Edge(label="CRUD\nOperations") >> cosmos
+    aci >> Edge(label="Store/Retrieve\nImages") >> blob