Update app.py

app.py

@@ -2,167 +2,1122 @@ import gradio as gr
 from gradio import Server
 import spaces
 import torch
+
 from transformers import (
     AutoTokenizer,
     AutoModelForCausalLM,
-    BitsAndBytesConfig,          # ← added
+    BitsAndBytesConfig,
+    TextIteratorStreamer,
 )
 
-# ─────────────────────────────────────────────
-# 1. MODEL SETUP
-# ─────────────────────────────────────────────
+from threading import Thread
+
+
+# ============================================================
+# G1-PREVIEW API
+# Smilyai-Labs
+#
+# Backwards compatible with the original prompt API.
+#
+# OLD FORMAT:
+# {
+#     "prompt": "Hello"
+# }
+#
+# -> thinking OFF by default
+#
+#
+# NEW FORMAT:
+# {
+#     "messages": [
+#         {"role": "user", "content": "Hello"}
+#     ]
+# }
+#
+# -> xhigh reasoning by default
+#
+#
+# Explicit reasoning_effort always overrides the default.
+# ============================================================
+
+
+# ============================================================
+# 1. CONFIGURATION
+# ============================================================
+
 MODEL_ID = "Qwen/Qwen3.8-27B"
 
-# ── 4-bit quantisation config ──────────────────
+VERSION = "2.1.0"
+
+DEFAULT_SYSTEM_PROMPT = (
+    "You are a helpful assistant created by Smilyai-Labs. "
+    "You are called G1-Preview."
+)
+
+
+# ============================================================
+# 2. REASONING MODES
+# ============================================================
+
+REASONING_MODES = {
+    # Maximum reasoning
+    "xhigh": {
+        "enable_thinking": True,
+        "temperature": 1.0,
+        "top_p": 0.95,
+        "max_token_multiplier": 1.00,
+    },
+
+    # Balanced reasoning
+    "medium": {
+        "enable_thinking": True,
+        "temperature": 0.9,
+        "top_p": 0.95,
+        "max_token_multiplier": 0.65,
+    },
+
+    # Fast reasoning
+    "low": {
+        "enable_thinking": True,
+        "temperature": 0.8,
+        "top_p": 0.90,
+        "max_token_multiplier": 0.35,
+    },
+
+    # Direct / non-thinking
+    "none": {
+        "enable_thinking": False,
+        "temperature": 0.7,
+        "top_p": 0.80,
+        "max_token_multiplier": 1.00,
+    },
+}
+
+
+# ============================================================
+# 3. REASONING ALIASES
+# ============================================================
+
+REASONING_ALIASES = {
+    "high": "xhigh",
+    "maximum": "xhigh",
+    "max": "xhigh",
+
+    "mid": "medium",
+    "balanced": "medium",
+
+    "minimal": "low",
+
+    "off": "none",
+    "false": "none",
+    "disabled": "none",
+    "disable": "none",
+
+    "non-thinking": "none",
+    "non_thinking": "none",
+
+    "instruct": "none",
+}
+
+
+def normalize_reasoning_effort(reasoning_effort):
+    """
+    Normalize the requested reasoning mode.
+
+    Supported canonical values:
+
+        xhigh
+        medium
+        low
+        none
+    """
+
+    if reasoning_effort is None:
+        return None
+
+    effort = str(
+        reasoning_effort
+    ).strip().lower()
+
+    effort = REASONING_ALIASES.get(
+        effort,
+        effort,
+    )
+
+    if effort not in REASONING_MODES:
+        raise ValueError(
+            "Invalid reasoning_effort "
+            f"'{reasoning_effort}'. "
+
+            "Supported values: "
+            + ", ".join(REASONING_MODES.keys())
+        )
+
+    return effort
+
+
+# ============================================================
+# 4. QUANTIZATION
+# ============================================================
+
 bnb_config = BitsAndBytesConfig(
-    load_in_4bit=True,                        # enable 4-bit loading
-    bnb_4bit_quant_type="nf4",               # NormalFloat4 — best quality/size trade-off
-    bnb_4bit_compute_dtype=torch.bfloat16,   # compute in bf16 for speed & stability
-    bnb_4bit_use_double_quant=True,          # nested quantisation → saves ~0.4 bits/param
+    load_in_4bit=True,
+
+    bnb_4bit_quant_type="nf4",
+
+    bnb_4bit_compute_dtype=torch.bfloat16,
+
+    bnb_4bit_use_double_quant=True,
+)
+
+
+# ============================================================
+# 5. LOAD TOKENIZER
+# ============================================================
+
+print("=" * 70)
+print("Loading G1-Preview")
+print("=" * 70)
+
+print(
+    f"Tokenizer: {MODEL_ID}"
 )
 
