Update app.py

app.py

@@ -1,249 +1,237 @@
 import os
-import traceback
-from typing import Any
-
 import gradio as gr
 from openai import OpenAI
 
 
+# =========================
+# Hugging Face Secret
+# =========================
+# Add this in Hugging Face Spaces:
+# Settings → Secrets → New secret
+# Name: OPENAI_API_KEY
+# Value: your OpenAI API key
+
+
+DEFAULT_GENERATION_MODEL = os.getenv("OPENAI_GENERATION_MODEL", "gpt-5.5")
+DEFAULT_REASONING_MODEL = os.getenv("OPENAI_REASONING_MODEL", "gpt-5.5")
+
+
 GENERATION_MODELS = [
-    "gpt-4.1-mini",
-    "gpt-4.1",
-    "gpt-4o-mini",
     "gpt-5.5",
+    "gpt-5.1",
+    "gpt-5-mini",
+    "gpt-4.1",
+    "gpt-4.1-mini",
 ]
 
 REASONING_MODELS = [
     "gpt-5.5",
-    "o4-mini",
-    "o3-mini",
+    "gpt-5.1",
+    "gpt-5-mini",
+    "gpt-5-pro",
 ]
 
 
-def get_client() -> OpenAI | None:
-    """
-    Hugging Face Spaces exposes Secrets as environment variables.
-    Add your OpenAI key in Space Settings as OPENAI_API_KEY.
-    The lowercase fallback is included only to help during local testing.
-    """
-    api_key = os.getenv("OPENAI_API_KEY") or os.getenv("openai_api_key")
-    if not api_key:
-        return None
-    return OpenAI(api_key=api_key)
-
+def get_openai_client():
+    api_key = os.getenv("OPENAI_API_KEY")
 
-def extract_output_text(response: Any) -> str:
-    """Robustly extract text from an OpenAI Responses API response."""
-    output_text = getattr(response, "output_text", None)
-    if output_text:
-        return output_text.strip()
+    if not api_key:
+        raise ValueError(
+            "OPENAI_API_KEY is missing. "
+            "Please add it in Hugging Face Spaces → Settings → Secrets."
+        )
 
-    chunks: list[str] = []
-    for item in getattr(response, "output", []) or []:
-        content = getattr(item, "content", None)
-        if content is None and isinstance(item, dict):
-            content = item.get("content", [])
+    return OpenAI(api_key=api_key)
 
-        for part in content or []:
-            if isinstance(part, dict):
-                text = part.get("text") or part.get("output_text")
-            else:
-                text = getattr(part, "text", None) or getattr(part, "output_text", None)
-            if text:
-                chunks.append(str(text))
 
-    return "\n".join(chunks).strip() if chunks else str(response)
+def is_gpt5_family(model: str) -> bool:
+    return model.startswith("gpt-5")
 
 
-def is_gpt5_family(model: str) -> bool:
+def extract_output_text(response):
     """
-    GPT-5 family models may reject custom sampling controls such as temperature.
-    To avoid the common 400 error, this app does not send those controls to GPT-5.x models.
+    Safely extract text from OpenAI Responses API output.
     """
-    return model.strip().lower().startswith("gpt-5")
+    if hasattr(response, "output_text") and response.output_text:
+        return response.output_text
+
+    chunks = []
 
+    if hasattr(response, "output") and response.output:
+        for item in response.output:
+            if hasattr(item, "content") and item.content:
+                for content in item.content:
+                    if hasattr(content, "text") and content.text:
+                        chunks.append(content.text)
 
