Update app.py

app.py

@@ -5,8 +5,6 @@ from typing import List, Dict, Optional, Tuple
 
 import gradio as gr
 from openai import OpenAI
-from google import genai
-from google.genai import types
 from PIL import Image
 
 # -------------------------------------------------------------------
@@ -15,16 +13,23 @@ from PIL import Image
 
 APP_TITLE = "ZEN AI Co. Module 2 | Agent Assembler"
 APP_DESCRIPTION = """
-Multi-model agent that can chat, draft reports, generate infographic briefs,
-and create images using GPT-5, Gemini 2.5 Pro, Gemini 3 Pro, Nano Banana,
-Nano Banana Pro, and DALL·E 3.
+OpenAI-only teaching rig for building AI model UIs.
+
+• Uses GPT-5 for text generation.
+• Uses DALL·E 3 for image generation.
+• Lets you edit the system prompt, role, tone, and output format.
+• Provides sliders and controls to experiment with sampling and behavior.
+• Includes starter prompts to show different use cases (chat, reports, infographics, visuals).
 """
 
-DEFAULT_TEMPERATURE = 0.6
+DEFAULT_TEMPERATURE = 0.7
+DEFAULT_TOP_P = 1.0
 DEFAULT_MAX_TOKENS = 1024
+DEFAULT_PRESENCE_PENALTY = 0.0
+DEFAULT_FREQUENCY_PENALTY = 0.0
 
 # -------------------------------------------------------------------
-# API Clients
+# OpenAI Client Helper
 # -------------------------------------------------------------------
 
 def get_openai_client(key_override: Optional[str] = None) -> OpenAI:
@@ -36,75 +41,61 @@ def get_openai_client(key_override: Optional[str] = None) -> OpenAI:
     api_key = (key_override or "").strip() or os.getenv("OPENAI_API_KEY", "").strip()
     if not api_key:
         raise ValueError(
-            "OpenAI API key missing. "
-            "Set OPENAI_API_KEY env var or paste it into the sidebar."
+            "OpenAI API key missing. Set OPENAI_API_KEY env var "
+            "or paste it into the sidebar."
         )
     return OpenAI(api_key=api_key)
 
-
-def get_google_client(key_override: Optional[str] = None) -> genai.Client:
-    """
-    Returns a Google GenAI client using either:
-    1) key from the UI override, or
-    2) GOOGLE_API_KEY environment variable.
-    """
-    api_key = (key_override or "").strip() or os.getenv("GOOGLE_API_KEY", "").strip()
-    if not api_key:
-        raise ValueError(
-            "Google Gemini API key missing. "
-            "Set GOOGLE_API_KEY env var or paste it into the sidebar."
-        )
-    return genai.Client(api_key=api_key)
-
 # -------------------------------------------------------------------
 # Prompt & Style Helpers
 # -------------------------------------------------------------------
 
 def build_system_instructions(
-    base_instructions: str,
-    theme: str,
+    user_system_prompt: str,
+    assistant_role: str,
     output_mode: str,
     tone: str,
 ) -> str:
     """
-    Builds a system prompt that reflects theme, output mode, and tone.
+    Build a system prompt string combining user-provided base instructions
+    with role + format + tone metadata.
     """