-print(f"Loading tokenizer: {MODEL_ID}")
-tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, trust_remote_code=True)
+tokenizer = AutoTokenizer.from_pretrained(
+    MODEL_ID,
+    trust_remote_code=True,
+)
+
+
+# ============================================================
+# 6. LOAD MODEL
+# ============================================================
+
+print(
+    f"Model: {MODEL_ID}"
+)
+
+print(
+    "Loading in 4-bit..."
+)
 
-print(f"Loading model in 4-bit: {MODEL_ID}")
 model = AutoModelForCausalLM.from_pretrained(
     MODEL_ID,
-    quantization_config=bnb_config,          # ← replaces torch_dtype=float16
-    device_map="auto",                        # ZeroGPU manages CUDA device
+
+    quantization_config=bnb_config,
+
+    device_map="auto",
+
     trust_remote_code=True,
 )
+
 model.eval()
 
-# ─────────────────────────────────────────────
-# 2. INFERENCE FUNCTION (ZeroGPU decorated)
-# ─────────────────────────────────────────────
+print(
+    "Model loaded successfully."
+)
+
+
+# ============================================================
+# 7. DETERMINE DEFAULT REASONING MODE
+# ============================================================
+
+def get_default_reasoning_effort(
+    messages,
+):
+    """
+    IMPORTANT BACKWARDS-COMPATIBILITY RULE:
+
+    Old prompt API:
+        thinking OFF
+
+    New messages API:
+        xhigh thinking
+    """
+
+    if messages is None:
+        return "none"
+
+    return "xhigh"
+
+
+def resolve_reasoning_effort(
+    reasoning_effort,
+    messages,
+):
+    """
+    Explicit reasoning_effort always wins.
+
+    If omitted:
+
+        old prompt API -> none
+
+        messages API -> xhigh
+    """
+
+    if reasoning_effort is None:
+
+        reasoning_effort = (
+            get_default_reasoning_effort(
+                messages
+            )
+        )
+
+    reasoning_effort = (
+        normalize_reasoning_effort(
+            reasoning_effort
+        )
+    )
+
+    return reasoning_effort
+
+
+# ============================================================
+# 8. BUILD MESSAGES
+# ============================================================
+
+def build_messages(
+    prompt=None,
+    messages=None,
+    system_prompt=DEFAULT_SYSTEM_PROMPT,
+):
+    """
+    Supports both the legacy and modern formats.
+    """
+
+    # --------------------------------------------------------
+    # Modern messages format
+    # --------------------------------------------------------
+
+    if messages is not None:
+
+        if not isinstance(
+            messages,
+            list,
+        ):
+            raise ValueError(
+                "'messages' must be a list."
+            )
+
+        final_messages = []
+
+        for message in messages:
+
+            if not isinstance(
+                message,
+                dict,
+            ):
+                raise ValueError(
+                    "Every message must be "
+                    "an object."
+                )
+
+            role = message.get(
+                "role"
+            )
+
+            content = message.get(
+                "content"
+            )
+
+            if role is None:
+                raise ValueError(
+                    "Every message requires "
+                    "a 'role'."
+                )
+
+            if content is None:
+                content = ""
+
+            final_messages.append(
+                {
+                    "role": role,
+                    "content": content,
+                }
+            )
+
+        # ----------------------------------------------------
+        # Add default system prompt if needed
+        # ----------------------------------------------------
+
+        has_system = any(
+            message.get("role") == "system"
+            for message in final_messages
+        )
+
+        if not has_system:
+
+            final_messages.insert(
+                0,
+                {
+                    "role": "system",
+                    "content": system_prompt,
+                },
+            )
+
+        return final_messages
+
+    # --------------------------------------------------------
+    # Legacy prompt format
+    # --------------------------------------------------------
+
+    return [
+        {
+            "role": "system",
+            "content": system_prompt,
+        },
+
+        {
+            "role": "user",
+            "content": prompt or "",
+        },
+    ]
+
+
+# ============================================================
+# 9. APPLY CHAT TEMPLATE
+# ============================================================
+
+def apply_chat_template(
+    messages,
+    reasoning_effort,
+):
+    """
+    Apply the model's chat template.
+
+    For Qwen-style models, enable_thinking controls
+    whether reasoning mode is enabled.
+    """
+
+    effort = normalize_reasoning_effort(
+        reasoning_effort
+    )
+
+    enable_thinking = (
+        REASONING_MODES[
+            effort
+        ]["enable_thinking"]
+    )
+
+    try:
+
+        # Preferred path
+        return tokenizer.apply_chat_template(
+            messages,
+
+            tokenize=False,
+
+            add_generation_prompt=True,
+
+            enable_thinking=enable_thinking,
+        )
+
+    except TypeError:
+
+        # Compatibility fallback
+        return tokenizer.apply_chat_template(
+            messages,
+
+            tokenize=False,
+
+            add_generation_prompt=True,
+        )
+
+
+# ============================================================
+# 10. CLEAN THINKING
+# ============================================================
+
+def remove_thinking(
+    response,
+):
+    """
+    Remove <think>...</think> from a response.
+    """
+
+    if not response:
+        return response
+
+    # Complete thinking section
+    if "<think>" in response:
+
+        if "</think>" in response:
+
+            response = response.split(
+                "</think>",
+                1,
+            )[1]
+
+        else:
+
+            # Incomplete thinking section
+            response = response.split(
+                "<think>",
+                1,
+            )[0]
+
+    return response.strip()
+
+
+def clean_response(
+    response,
+    preserve_thinking,
+):
+    """
+    Return either the complete model output or only
+    the final answer.
+    """
+
+    if preserve_thinking:
+        return response
+
+    return remove_thinking(
+        response
+    )
+
+
+# ============================================================
+# 11. GENERATION SETTINGS
+# ============================================================
+
+def get_generation_settings(
+    reasoning_effort,
+    max_new_tokens,
+    temperature,
+    top_p,
+    do_sample,
+):
+    """
+    Create generation settings for the selected
+    reasoning mode.
+    """
+
+    effort = normalize_reasoning_effort(
+        reasoning_effort
+    )
+
+    config = REASONING_MODES[
+        effort
+    ]
+
+    # --------------------------------------------------------
+    # Token budget
+    # --------------------------------------------------------
+
+    effective_max_tokens = int(
+        max_new_tokens
+        * config["max_token_multiplier"]
+    )
+
+    # Never let the multiplier reduce this below 64
+    effective_max_tokens = max(
+        64,
+        effective_max_tokens,
+    )
+
+    # --------------------------------------------------------
+    # Sampling
+    # --------------------------------------------------------
+
+    if effort == "none":
+
+        effective_temperature = (
+            temperature
+        )
+
+        effective_top_p = (
+            top_p
+        )
+
+    else:
+
+        effective_temperature = (
+            config["temperature"]
+        )
+
+        effective_top_p = (
+            config["top_p"]
+        )
+
+    settings = {
+        "max_new_tokens": effective_max_tokens,
+
+        "do_sample": do_sample,
+    }
+
+    # --------------------------------------------------------
+    # Only include sampling parameters when sampling
+    # is actually enabled.
+    # --------------------------------------------------------
+
+    if do_sample:
+
+        settings[
+            "temperature"
+        ] = effective_temperature
+
+        settings[
+            "top_p"
+        ] = effective_top_p
+
+    return settings
+
+
+# ============================================================
+# 12. GENERATE
+# ============================================================
+
 @spaces.GPU(duration=120)
 def generate(
-    prompt: str,
-    system_prompt: str = "You are a helpful assistant created by Smilyai-Labs. You are called G1-Preview.",
+    prompt: str = "",
+
+    system_prompt: str = DEFAULT_SYSTEM_PROMPT,
+
     max_new_tokens: int = 512,
+
     temperature: float = 0.7,
+
     top_p: float = 0.9,
+
     do_sample: bool = True,
-) -> str:
+
+    reasoning_effort=None,
+
+    preserve_thinking: bool = False,
+
+    messages=None,
+):
     """
-    Generate a text response from Mira-1-Large.
+    Main generation endpoint.
+
+    ------------------------------------------------------------
+    OLD FORMAT
+    ------------------------------------------------------------
+
+    {
+        "prompt": "Hello"
+    }
+
+    Default:
+        reasoning_effort = none
+
+
+    ------------------------------------------------------------
+    NEW FORMAT
+    ------------------------------------------------------------
 
-    Args:
-        prompt: The user message / prompt to send to the model.
-        system_prompt: System-level instruction for the model.
-        max_new_tokens: Maximum number of tokens to generate.
-        temperature: Sampling temperature (higher = more creative).
-        top_p: Nucleus sampling probability mass.
-        do_sample: Whether to use sampling (True) or greedy decoding (False).
+    {
+        "messages": [
+            {
+                "role": "user",
+                "content": "Hello"
+            }
+        ]
+    }
 
-    Returns:
-        The model's text response as a string.
+    Default:
+        reasoning_effort = xhigh
+
+
+    ------------------------------------------------------------
+    EXPLICIT REASONING
+    ------------------------------------------------------------
+
+    {
+        "prompt": "Solve this.",
+        "reasoning_effort": "xhigh"
+    }
+
+
+    ------------------------------------------------------------
+    THINKING VISIBILITY
+    ------------------------------------------------------------
+
+    preserve_thinking=true
+
+    returns:
+
+        <think>
+        ...
+        </think>
+
+        final answer
+
+
+    preserve_thinking=false
+
+    returns:
+
+        final answer
     """