-def format_settings(title: str, settings: dict[str, Any]) -> str:
-    lines = [f"--- {title} ---"]
-    for key, value in settings.items():
-        lines.append(f"{key}: {value}")
-    lines.append("------------------------\n")
-    return "\n".join(lines)
+    return "\n".join(chunks).strip()
 
 
 def run_generation(
-    prompt: str,
-    model: str,
-    system_message: str,
-    temperature: float,
-    top_p: float,
-    max_output_tokens: int,
-    frequency_penalty: float,
-    presence_penalty: float,
-    show_settings: bool,
-) -> str:
-    client = get_client()
-    if client is None:
-        return (
-            "Missing API key.\n\n"
-            "In Hugging Face Spaces, go to Settings → Secrets and add:\n"
-            "Name: OPENAI_API_KEY\n"
-            "Value: your OpenAI API key"
-        )
+    prompt,
+    model,
+    system_message,
+    temperature,
+    top_p,
+    max_output_tokens,
+    frequency_penalty,
+    presence_penalty,
+    show_settings,
+):
+    try:
+        client = get_openai_client()
 
-    if not prompt or not prompt.strip():
-        return "Please enter a prompt."
-
-    params: dict[str, Any] = {
-        "model": model,
-        "instructions": system_message or "You are a helpful assistant.",
-        "input": prompt,
-        "max_output_tokens": int(max_output_tokens),
-    }
-
-    settings_note = ""
-    if is_gpt5_family(model):
-        settings_note = (
-            "Note: GPT-5 family models can reject custom sampling controls. "
-            "Temperature, top_p, frequency_penalty, and presence_penalty were not sent.\n\n"
-        )
-    else:
-        params.update(
-            {
-                "temperature": float(temperature),
-                "top_p": float(top_p),
-                "frequency_penalty": float(frequency_penalty),
-                "presence_penalty": float(presence_penalty),
-            }
-        )
+        request_params = {
+            "model": model,
+            "instructions": system_message,
+            "input": prompt,
+            "max_output_tokens": int(max_output_tokens),
+        }
 
-    try:
-        response = client.responses.create(**params)
-        text = extract_output_text(response)
+        # GPT-5 family models may reject custom temperature/top_p/penalties.
+        # Keep defaults for GPT-5 models to avoid unsupported_value errors.
+        if not is_gpt5_family(model):
+            request_params["temperature"] = float(temperature)
+            request_params["top_p"] = float(top_p)
+            request_params["frequency_penalty"] = float(frequency_penalty)
+            request_params["presence_penalty"] = float(presence_penalty)
+
+        response = client.responses.create(**request_params)
+        output = extract_output_text(response)
+
+        if not output:
+            output = "No output generated."
 
         if show_settings:
-            settings = {
-                "model": model,
-                "system_message": system_message,
-                "max_output_tokens": max_output_tokens,
-            }
+            settings = f"""
+MODEL SETTINGS
+--------------
+Model: {model}
+Max Output Tokens: {max_output_tokens}
+"""
+
             if is_gpt5_family(model):
-                settings.update(
-                    {
-                        "sampling_controls": "not sent for GPT-5 family model",
-                    }
-                )
+                settings += """
+Temperature: default only for GPT-5 family
+Top P: default only for GPT-5 family
+Frequency Penalty: default only for GPT-5 family
+Presence Penalty: default only for GPT-5 family
+"""
             else:
-                settings.update(
-                    {
-                        "temperature": temperature,
-                        "top_p": top_p,
-                        "frequency_penalty": frequency_penalty,
-                        "presence_penalty": presence_penalty,
-                    }
-                )
-            return settings_note + format_settings("Generation Settings", settings) + text
+                settings += f"""
+Temperature: {temperature}
+Top P: {top_p}
+Frequency Penalty: {frequency_penalty}
+Presence Penalty: {presence_penalty}
+"""
 
-        return settings_note + text
+            settings += "\nOUTPUT\n------\n"
+            return settings + output
 
