Sync from GitHub via hub-sync

VERSION

@@ -1 +1 @@
-e53591dafabc331639f010ada7aeec3330d50800
+9e5bc2edbb4834010576ab5c6e6cc01eebd0e242

main.py

@@ -32,6 +32,12 @@ def _env(name: str, default: str = "") -> str:
     return (os.getenv(name) or default).strip()
 
 
+def _csv_env(name: str, default_csv: str) -> list:
+    raw = _env(name, default_csv)
+    values = [item.strip() for item in raw.split(",") if item.strip()]
+    return values
+
+
 HF_TOKEN = _env("HF_TOKEN")
 HF_MODEL = _env("HF_MODEL", "zai-org/GLM-5.1")
 
@@ -56,6 +62,74 @@ GOOGLE_API_KEY = _env("GOOGLE_API_KEY")
 GOOGLE_MODEL = _env("GOOGLE_MODEL", "gemini-2.0-flash")
 
 
+HF_MODELS = _csv_env("HF_MODELS", HF_MODEL or "zai-org/GLM-5.1")
+GOOGLE_MODELS = _csv_env(
+    "GOOGLE_MODELS",
+    GOOGLE_MODEL or "gemini-2.0-flash,gemini-2.0-flash-lite,gemini-1.5-flash",
+)
+GITHUB_MODELS = _csv_env(
+    "GITHUB_MODELS",
+    GITHUB_MODEL or "openai/gpt-4.1-mini,meta/Llama-3.3-70B-Instruct,mistral-ai/Mistral-Nemo-Instruct-2407",
+)
+
+PROVIDER_MODELS = {
+    "hf": HF_MODELS,
+    "google": GOOGLE_MODELS,
+    "github": GITHUB_MODELS,
+}
+
+PROVIDER_LABELS = {
+    "hf": "Hugging Face (z.ai)",
+    "google": "Google Gemini",
+    "github": "GitHub Models",
+}
+
+UI_PROVIDERS = ["hf", "google", "github"]
+
+PRESET_CONFIGS = {
+    "ultra-cheap": {
+        "label": "Ultra Cheap",
+        "provider": "google",
+        "preferred_models": [
+            "gemini-2.0-flash-lite",
+            "gemini-1.5-flash",
+            "gemini-2.0-flash",
+        ],
+        "note": "Minimum-cost setup for rapid dev testing.",
+    },
+    "budget-dev": {
+        "label": "Budget Dev",
+        "provider": "github",
+        "preferred_models": [
+            "mistral-ai/Mistral-Nemo-Instruct-2407",
+            "openai/gpt-4.1-mini",
+            "meta/Llama-3.3-70B-Instruct",
+        ],
+        "note": "Lowest-cost first for rapid iteration.",
+    },
+    "balanced": {
+        "label": "Balanced",
+        "provider": "google",
+        "preferred_models": [
+            "gemini-2.0-flash",
+            "gemini-1.5-flash",
+            "gemini-2.0-flash-lite",
+        ],
+        "note": "Good quality and speed for day-to-day testing.",
+    },
+    "quality-check": {
+        "label": "Quality Check",
+        "provider": "hf",
+        "preferred_models": [
+            "zai-org/GLM-5.1",
+            "zai-org/GLM-5",
+            "zai-org/GLM-4.7",
+        ],
+        "note": "Higher-quality pass for final validation.",
+    },
+}
+
+
 # Explicit token passing helps avoid auth ambiguity across local and Space runtimes.
 hf_client = InferenceClient(token=HF_TOKEN) if HF_TOKEN else InferenceClient()
 
@@ -73,6 +147,74 @@ def _runtime_label() -> str:
     return f"Backend: {backend_name} | Model: {model_text}"
 
 
+def _default_model_for(provider: str) -> str:
+    provider = (provider or "").lower()
+    models = PROVIDER_MODELS.get(provider, [])
+    if models:
+        return models[0]
+
+    if provider == "hf":
+        return HF_MODEL
+    if provider == "google":
+        return GOOGLE_MODEL
+    if provider == "github":
+        return GITHUB_MODEL
+    return ""
+
+
+def _model_choices_for(provider: str) -> tuple:
+    provider = (provider or "").lower()
+    choices = PROVIDER_MODELS.get(provider, [])
+    selected = _default_model_for(provider)
+    if selected and selected not in choices:
+        choices = [selected] + choices
+    return choices, selected
+
+
+def _on_provider_change(provider: str):
+    choices, selected = _model_choices_for(provider)
+    return gr.update(choices=choices, value=selected)
+
+
+def _pick_model_for_preset(provider: str, preferred_models: list) -> str:
+    choices, selected = _model_choices_for(provider)
+    for model in preferred_models:
+        if model in choices:
+            return model
+    if choices:
+        return choices[0]
+    return selected
+
+
+def _apply_preset(preset_key: str):
+    preset = PRESET_CONFIGS.get(preset_key)
+    if not preset:
+        return (
+            gr.update(),
+            gr.update(),
+            "Preset not found.",
+        )
+
+    provider = preset["provider"]
+    model_choices, _ = _model_choices_for(provider)
+    selected_model = _pick_model_for_preset(provider, preset["preferred_models"])
+    if selected_model and selected_model not in model_choices:
+        model_choices = [selected_model] + model_choices
+
+    status = (
+        f"Applied preset: {preset['label']} | "
+        f"Provider: {PROVIDER_LABELS.get(provider, provider)} | "
+        f"Model: {selected_model or 'not-set'} | "
+        f"{preset['note']}"
+    )
+
+    return (
+        gr.update(value=provider),
+        gr.update(choices=model_choices, value=selected_model),
+        status,
+    )
+
+
 def _history_to_messages(history: list, user_message: str) -> list:
     messages = []
 
