Upload app.py

app.py

@@ -0,0 +1,393 @@
+import os
+import traceback
+from typing import Any
+
+import gradio as gr
+from openai import OpenAI
+
+
+GENERATION_MODELS = [
+    "gpt-4.1-mini",
+    "gpt-4.1",
+    "gpt-4o-mini",
+    "gpt-5.5",
+]
+
+REASONING_MODELS = [
+    "gpt-5.5",
+    "o4-mini",
+    "o3-mini",
+]
+
+
+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 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()
+
+    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", [])
+
+        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:
+    """
+    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.
+    """
+    return model.strip().lower().startswith("gpt-5")
+
+
+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)
+
+
+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"
+        )
+
+    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),
+            }
+        )
+
+    try:
+        response = client.responses.create(**params)
+        text = extract_output_text(response)
+
+        if show_settings:
+            settings = {
+                "model": model,
+                "system_message": system_message,
+                "max_output_tokens": max_output_tokens,
+            }
+            if is_gpt5_family(model):
+                settings.update(
+                    {
+                        "sampling_controls": "not sent for GPT-5 family model",
+                    }
+                )
+            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
+
+        return settings_note + text
+
+    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()}"
+        )
+
+
+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"
+        )
+
+    if not prompt or not prompt.strip():
+        return "Please enter a prompt."
+
+    params: dict[str, Any] = {
+        "model": model,
+        "input": prompt,
+        "reasoning": {"effort": reasoning_effort},
+        "max_output_tokens": int(max_output_tokens),
+    }
+
+    try:
+        response = client.responses.create(**params)
+        text = extract_output_text(response)
+
+        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()}"
+        )
+
+
+custom_css = """
+.gradio-container {
+    max-width: 1180px !important;
+    margin: auto !important;
+}
+#main-title {
+    text-align: center;
+}
+.output-box textarea {
+    font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", monospace;
+}
+"""
+
+
+with gr.Blocks(
+    title="OpenAI LLM Controls",
+    theme=gr.themes.Soft(),
+    css=custom_css,
+) as demo:
+    gr.Markdown(
+        """
+        # OpenAI LLM Controls
+
+        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",
+    )
+
+    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.
+            """
+        )
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                gen_prompt = gr.Textbox(
+                    lines=7,
+                    label="Prompt",
+                    value="Write a short LinkedIn post explaining why business leaders should learn AI. Maximum 120 words.",
+                )
+                gen_model = gr.Dropdown(
+                    GENERATION_MODELS,
+                    label="Model",
+                    value="gpt-4.1-mini",
+                )
+                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_button = gr.Button("Generate", variant="primary")
+
+            with gr.Column(scale=1):
+                gen_output = gr.Textbox(
+                    lines=22,
+                    label="Output",
+                    elem_classes=["output-box"],
+                    show_copy_button=True,
+                )
+
+        gen_button.click(
+            fn=run_generation,
+            inputs=[
+                gen_prompt,
+                gen_model,
+                system_message,
+                temperature,
+                top_p,
+                max_output_tokens_gen,
+                frequency_penalty,
+                presence_penalty,
+                show_settings_gen,
+            ],
+            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."
+                    ),
+                )
+                reason_model = gr.Dropdown(
+                    REASONING_MODELS,
+                    label="Model",
+                    value="gpt-5.5",
+                )
+                reasoning_effort = gr.Radio(
+                    ["low", "medium", "high"],
+                    label="Reasoning Effort",
+                    value="medium",
+                )
+                max_output_tokens_reason = gr.Slider(
+                    minimum=100,
+                    maximum=8000,
+                    step=50,
+                    value=900,
+                    label="Max Output Tokens",
+                )
+                show_settings_reason = gr.Checkbox(value=True, label="Show Settings")
+                reason_button = gr.Button("Reason", variant="primary")
+
+            with gr.Column(scale=1):
+                reason_output = gr.Textbox(
+                    lines=22,
+                    label="Output",
+                    elem_classes=["output-box"],
+                    show_copy_button=True,
+                )
+
+        reason_button.click(
+            fn=run_reasoning,
+            inputs=[
+                reason_prompt,
+                reason_model,
+                reasoning_effort,
+                max_output_tokens_reason,
+                show_settings_reason,
+            ],
+            outputs=reason_output,
+        )
+
+
+if __name__ == "__main__":
+    demo.queue()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=int(os.getenv("PORT", "7860")),
+    )