-    except Exception as exc:
-        return (
-            "OpenAI API error:\n"
-            f"{exc}\n\n"
-            "Tip: If you selected a GPT-5 family model, try keeping generation controls at default "
-            "or use the Reasoning Controls tab.\n\n"
-            f"Technical details:\n{traceback.format_exc()}"
-        )
+        return output
+
+    except Exception as e:
+        return f"Error:\n{str(e)}"
 
 
 def run_reasoning(
-    prompt: str,
-    model: str,
-    reasoning_effort: str,
-    max_output_tokens: int,
-    show_settings: bool,
-) -> str:
-    client = get_client()
-    if client is None:
-        return (
-            "Missing API key.\n\n"
-            "In Hugging Face Spaces, go to Settings → Secrets and add:\n"
-            "Name: OPENAI_API_KEY\n"
-            "Value: your OpenAI API key"
-        )
+    prompt,
+    model,
+    reasoning_effort,
+    max_output_tokens,
+    show_settings,
+):
+    try:
+        client = get_openai_client()
 
-    if not prompt or not prompt.strip():
-        return "Please enter a prompt."
+        request_params = {
+            "model": model,
+            "input": prompt,
+            "max_output_tokens": int(max_output_tokens),
+            "reasoning": {
+                "effort": reasoning_effort
+            },
+        }
 
-    params: dict[str, Any] = {
-        "model": model,
-        "input": prompt,
-        "reasoning": {"effort": reasoning_effort},
-        "max_output_tokens": int(max_output_tokens),
-    }
+        response = client.responses.create(**request_params)
+        output = extract_output_text(response)
 
-    try:
-        response = client.responses.create(**params)
-        text = extract_output_text(response)
+        if not output:
+            output = "No output generated."
 
         if show_settings:
-            settings = {
-                "model": model,
-                "reasoning_effort": reasoning_effort,
-                "max_output_tokens": max_output_tokens,
-                "api": "OpenAI Responses API",
-            }
-            return format_settings("Reasoning Settings", settings) + text
-
-        return text
-
-    except Exception as exc:
-        return (
-            "OpenAI API error:\n"
-            f"{exc}\n\n"
-            "Tip: Make sure your account has access to the selected model, or try another model "
-            "from the dropdown.\n\n"
-            f"Technical details:\n{traceback.format_exc()}"
-        )
+            settings = f"""
+REASONING SETTINGS
+------------------
+Model: {model}
+Reasoning Effort: {reasoning_effort}
+Max Output Tokens: {max_output_tokens}
+
+OUTPUT
+------
+"""
+            return settings + output
 
+        return output
 
-custom_css = """
+    except Exception as e:
+        return f"Error:\n{str(e)}"
+
+
+CSS = """
 .gradio-container {
-    max-width: 1180px !important;
+    max-width: 1200px !important;
     margin: auto !important;
 }
-#main-title {
+
+.main-title {
     text-align: center;
+    margin-bottom: 20px;
+}
+
+.helper-box {
+    padding: 14px;
+    border-radius: 12px;
+    background: #f7f7f8;
+    border: 1px solid #e5e7eb;
+    margin-bottom: 16px;
 }
+
 .output-box textarea {
-    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+    font-family: monospace !important;
 }
 """
 
 
-with gr.Blocks(
-    title="OpenAI LLM Controls",
-    theme=gr.themes.Soft(),
-    css=custom_css,
-) as demo:
+with gr.Blocks() as demo:
     gr.Markdown(
         """
-        # OpenAI LLM Controls
+        <div class="main-title">
+
+        # LLM Generation & Reasoning Controls
+
+        Experiment with OpenAI model settings using a simple Gradio interface.
 
-        Experiment with generation settings and reasoning effort using the OpenAI Responses API.
-        Add your key in Hugging Face Spaces as the secret `OPENAI_API_KEY`.
-        """,
-        elem_id="main-title",
+        </div>
+        """
     )
 