@@ -152,20 +294,22 @@ def _chat_openai_compatible(
     return _extract_content(message) or "(empty response)"
 
 
-def _chat_hf(messages: list) -> str:
+def _chat_hf(messages: list, model_override: str = "") -> str:
+    model = model_override or _default_model_for("hf")
     response = hf_client.chat_completion(
-        model=HF_MODEL,
+        model=model,
         messages=messages,
         max_tokens=AI_MAX_TOKENS,
     )
     return response.choices[0].message.content or "(empty response)"
 
 
-def _chat_github(messages: list) -> str:
+def _chat_github(messages: list, model_override: str = "") -> str:
+    model = model_override or _default_model_for("github")
     return _chat_openai_compatible(
         endpoint="https://models.github.ai/inference/chat/completions",
         api_key=GITHUB_TOKEN,
-        model=GITHUB_MODEL,
+        model=model,
         messages=messages,
     )
 
@@ -192,10 +336,11 @@ def _chat_fireworks(messages: list) -> str:
     )
 
 
-def _chat_google(messages: list) -> str:
+def _chat_google(messages: list, model_override: str = "") -> str:
+    model = model_override or _default_model_for("google")
     if not GOOGLE_API_KEY:
         raise ValueError("GOOGLE_API_KEY is missing.")
-    if not GOOGLE_MODEL:
+    if not model:
         raise ValueError("GOOGLE_MODEL is not configured.")
 
     contents = []
@@ -211,7 +356,7 @@ def _chat_google(messages: list) -> str:
             contents.append({"role": "user", "parts": [{"text": text}]})
 
     endpoint = (
-        f"https://generativelanguage.googleapis.com/v1beta/models/{GOOGLE_MODEL}:generateContent"
+        f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent"
         f"?key={GOOGLE_API_KEY}"
     )
     payload = {
@@ -242,13 +387,13 @@ def _chat_google(messages: list) -> str:
     return result or "(empty response)"
 
 
-def _chat_once(backend: str, messages: list) -> str:
+def _chat_once(backend: str, messages: list, model_override: str = "") -> str:
     if backend == "hf":
-        return _chat_hf(messages)
+        return _chat_hf(messages, model_override)
     if backend == "google":
-        return _chat_google(messages)
+        return _chat_google(messages, model_override)
     if backend == "github":
-        return _chat_github(messages)
+        return _chat_github(messages, model_override)
     if backend == "openrouter":
         return _chat_openrouter(messages)
     if backend == "fireworks":
@@ -258,15 +403,17 @@ def _chat_once(backend: str, messages: list) -> str:
     )
 
 
-def chat_response(message: str, history: list) -> str:
+def chat_response(message: str, history: list, selected_provider: str, selected_model: str) -> str:
     """Send a user message using the configured backend and return assistant text."""
     if not message or not message.strip():
         return "Please enter a message."
 
     messages = _history_to_messages(history, message.strip())
+    provider = (selected_provider or AI_BACKEND or "hf").lower().strip()
+    selected_model = (selected_model or "").strip()
 
     try:
-        if AI_BACKEND == "auto":
+        if provider == "auto":
             errors = []
             for backend in AI_FALLBACK_ORDER:
                 try:
@@ -275,7 +422,7 @@ def chat_response(message: str, history: list) -> str:
                     errors.append(f"{backend}: {exc}")
             return "All providers failed. " + " | ".join(errors)
 
-        return _chat_once(AI_BACKEND, messages)
+        return _chat_once(provider, messages, model_override=selected_model)
     except Exception as e:
         return f"Error: {str(e)}"
 
@@ -288,6 +435,41 @@ with gr.Blocks(title="GitHub + HuggingFace + AI Chat Demo") as demo:
     )
     gr.Markdown(f"**{_runtime_label()}**")
 
+    initial_provider = AI_BACKEND if AI_BACKEND in UI_PROVIDERS else "hf"
+    initial_model_choices, initial_model = _model_choices_for(initial_provider)
+
+    preset_dropdown = gr.Dropdown(
+        label="Quick Preset",
+        choices=[(v["label"], k) for k, v in PRESET_CONFIGS.items()],
+        value="ultra-cheap",
+    )
+    preset_apply_btn = gr.Button("Apply Preset")
+    preset_status = gr.Markdown("Preset tip: start with Ultra Cheap while iterating.")
+
+    provider_dropdown = gr.Dropdown(
+        label="Provider",
+        choices=[(PROVIDER_LABELS[p], p) for p in UI_PROVIDERS],
+        value=initial_provider,
+    )
+    model_dropdown = gr.Dropdown(
+        label="Model",
+        choices=initial_model_choices,
+        value=initial_model,
+        allow_custom_value=True,
+    )
+
+    provider_dropdown.change(
+        fn=_on_provider_change,
+        inputs=[provider_dropdown],
+        outputs=[model_dropdown],
+    )
+
+    preset_apply_btn.click(
+        fn=_apply_preset,
+        inputs=[preset_dropdown],
+        outputs=[provider_dropdown, model_dropdown, preset_status],
+    )
+
     gr.ChatInterface(
         chat_response,
         examples=[
@@ -295,6 +477,7 @@ with gr.Blocks(title="GitHub + HuggingFace + AI Chat Demo") as demo:
             "Explain quantum computing in simple terms.",
             "Give me a low-cost model selection strategy for dev vs prod.",
         ],
+        additional_inputs=[provider_dropdown, model_dropdown],
         title=None,
         description="Ask me anything!",
     )