-    messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user",   "content": prompt},
-    ]
 
-    text = tokenizer.apply_chat_template(
-        messages,
-        tokenize=False,
-        add_generation_prompt=True,
+    # --------------------------------------------------------
+    # Resolve reasoning mode
+    # --------------------------------------------------------
+
+    reasoning_effort = (
+        resolve_reasoning_effort(
+            reasoning_effort,
+            messages,
+        )
     )
 
-    inputs = tokenizer(text, return_tensors="pt").to(model.device)
+    # --------------------------------------------------------
+    # Build messages
+    # --------------------------------------------------------
+
+    final_messages = build_messages(
+        prompt=prompt,
+
+        messages=messages,
+
+        system_prompt=system_prompt,
+    )
+
+    # --------------------------------------------------------
+    # Apply template
+    # --------------------------------------------------------
+
+    text = apply_chat_template(
+        final_messages,
+
+        reasoning_effort,
+    )
+
+    # --------------------------------------------------------
+    # Tokenize
+    # --------------------------------------------------------
+
+    inputs = tokenizer(
+        text,
+
+        return_tensors="pt",
+    )
+
+    # --------------------------------------------------------
+    # Move inputs to model device
+    # --------------------------------------------------------
+
+    inputs = {
+        key: value.to(model.device)
+
+        for key, value in inputs.items()
+    }
+
+    # --------------------------------------------------------
+    # Generation settings
+    # --------------------------------------------------------
+
+    generation_settings = (
+        get_generation_settings(
+            reasoning_effort=reasoning_effort,
 
-    with torch.no_grad():
-        output_ids = model.generate(
-            **inputs,
             max_new_tokens=max_new_tokens,
+
             temperature=temperature,
+
             top_p=top_p,
+
             do_sample=do_sample,
-            pad_token_id=tokenizer.eos_token_id,
         )
+    )
+
+    generation_settings[
+        "pad_token_id"
+    ] = tokenizer.eos_token_id
+
+    # --------------------------------------------------------
+    # Generate
+    # --------------------------------------------------------
+
+    with torch.inference_mode():
+
+        output_ids = model.generate(
+            **inputs,
+
+            **generation_settings,
+        )
+
+    # --------------------------------------------------------
+    # Remove input tokens
+    # --------------------------------------------------------
+
+    input_length = (
+        inputs["input_ids"].shape[1]
+    )
+
+    new_tokens = output_ids[
+        0,
+        input_length:
+    ]
+
+    # --------------------------------------------------------
+    # Decode
+    # --------------------------------------------------------
+
+    response = tokenizer.decode(
+        new_tokens,
+
+        skip_special_tokens=True,
+    )
+
+    # --------------------------------------------------------
+    # Hide thinking if requested
+    # --------------------------------------------------------
+
+    response = clean_response(
+        response,
+
+        preserve_thinking=preserve_thinking,
+    )
 
-    new_tokens = output_ids[0][inputs["input_ids"].shape[1]:]
-    response = tokenizer.decode(new_tokens, skip_special_tokens=True)
     return response
 
 
-# ─────────────────────────────────────────────
-# 3. STREAMING INFERENCE (SSE / token-by-token)
-# ─────────────────────────────────────────────
+# ============================================================
+# 13. STREAMING GENERATION
+# ============================================================
+
 @spaces.GPU(duration=120)
 def generate_stream(
-    prompt: str,
-    system_prompt: str = "You are a helpful assistant.",
+    prompt: str = "",
+
+    system_prompt: str = DEFAULT_SYSTEM_PROMPT,
+
     max_new_tokens: int = 512,
+
     temperature: float = 0.7,
+
     top_p: float = 0.9,
-) -> str:
-    """
-    Stream a text response token-by-token from Mira-1-Large via SSE.
 
-    Args:
-        prompt: The user message / prompt.
-        system_prompt: System-level instruction for the model.
-        max_new_tokens: Maximum number of tokens to generate.
-        temperature: Sampling temperature.
-        top_p: Nucleus sampling probability mass.
+    do_sample: bool = True,
+
+    reasoning_effort=None,
+
+    preserve_thinking: bool = False,
 
-    Yields:
-        Partial response strings, growing with each new token.
+    messages=None,
+):
     """
-    from transformers import TextIteratorStreamer
-    from threading import Thread
+    Streaming generation endpoint.
 
-    messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user",   "content": prompt},
-    ]
-    text = tokenizer.apply_chat_template(
-        messages, tokenize=False, add_generation_prompt=True
+    Uses exactly the same reasoning rules as generate().
+    """
+
+    # --------------------------------------------------------
+    # Resolve reasoning
+    # --------------------------------------------------------
+
+    reasoning_effort = (
+        resolve_reasoning_effort(
+            reasoning_effort,
+            messages,
+        )
     )
-    inputs = tokenizer(text, return_tensors="pt").to(model.device)
+
+    # --------------------------------------------------------
+    # Build messages
+    # --------------------------------------------------------
+
+    final_messages = build_messages(
+        prompt=prompt,
+
+        messages=messages,
+
+        system_prompt=system_prompt,
+    )
+
+    # --------------------------------------------------------
+    # Apply template
+    # --------------------------------------------------------
+
+    text = apply_chat_template(
+        final_messages,
+
+        reasoning_effort,
+    )
+
+    # --------------------------------------------------------
+    # Tokenize
+    # --------------------------------------------------------
+
+    inputs = tokenizer(
+        text,
+
+        return_tensors="pt",
+    )
+
+    inputs = {
+        key: value.to(model.device)
+
+        for key, value in inputs.items()
+    }
+
+    # --------------------------------------------------------
+    # Generation settings
+    # --------------------------------------------------------
+
+    generation_settings = (
+        get_generation_settings(
+            reasoning_effort=reasoning_effort,
+
+            max_new_tokens=max_new_tokens,
+
+            temperature=temperature,
+
+            top_p=top_p,
+
+            do_sample=do_sample,
+        )
+    )
+
+    # --------------------------------------------------------
+    # Streamer
+    # --------------------------------------------------------
 
     streamer = TextIteratorStreamer(
-        tokenizer, skip_prompt=True, skip_special_tokens=True
+        tokenizer,
+
+        skip_prompt=True,
+
+        skip_special_tokens=True,
     )
 
-    gen_kwargs = dict(
-        **inputs,
-        max_new_tokens=max_new_tokens,
-        temperature=temperature,
-        top_p=top_p,
-        do_sample=True,
-        streamer=streamer,
-        pad_token_id=tokenizer.eos_token_id,
+    generation_settings.update(
+        {
+            "streamer": streamer,
+
+            "pad_token_id": (
+                tokenizer.eos_token_id
+            ),
+        }
+    )
+
+    # --------------------------------------------------------
+    # Background generation
+    # --------------------------------------------------------
+
+    thread = Thread(
+        target=model.generate,
+
+        kwargs={
+            **inputs,
+
+            **generation_settings,
+        },
     )
 
-    thread = Thread(target=model.generate, kwargs=gen_kwargs)
     thread.start()
 
+    # --------------------------------------------------------
+    # Stream
+    # --------------------------------------------------------
+
     partial = ""
+
     for new_text in streamer:
+
         partial += new_text
-        yield partial
 
+        if preserve_thinking:
+
+            yield partial
+
+        else:
+
+            yield remove_thinking(
+                partial
+            )
+
+
+# ============================================================
+# 14. OPENAI-STYLE CHAT
+# ============================================================
+
+@spaces.GPU(duration=120)
+def chat(
+    messages,
+
+    model: str = MODEL_ID,
+
+    max_tokens: int = 512,
+
+    temperature: float = 0.7,
+
+    top_p: float = 0.9,
+
+    reasoning_effort=None,
+
+    preserve_thinking: bool = False,
+):
+    """
+    OpenAI-style chat endpoint.
+
+    Since this uses the modern messages format,
+    omitted reasoning_effort defaults to xhigh.
+    """
+
+    response = generate(
+        messages=messages,
+
+        max_new_tokens=max_tokens,
+
+        temperature=temperature,
+
+        top_p=top_p,
+
+        reasoning_effort=reasoning_effort,
+
+        preserve_thinking=preserve_thinking,
+    )
+
+    return {
+        "id": "g1-preview-response",
+
+        "object": "chat.completion",
+
+        "model": model,
+
+        "choices": [
+            {
+                "index": 0,
+
+                "message": {
+                    "role": "assistant",
+
+                    "content": response,
+                },
+
+                "finish_reason": "stop",
+            }
+        ],
+    }
+
+
+# ============================================================
+# 15. SERVER
+# ============================================================
 
-# ───────────────────────────────���─────────────
-# 4. gr.Server — REST API + OPTIONAL SWAGGER UI
-# ─────────────────────────────────────────────
 app = Server(
-    title="Mira-1-Large API",
-    summary="ZeroGPU-backed REST API for Smilyai-labs/Mira-1-large (Qwen arch)",
-    version="1.0.0",
+    title="G1-Preview API",
+
+    summary=(
+        "ZeroGPU-backed API for "
+        "Smilyai-Labs G1-Preview"
+    ),
+
+    version=VERSION,
 )
 
-app.api(generate,        name="generate")
-app.api(generate_stream, name="generate_stream")
+
+# ============================================================
+# 16. REGISTER API ENDPOINTS
+# ============================================================
+
+# Legacy + modern generation
+app.api(
+    generate,
+
+    name="generate",
+)
+
+
+# Streaming generation
+app.api(
+    generate_stream,
+
+    name="generate_stream",
+)
+
+
+# OpenAI-style chat
+app.api(
+    chat,
+
+    name="chat",
+)
+
+
+# ============================================================
+# 17. HEALTH CHECK
+# ============================================================
 
 @app.get("/health")
 def health():
-    return {"status": "ok", "model": MODEL_ID}
 
-# ─────────────────────────────────────────────
-# 5. LAUNCH
-# ─────────────────────────────────────────────
+    return {
+        "status": "ok",
+
+        "model": MODEL_ID,
+
+        "version": VERSION,
+
+        "reasoning": {
+            "supported": True,
+
+            "modes": [
+                "xhigh",
+                "medium",
+                "low",
+                "none",
+            ],
+
+            "new_format_default": "xhigh",
+
+            "legacy_format_default": "none",
+        },
+
+        "compatibility": {
+            "legacy_prompt": True,
+
+            "messages": True,
+
+            "streaming": True,
+
+            "openai_style_chat": True,
+        },
+    }
+
+
+# ============================================================
+# 18. START SERVER
+# ============================================================
+
+print()
+print("=" * 70)
+print("G1-PREVIEW API READY")
+print("=" * 70)
+
+print(
+    f"Model: {MODEL_ID}"
+)
+
+print(
+    f"Version: {VERSION}"
+)
+
+print(
+    "Reasoning modes: "
+    "xhigh / medium / low / none"
+)
+
+print(
+    "Legacy prompt default: NONE"
+)
+
+print(
+    "Messages default: XHIGH"
+)
+
+print(
+    "Streaming: ENABLED"
+)
+
+print(
+    "OpenAI-style chat: ENABLED"
+)
+
+print("=" * 70)
+print()
+
 app.launch()