-    with gr.Tab("Generation Controls"):
-        gr.Markdown(
-            """
-            Use this tab to test practical writing and completion tasks.  
-            For GPT-5 family models, the app avoids sending custom sampling controls to prevent unsupported-parameter errors.
-            """
-        )
+    gr.Markdown(
+        """
+        <div class="helper-box">
+
+        <b>Important:</b> Add your OpenAI key in Hugging Face Spaces Secrets as:
 
+        <code>OPENAI_API_KEY</code>
+
+        GPT-5 family models may only support default values for temperature, top-p, and penalties.  
+        This app automatically skips those settings for GPT-5 models to avoid API errors.
+
+        </div>
+        """
+    )
+
+    with gr.Tab("Generation Controls"):
         with gr.Row():
             with gr.Column(scale=1):
                 gen_prompt = gr.Textbox(
@@ -251,53 +239,66 @@ with gr.Blocks(
                     label="Prompt",
                     value="Write a short LinkedIn post explaining why business leaders should learn AI. Maximum 120 words.",
                 )
+
                 gen_model = gr.Dropdown(
-                    GENERATION_MODELS,
+                    choices=GENERATION_MODELS,
                     label="Model",
-                    value="gpt-4.1-mini",
+                    value=DEFAULT_GENERATION_MODEL
+                    if DEFAULT_GENERATION_MODEL in GENERATION_MODELS
+                    else "gpt-5.5",
                 )
-                system_message = gr.Textbox(
+
+                gen_system_message = gr.Textbox(
                     lines=3,
                     label="System Message",
                     value="You are a helpful AI instructor. Keep answers clear and practical.",
                 )
-                with gr.Accordion("Advanced Generation Settings", open=True):
-                    temperature = gr.Slider(
-                        minimum=0.0,
-                        maximum=2.0,
-                        step=0.01,
-                        value=0.7,
-                        label="Temperature",
-                    )
-                    top_p = gr.Slider(
-                        minimum=0.0,
-                        maximum=1.0,
-                        step=0.01,
-                        value=1.0,
-                        label="Top P",
-                    )
-                    max_output_tokens_gen = gr.Slider(
-                        minimum=50,
-                        maximum=4000,
-                        step=10,
-                        value=300,
-                        label="Max Output Tokens",
-                    )
-                    frequency_penalty = gr.Slider(
-                        minimum=-2.0,
-                        maximum=2.0,
-                        step=0.01,
-                        value=0.0,
-                        label="Frequency Penalty",
-                    )
-                    presence_penalty = gr.Slider(
-                        minimum=-2.0,
-                        maximum=2.0,
-                        step=0.01,
-                        value=0.0,
-                        label="Presence Penalty",
-                    )
-                    show_settings_gen = gr.Checkbox(value=True, label="Show Settings")
+
+                gen_temperature = gr.Slider(
+                    minimum=0.0,
+                    maximum=2.0,
+                    step=0.01,
+                    value=0.7,
+                    label="Temperature",
+                )
+
+                gen_top_p = gr.Slider(
+                    minimum=0.0,
+                    maximum=1.0,
+                    step=0.01,
+                    value=1.0,
+                    label="Top P",
+                )
+
+                gen_max_output_tokens = gr.Slider(
+                    minimum=50,
+                    maximum=4000,
+                    step=50,
+                    value=500,
+                    label="Max Output Tokens",
+                )
+
+                gen_frequency_penalty = gr.Slider(
+                    minimum=-2.0,
+                    maximum=2.0,
+                    step=0.01,
+                    value=0.0,
+                    label="Frequency Penalty",
+                )
+
+                gen_presence_penalty = gr.Slider(
+                    minimum=-2.0,
+                    maximum=2.0,
+                    step=0.01,
+                    value=0.0,
+                    label="Presence Penalty",
+                )
+
+                gen_show_settings = gr.Checkbox(
+                    value=True,
+                    label="Show Settings",
+                )
+
                 gen_button = gr.Button("Generate", variant="primary")
 
             with gr.Column(scale=1):
@@ -305,7 +306,6 @@ with gr.Blocks(
                     lines=22,
                     label="Output",
                     elem_classes=["output-box"],
-                    show_copy_button=True,
                 )
 
         gen_button.click(
@@ -313,55 +313,67 @@ with gr.Blocks(
             inputs=[
                 gen_prompt,
                 gen_model,
-                system_message,
-                temperature,
-                top_p,
-                max_output_tokens_gen,
-                frequency_penalty,
-                presence_penalty,
-                show_settings_gen,
+                gen_system_message,
+                gen_temperature,
+                gen_top_p,
+                gen_max_output_tokens,
+                gen_frequency_penalty,
+                gen_presence_penalty,
+                gen_show_settings,
             ],
             outputs=gen_output,
         )
 
     with gr.Tab("Reasoning Controls"):
-        gr.Markdown(
-            """
-            Use this tab for analysis, recommendations, technical trade-offs, planning, and decision-making tasks.
-            """
-        )
-
         with gr.Row():
             with gr.Column(scale=1):
                 reason_prompt = gr.Textbox(
                     lines=9,
                     label="Prompt",
-                    value=(
-                        "A telecom company wants to build an AI customer support assistant. "
-                        "They have 50,000 past support tickets, a FAQ website, billing policies, "
-                        "and a small developer team. Should they start with: "
-                        "1. Simple prompt-based chatbot 2. RAG chatbot 3. Fine-tuning "
-                        "4. Agent with tools. Give a practical recommendation with trade-offs."
-                    ),
+                    value="""A telecom company wants to build an AI customer support assistant.
+
+They have:
+- 50,000 past support tickets
+- A FAQ website
+- Billing policies
+- A small developer team
+
+Should they start with:
+1. Simple prompt-based chatbot
+2. RAG chatbot
+3. Fine-tuning
+4. Agent with tools
+
+Give a practical recommendation with trade-offs.""",
                 )
+
                 reason_model = gr.Dropdown(
-                    REASONING_MODELS,
+                    choices=REASONING_MODELS,
                     label="Model",
-                    value="gpt-5.5",
+                    value=DEFAULT_REASONING_MODEL
+                    if DEFAULT_REASONING_MODEL in REASONING_MODELS
+                    else "gpt-5.5",
                 )
-                reasoning_effort = gr.Radio(
-                    ["low", "medium", "high"],
+
+                reason_effort = gr.Radio(
+                    choices=["low", "medium", "high"],
                     label="Reasoning Effort",
                     value="medium",
                 )
-                max_output_tokens_reason = gr.Slider(
+
+                reason_max_output_tokens = gr.Slider(
                     minimum=100,
                     maximum=8000,
-                    step=50,
-                    value=900,
+                    step=100,
+                    value=1000,
                     label="Max Output Tokens",
                 )
-                show_settings_reason = gr.Checkbox(value=True, label="Show Settings")
+
+                reason_show_settings = gr.Checkbox(
+                    value=True,
+                    label="Show Settings",
+                )
+
                 reason_button = gr.Button("Reason", variant="primary")
 
             with gr.Column(scale=1):
@@ -369,7 +381,6 @@ with gr.Blocks(
                     lines=22,
                     label="Output",
                     elem_classes=["output-box"],
-                    show_copy_button=True,
                 )
 
         reason_button.click(
@@ -377,17 +388,20 @@ with gr.Blocks(
             inputs=[
                 reason_prompt,
                 reason_model,
-                reasoning_effort,
-                max_output_tokens_reason,
-                show_settings_reason,
+                reason_effort,
+                reason_max_output_tokens,
+                reason_show_settings,
             ],
             outputs=reason_output,
         )
 
 
 if __name__ == "__main__":
-    demo.queue()
     demo.launch(
+        theme=gr.themes.Soft(),
+        css=CSS,
         server_name="0.0.0.0",
-        server_port=int(os.getenv("PORT", "7860")),
-    )
+        server_port=int(os.getenv("PORT", 7860)),
+        debug=False,
+        share=False,
+    )