-    theme_map = {
-        "ZEN Dark": "Use a sleek, modern, slightly futuristic tone. Be concise but high signal.",
-        "ZEN Light": "Use a clear, friendly, educational tone suitable for learners of all ages.",
-        "Research / Technical": "Write like a senior research engineer: rigorous, structured, and explicit.",
-        "Youth AI Pioneer": (
-            "Explain things in simple, motivating language for ages 11–18, "
-            "but keep the concepts accurate and serious."
-        ),
+    role_map = {
+        "General Assistant": "Behave as a highly capable, calm general-purpose AI assistant.",
+        "Teacher / Instructor": "Behave as a patient educator. Explain concepts step-by-step and check for understanding.",
+        "Engineer / Architect": "Behave as a senior engineer and systems architect. Be explicit, structured, and precise.",
+        "Storyteller / Creative": "Behave as a creative storyteller. Use vivid but clear language while staying coherent.",
     }
 
     output_map = {
-        "Standard Chat": "Respond like a normal assistant, but keep paragraphs tight and skimmable.",
+        "Standard Chat": "Respond like a normal chat, with paragraphs kept short and skimmable.",
         "Executive Report": (
-            "Respond as a structured executive brief with headings, bullets, "
-            "and 1–2 sentence insights per section."
+            "Respond as an executive brief with headings, short sections, and bullet points "
+            "highlighting key decisions and risks."
         ),
         "Infographic Outline": (
-            "Respond as a bullet-point infographic blueprint with short, punchy lines and clear sections."
+            "Respond as an infographic blueprint with section titles and short bullet lines. "
+            "Focus on clarity and label-friendly phrases."
+        ),
+        "Bullet Summary": (
+            "Respond as a tight bullet summary (5–10 bullets) capturing only the most important details."
         ),
-        "Bullet Summary": "Respond as a compact bullet summary with 5–10 bullets max.",
     }
 
     tone_map = {
-        "Neutral": "Keep style neutral and globally understandable.",
-        "Bold / Visionary": "Lean into visionary, high-energy language while staying precise and concrete.",
-        "Minimalist": "Be extremely concise; prioritize clarity over flourish.",
+        "Neutral": "Keep the tone neutral and globally understandable.",
+        "Bold / Visionary": "Use confident, forward-looking language, but stay concrete and honest.",
+        "Minimalist": "Be extremely concise. Prefer fewer words and high information density.",
     }
 
     parts = [
-        base_instructions.strip(),
+        (user_system_prompt or "").strip(),
         "",
-        f"STYLE THEME: {theme_map.get(theme, '')}",
+        f"ASSISTANT ROLE: {role_map.get(assistant_role, '')}",
         f"OUTPUT MODE: {output_map.get(output_mode, '')}",
         f"TONE: {tone_map.get(tone, '')}",
         "",
-        "Always format results cleanly in Markdown.",
+        "Always output clean Markdown.",
     ]
     return "\n".join(p for p in parts if p.strip())
 
@@ -115,123 +106,53 @@ def history_to_openai_messages(
     system_instructions: str,
 ) -> List[Dict[str, str]]:
     """
-    Convert Chatbot-style history (list of {role, content}) into an
-    OpenAI messages list with an added system message and new user query.
+    Convert Chatbot-style history (list of {role, content}) into an OpenAI
+    messages list with an added system message and new user query.
     """
     messages: List[Dict[str, str]] = []
     if system_instructions:
         messages.append({"role": "system", "content": system_instructions})
 
-    # Reuse history directly
-    for msg in history_messages:
-        if msg.get("role") in ("user", "assistant", "system"):
-            messages.append({"role": msg["role"], "content": msg["content"]})
-
-    messages.append({"role": "user", "content": user_message})
-    return messages
-
-
-def history_to_gemini_prompt_from_messages(
-    history_messages: List[Dict[str, str]],
-    user_message: str,
-    system_instructions: str,
-) -> str:
-    """
-    Flatten Chatbot-style message history into a single prompt for Gemini.
-    """
-    lines: List[str] = []
-    if system_instructions:
-        lines.append(f"SYSTEM:\n{system_instructions}\n")
-
+    # Reuse existing history
     for msg in history_messages:
         role = msg.get("role")
         content = msg.get("content", "")
-        if role == "user":
-            lines.append(f"USER: {content}")
-        elif role == "assistant":
-            lines.append(f"ASSISTANT: {content}")
-        elif role == "system":
-            lines.append(f"SYSTEM (prior): {content}")
+        if role in ("user", "assistant", "system") and content:
+            messages.append({"role": role, "content": content})
 
-    lines.append(f"USER: {user_message}")
-    lines.append("ASSISTANT:")
-    return "\n\n".join(lines)
+    # New query
+    messages.append({"role": "user", "content": user_message})
+    return messages
 
 # -------------------------------------------------------------------
-# Text Model Calls
+# OpenAI Text & Image Calls
 # -------------------------------------------------------------------
 
 def call_openai_text(
     openai_key: Optional[str],
     messages: List[Dict[str, str]],
     temperature: float,
+    top_p: float,
     max_tokens: int,
+    presence_penalty: float,
+    frequency_penalty: float,
 ) -> str:
+    """
+    Call GPT-5 via Chat Completions using the new max_completion_tokens parameter.
+    """
     client = get_openai_client(openai_key)
     completion = client.chat.completions.create(
-        model="gpt-5",  # adjust to actual GPT-5 variant in your project if needed
+        model="gpt-5",  # change to exact variant you have (e.g. "gpt-5.1-mini") if needed
         messages=messages,
         temperature=temperature,
-        max_tokens=max_tokens,
+        top_p=top_p,
+        presence_penalty=presence_penalty,
+        frequency_penalty=frequency_penalty,
+        max_completion_tokens=max_tokens,
     )
     return completion.choices[0].message.content
 
 
-def call_gemini_text(
-    google_key: Optional[str],
-    model_id: str,
-    prompt: str,
-    temperature: float,
-    max_tokens: int,
-) -> str:
-    client = get_google_client(google_key)
-    response = client.models.generate_content(
-        model=model_id,
-        contents=[prompt],
-        config=types.GenerateContentConfig(
-            temperature=temperature,
-            max_output_tokens=max_tokens,
-        ),
-    )
-    return response.text
-
-
-def call_hybrid_text(
-    openai_key: Optional[str],
-    google_key: Optional[str],
-    gemini_model_id: str,
-    messages: List[Dict[str, str]],
-    gemini_prompt: str,
-    temperature: float,
-    max_tokens: int,
-) -> str:
-    """
-    Call GPT-5 and a Gemini model, then fuse the outputs.
-    """
-    try:
-        gpt_answer = call_openai_text(openai_key, messages, temperature, max_tokens)
-    except Exception as e:
-        gpt_answer = f"[GPT-5 call failed: {e}]"
-
-    try:
-        gemini_answer = call_gemini_text(
-            google_key, gemini_model_id, gemini_prompt, temperature, max_tokens
-        )
-    except Exception as e:
-        gemini_answer = f"[Gemini call failed: {e}]"
-
-    fused = (
-        "### GPT-5 Perspective\n"
-        f"{gpt_answer}\n\n"
-        "### Gemini Perspective\n"
-        f"{gemini_answer}"
-    )
-    return fused
-
-# -------------------------------------------------------------------
-# Image Generation Calls
-# -------------------------------------------------------------------
-
 def call_openai_dalle(
     openai_key: Optional[str],
     prompt: str,
@@ -254,34 +175,36 @@ def call_openai_dalle(
     img_bytes = base64.b64decode(img_data)
     return Image.open(BytesIO(img_bytes))
 
+# -------------------------------------------------------------------
+# Starter Prompts
+# -------------------------------------------------------------------
 
-def call_gemini_image(
-    google_key: Optional[str],
-    model_id: str,
-    prompt: str,
-) -> Optional[Image.Image]:
-    """
-    Use Nano Banana (gemini-2.5-flash-image) or Nano Banana Pro
-    (gemini-3-pro-image-preview) via Google GenAI SDK.
-    """
-    client = get_google_client(google_key)
-    response = client.models.generate_content(
-        model=model_id,
-        contents=[prompt],
-    )
+STARTER_PROMPTS = {
+    "Explain AI Literacy to a 13-year-old":
+        "Explain what AI literacy is to a 13-year-old who loves YouTube and video games. "
+        "Use examples from their world and end with 3 practical things they can do this week.",
+
+    "Executive Brief: AI Strategy for a Nonprofit":
+        "Create an executive brief for a youth-serving nonprofit that wants to adopt AI tools. "
+        "Include priorities, risks, and quick wins in under 800 words.",
 
-    # Walk candidate parts for inline image data
-    for candidate in getattr(response, "candidates", []):
-        content = getattr(candidate, "content", None)
-        if not content:
-            continue
-        for part in getattr(content, "parts", []):
-            inline = getattr(part, "inline_data", None)
-            if inline and getattr(inline, "data", None):
-                img_bytes = base64.b64decode(inline.data)
-                return Image.open(BytesIO(img_bytes))
+    "Infographic Outline: ZEN AI Pioneer Program":
+        "Create an infographic outline that explains the ZEN AI Pioneer Program: "
+        "what it is, who it serves, what makes it historic, and 3 key stats. "
+        "Make the sections short and label-friendly.",
 
-    return None
+    "Creative Image Prompt: Futuristic ZEN AI Lab":
+        "Describe a futuristic but realistic ZEN AI Co. lab where youth are building their own AI tools. "
+        "Focus on what the scene looks like so it can be turned into an illustration. "
+        "End with a separate final paragraph that is ONLY the pure image prompt text.",
+
+    "Debugging Prompt: Why is my model hallucinating?":
+        "I built a small AI app and the model is hallucinating facts about my organization. "
+        "Explain why that happens and propose a 3-layer mitigation strategy (prompting, retrieval, UX).",
+}
+
+def get_starter_prompt(choice: str) -> str:
+    return STARTER_PROMPTS.get(choice, "")
 
 # -------------------------------------------------------------------
 # Core Chat Logic
@@ -291,98 +214,61 @@ def agent_assembler_chat(
     user_message: str,
     chat_history: List[Dict[str, str]],
     openai_key_ui: str,
-    google_key_ui: str,
-    model_family: str,
-    gemini_model_choice: str,
+    system_prompt_ui: str,
+    assistant_role: str,
     output_mode: str,
-    theme: str,
     tone: str,
     temperature: float,
+    top_p: float,
     max_tokens: int,
+    presence_penalty: float,
+    frequency_penalty: float,
     generate_image: bool,
-    image_backend: str,
+    image_style: str,
+    image_aspect: str,
 ) -> Tuple[List[Dict[str, str]], Optional[Image.Image]]:
     """
-    Main callback: text + optional image generation.
-
-    chat_history is a list of messages:
-    [{"role": "user", "content": "..."}, {"role": "assistant", "content": "..."}]
-    which matches the Gradio Chatbot in messages mode.
+    Main callback: GPT-5 text + optional DALL·E 3 image.
+    chat_history is a list of messages: [{role, content}, ...]
     """
     if not user_message.strip():
         return chat_history, None
 
-    base_system = (
-        "You are ZEN AI Co.'s Agent Assembler, a multi-model orchestrator. "
-        "You can:\n"
-        "- Hold deep, contextual conversations about AI literacy, automation, and education.\n"
-        "- Generate executive reports and structured briefs.\n"
-        "- Produce detailed infographic blueprints with clear sections and labels.\n"
-        "- Collaborate with image models by designing precise, typo-free prompts.\n"
-        "\n"
-        "Always:\n"
-        "- Avoid hallucinating APIs or capabilities you don't actually have.\n"
-        "- Make outputs copy-paste-ready for real projects.\n"
-        "- Keep spelling and formatting extremely precise."
-    )
-
+    # Build system instructions
     system_instructions = build_system_instructions(
-        base_instructions=base_system,
-        theme=theme,
+        user_system_prompt=system_prompt_ui,
+        assistant_role=assistant_role,
         output_mode=output_mode,
         tone=tone,
     )
 
-    # Prepare messages for OpenAI and Gemini
+    # Prepare messages for OpenAI
     openai_messages = history_to_openai_messages(
         history_messages=chat_history,
         user_message=user_message,
         system_instructions=system_instructions,
     )
-    gemini_prompt = history_to_gemini_prompt_from_messages(
-        history_messages=chat_history,
-        user_message=user_message,
-        system_instructions=system_instructions,
-    )
 
-    # Route text generation
-    if model_family == "OpenAI: GPT-5":
+    # Call GPT-5
+    try:
         ai_reply = call_openai_text(
             openai_key=openai_key_ui,
             messages=openai_messages,
             temperature=temperature,
+            top_p=top_p,
             max_tokens=max_tokens,
+            presence_penalty=presence_penalty,
+            frequency_penalty=frequency_penalty,
         )
-    elif model_family.startswith("Google Gemini"):
-        if gemini_model_choice == "Gemini 2.5 Pro":
-            model_id = "gemini-2.5-pro"
-        else:
-            model_id = "gemini-3-pro-preview"
-
-        ai_reply = call_gemini_text(
-            google_key=google_key_ui,
-            model_id=model_id,
-            prompt=gemini_prompt,
-            temperature=temperature,
-            max_tokens=max_tokens,
-        )
-    else:  # Hybrid: GPT-5 + Gemini
-        if gemini_model_choice == "Gemini 2.5 Pro":
-            model_id = "gemini-2.5-pro"
-        else:
-            model_id = "gemini-3-pro-preview"
-
-        ai_reply = call_hybrid_text(
-            openai_key=openai_key_ui,
-            google_key=google_key_ui,
-            gemini_model_id=model_id,
-            messages=openai_messages,
-            gemini_prompt=gemini_prompt,
-            temperature=temperature,
-            max_tokens=max_tokens,
+    except Exception as e:
+        ai_reply = (
+            "There was an error calling GPT-5.\n\n"
+            f"Short message: `{e}`\n\n"
+            "Check that your API key is valid and that the model name matches "
+            "what is available in your OpenAI account."
         )
 
-    # Update history with new user + assistant messages
+    # Update history
     chat_history = chat_history + [
         {"role": "user", "content": user_message},
         {"role": "assistant", "content": ai_reply},
@@ -391,34 +277,34 @@ def agent_assembler_chat(
     # Optional image generation
     generated_image: Optional[Image.Image] = None
     if generate_image:
+        # Map aspect label to DALL·E size
+        aspect_to_size = {
+            "Square (1:1)": "1024x1024",
+            "Portrait (9:16)": "1024x1792",
+            "Landscape (16:9)": "1792x1024",
+        }
+        size = aspect_to_size.get(image_aspect, "1024x1024")
+
+        # Build image prompt
         image_prompt = (
             f"{user_message.strip()}\n\n"
-            f"Image intent: {output_mode}. "
-            "Render clean, readable text if labels are required. "
-            "Use a visual style aligned with the ZEN AI Co. brand."
+            f"IMAGE STYLE: {image_style}. "
+            "High readability, clean composition, suitable for presentations or infographics."
         )
 
         try:
-            if image_backend == "DALL·E 3 (OpenAI)":
-                generated_image = call_openai_dalle(
-                    openai_key=openai_key_ui, prompt=image_prompt
-                )
-            elif image_backend == "Nano Banana (Gemini 2.5 Flash Image)":
-                generated_image = call_gemini_image(
-                    google_key=google_key_ui,
-                    model_id="gemini-2.5-flash-image",
-                    prompt=image_prompt,
-                )
-            else:  # Nano Banana Pro
-                generated_image = call_gemini_image(
-                    google_key=google_key_ui,
-                    model_id="gemini-3-pro-image-preview",
-                    prompt=image_prompt,
-                )
+            generated_image = call_openai_dalle(
+                openai_key=openai_key_ui,
+                prompt=image_prompt,
+                size=size,
+            )
         except Exception as e:
-            # Attach error note to the latest assistant message
+            # Attach error note to latest assistant message
             if chat_history and chat_history[-1].get("role") == "assistant":
-                chat_history[-1]["content"] += f"\n\n_Image generation failed: {e}_"
+                chat_history[-1]["content"] += (
+                    f"\n\n_Image generation failed: `{e}`. "
+                    "Check your OpenAI key and dalle-3 availability._"
+                )
 
     return chat_history, generated_image
 
@@ -433,67 +319,89 @@ def clear_chat() -> Tuple[List[Dict[str, str]], Optional[Image.Image]]:
 # Gradio UI
 # -------------------------------------------------------------------
 
+DEFAULT_SYSTEM_PROMPT = """You are ZEN AI Co.'s Agent Assembler.
+
+You help people understand how large language models and image models work
+by giving clear, practical, and honest answers. You are allowed to:
+
+- Explain how prompts, system messages, and parameters change behavior.
+- Suggest better prompts and show before/after improvements.
+- Design prompts for text and images that are copy-paste-ready.
+- Produce reports, outlines, and infographic blueprints.
+
+You must:
+
+- Avoid making up API capabilities that do not exist.
+- Be honest when you don't know something or lack context.
+- Keep spelling and formatting very precise, especially in prompts and labels.
+"""
+
 def build_interface() -> gr.Blocks:
     with gr.Blocks(title=APP_TITLE) as demo:
         gr.Markdown(f"# {APP_TITLE}")
         gr.Markdown(APP_DESCRIPTION)
 
         with gr.Row():
-            # Left side: chat + image output
+            # LEFT: Chat + image + input
             with gr.Column(scale=3):
                 chatbot = gr.Chatbot(
                     label="Agent Assembler Chat",
                     height=520,
                 )
                 image_out = gr.Image(
-                    label="Latest Generated Image",
+                    label="Latest Generated Image (DALL·E 3)",
                     height=320,
                     interactive=False,
                 )
+
                 user_input = gr.Textbox(
                     label="Your message",
-                    placeholder=(
-                        "Ask for a chat, a report, an infographic outline, or an image..."
-                    ),
+                    placeholder="Ask a question, request a report, or describe a scene for image generation...",
                     lines=3,
                 )
 
                 with gr.Row():
                     send_btn = gr.Button("Send", variant="primary")
-                    clear_btn = gr.Button("Clear")
+                    clear_btn = gr.Button("Clear Chat")
+
+                gr.Markdown("### Starter Prompts")
+                starter_choice = gr.Dropdown(
+                    label="Pick a starter prompt to auto-fill the input",
+                    choices=list(STARTER_PROMPTS.keys()),
+                    value="Explain AI Literacy to a 13-year-old",
+                )
+                starter_btn = gr.Button("Load Starter Prompt")
 
-            # Right side: control panel
+            # RIGHT: Controls / teaching panel
             with gr.Column(scale=2):
-                gr.Markdown("## API Keys")
+                gr.Markdown("## API & System Prompt")
+
                 openai_key_ui = gr.Textbox(
                     label="OpenAI API Key (optional; otherwise uses OPENAI_API_KEY env var)",
                     type="password",
                 )
-                google_key_ui = gr.Textbox(
-                    label="Google Gemini API Key (optional; otherwise uses GOOGLE_API_KEY env var)",
-                    type="password",
+
+                system_prompt_ui = gr.Textbox(
+                    label="System / Model Instructions",
+                    value=DEFAULT_SYSTEM_PROMPT,
+                    lines=10,
                 )
 
-                gr.Markdown("## Model & Style")
+                gr.Markdown("## Behavior & Style")
 
-                model_family = gr.Radio(
-                    label="Primary Model Routing",
+                assistant_role = gr.Radio(
+                    label="Assistant Role",
                     choices=[
-                        "OpenAI: GPT-5",
-                        "Google Gemini: Single",
-                        "Hybrid: GPT-5 + Gemini",
+                        "General Assistant",
+                        "Teacher / Instructor",
+                        "Engineer / Architect",
+                        "Storyteller / Creative",
                     ],
-                    value="Hybrid: GPT-5 + Gemini",
-                )
-
-                gemini_model_choice = gr.Radio(
-                    label="Gemini Model",
-                    choices=["Gemini 2.5 Pro", "Gemini 3 Pro (preview)"],
-                    value="Gemini 3 Pro (preview)",
+                    value="General Assistant",
                 )
 
                 output_mode = gr.Radio(
-                    label="Output Mode",
+                    label="Output Format",
                     choices=[
                         "Standard Chat",
                         "Executive Report",
@@ -503,78 +411,109 @@ def build_interface() -> gr.Blocks:
                     value="Standard Chat",
                 )
 
-                theme = gr.Radio(
-                    label="Theme (response style)",
-                    choices=[
-                        "ZEN Dark",
-                        "ZEN Light",
-                        "Research / Technical",
-                        "Youth AI Pioneer",
-                    ],
-                    value="ZEN Dark",
-                )
-
                 tone = gr.Radio(
                     label="Tone",
-                    choices=["Neutral", "Bold / Visionary", "Minimalist"],
+                    choices=[
+                        "Neutral",
+                        "Bold / Visionary",
+                        "Minimalist",
+                    ],
                     value="Neutral",
                 )
 
-                gr.Markdown("## Text Generation Controls")
+                gr.Markdown("## Sampling (Experiment Zone)")
 
                 temperature = gr.Slider(
-                    label="Temperature (creativity)",
+                    label="Temperature (creativity / randomness)",
                     minimum=0.0,
                     maximum=1.5,
                     value=DEFAULT_TEMPERATURE,
                     step=0.05,
                 )
 
+                top_p = gr.Slider(
+                    label="Top-p (nucleus sampling)",
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=DEFAULT_TOP_P,
+                    step=0.05,
+                )
+
                 max_tokens = gr.Slider(
-                    label="Max Tokens (text length)",
+                    label="Max completion tokens",
                     minimum=128,
                     maximum=4096,
                     value=DEFAULT_MAX_TOKENS,
                     step=128,
                 )
 
-                gr.Markdown("## Image Generation")
+                presence_penalty = gr.Slider(
+                    label="Presence penalty (encourage new topics)",
+                    minimum=-2.0,
+                    maximum=2.0,
+                    value=DEFAULT_PRESENCE_PENALTY,
+                    step=0.1,
+                )
+
+                frequency_penalty = gr.Slider(
+                    label="Frequency penalty (discourage repetition)",
+                    minimum=-2.0,
+                    maximum=2.0,
+                    value=DEFAULT_FREQUENCY_PENALTY,
+                    step=0.1,
+                )
+
+                gr.Markdown("## Image Generation (DALL·E 3)")
 
                 generate_image = gr.Checkbox(
                     label="Also generate an image for this message",
                     value=False,
                 )
 
-                image_backend = gr.Radio(
-                    label="Image Backend",
+                image_style = gr.Radio(
+                    label="Image Style",
                     choices=[
-                        "DALL·E 3 (OpenAI)",
-                        "Nano Banana (Gemini 2.5 Flash Image)",
-                        "Nano Banana Pro (Gemini 3 Pro Image Preview)",
+                        "Futuristic glass UI dashboard",
+                        "Clean infographic illustration",
+                        "Soft watercolor concept art",
+                        "High-contrast comic / graphic novel",
+                        "Photorealistic lab / studio scene",
                     ],
-                    value="Nano Banana Pro (Gemini 3 Pro Image Preview)",
+                    value="Clean infographic illustration",
+                )
+
+                image_aspect = gr.Radio(
+                    label="Aspect Ratio",
+                    choices=[
+                        "Square (1:1)",
+                        "Portrait (9:16)",
+                        "Landscape (16:9)",
+                    ],
+                    value="Square (1:1)",
                 )
 
         # Shared chat state: list of messages (dicts)
         chat_state = gr.State([])
 
-        # Send button wiring
+        # Send button: main call
         send_btn.click(
             fn=agent_assembler_chat,
             inputs=[
                 user_input,
                 chat_state,
                 openai_key_ui,
-                google_key_ui,
-                model_family,
-                gemini_model_choice,
+                system_prompt_ui,
+                assistant_role,
                 output_mode,
-                theme,
                 tone,
                 temperature,
+                top_p,
                 max_tokens,
+                presence_penalty,
+                frequency_penalty,
                 generate_image,
-                image_backend,
+                image_style,
+                image_aspect,
             ],
             outputs=[chatbot, image_out],
         ).then(
@@ -590,16 +529,18 @@ def build_interface() -> gr.Blocks:
                 user_input,
                 chat_state,
                 openai_key_ui,
-                google_key_ui,
-                model_family,
-                gemini_model_choice,
+                system_prompt_ui,
+                assistant_role,
                 output_mode,
-                theme,
                 tone,
                 temperature,
+                top_p,
                 max_tokens,
+                presence_penalty,
+                frequency_penalty,
                 generate_image,
-                image_backend,
+                image_style,
+                image_aspect,
             ],
             outputs=[chatbot, image_out],
         ).then(
@@ -608,7 +549,7 @@ def build_interface() -> gr.Blocks:
             outputs=[chat_state, user_input],
         )
 
-        # Clear button wiring
+        # Clear chat
         clear_btn.click(
             fn=clear_chat,
             inputs=None,
@@ -619,6 +560,16 @@ def build_interface() -> gr.Blocks:
             outputs=chat_state,
         )
 
+        # Starter prompt loader
+        def _load_starter(choice: str) -> str:
+            return get_starter_prompt(choice)
+
+        starter_btn.click(
+            fn=_load_starter,
+            inputs=[starter_choice],
+            outputs=[user_input],
+        )
+
     return demo