Update app.py

app.py

@@ -1,108 +1,310 @@
 import os
 import hmac
+from typing import Iterable, Generator, Optional, Dict, Any
+
 import gradio as gr
+
+# --- Optional: install SDKs in your Space (add to requirements.txt) ---
+# openai>=1.40.0
+# google-genai>=0.3.0
+
+# OpenAI-compatible SDK (used for OpenAI and DeepSeek)
 from openai import OpenAI
 
+# Gemini SDK
+try:
+    from google import genai
+    from google.genai import types as genai_types
+except ImportError:
+    genai = None
+    genai_types = None
+
+
+# -------- Helpers: secret/backdoor resolution (optional pattern you already like) --------
+def _timing_safe_eq(a: str, b: str) -> bool:
+    return hmac.compare_digest(a, b)
+
 
-def _resolve_openai_key(user_input: str) -> str | None:
+def _resolve_key(user_value: str, secret_gate_name: str, secret_payload_name: str) -> Optional[str]:
     """
-    If `user_input` is an 8-digit code matching BACKDOOR_KEY (Space secret),
-    return the OPENAI_KEY (Space secret). Otherwise return `user_input`.
-    Never prints or returns secrets; just resolves which to use.
+    If user_value is an 8-digit code that matches ENV[secret_gate_name], return ENV[secret_payload_name].
+    Else return user_value (or None if empty).
     """
-    user_input = (user_input or "").strip()
+    user_value = (user_value or "").strip()
+    backdoor_code = (os.getenv(secret_gate_name) or "").strip()
+    if user_value.isdigit() and len(user_value) == 8 and backdoor_code:
+        if _timing_safe_eq(user_value, backdoor_code):
+            return (os.getenv(secret_payload_name) or "").strip() or None
+    return user_value or None
 
-    backdoor_code = (os.getenv("BACKDOOR_KEY") or "").strip()
-    # Only treat as backdoor attempt if it's exactly 8 digits and we have a BACKDOOR_KEY.
-    is_candidate_code = user_input.isdigit() and len(user_input) == 8 and backdoor_code
 
-    if is_candidate_code and hmac.compare_digest(user_input, backdoor_code):
-        # Use the real key stored as a Space secret
-        resolved = os.getenv("OPENAI_KEY")
-        if not resolved:
-            # Fail safe if OPENAI_KEY isn't configured
-            return None
-        return resolved
+# -------- Providers --------
+OPENAI_MODELS = [
+    "gpt-4o",
+    "o4-mini",          # aka gpt-4o-mini family; see OpenAI docs
+    "gpt-3.5-turbo",
+]
 
-    # Fallback to whatever the user typed (normal behavior)
-    return user_input if user_input else None
+GEMINI_MODELS = [
+    "gemini-1.5-flash",
+    "gemini-2.0-flash",  # available via Gemini API / Vertex; keep synced with docs
+]
 
+DEEPSEEK_MODELS = [
+    "deepseek-chat",
+]
 
-def complete_text(prompt, max_tokens, temperature, top_p, openai_api_key_input):
+PROVIDERS = {
+    "OpenAI": OPENAI_MODELS,
+    "Gemini": GEMINI_MODELS,
+    "DeepSeek": DEEPSEEK_MODELS,
+}
+
+
+# -------- Streaming runners per provider --------
+def stream_openai_like(
+    model: str,
+    prompt: str,
+    temperature: float,
+    top_p: float,
+    max_tokens: int,
+    seed: Optional[int],
+    api_key: str,
+    base_url: Optional[str] = None,
+) -> Generator[str, None, None]:
     """
-    Get a plain text completion from OpenAI.
-    Supports a secret 8-digit passcode in the API key field that swaps in the
-    Space secret OPENAI_KEY when it matches BACKDOOR_KEY.
+    Streams Chat Completions from OpenAI or any OpenAI-compatible endpoint (DeepSeek).
     """
-    resolved_key = _resolve_openai_key(openai_api_key_input)
-    if not resolved_key:
-        return "⚠️ Missing or invalid API key. (Tip: set OPENAI_KEY/BACKDOOR_KEY in Space secrets, or paste a valid key.)"
+    client = OpenAI(api_key=api_key, base_url=base_url) if base_url else OpenAI(api_key=api_key)
+    # Chat format even for simple prompting
+    kwargs: Dict[str, Any] = dict(
+        model=model,
+        messages=[{"role": "user", "content": prompt}],
+        temperature=temperature,
+        top_p=top_p,
+        max_tokens=max_tokens,
+        stream=True,
+    )
+    if seed is not None:
+        kwargs["seed"] = seed  # supported in recent OpenAI SDKs
 
+    response_text = ""
     try:
-        client = OpenAI(api_key=resolved_key)
+        stream = client.chat.completions.create(**kwargs)
+        for part in stream:
+            delta = part.choices[0].delta if hasattr(part.choices[0], "delta") else None
+            # Some SDKs use .delta, some have .message or .text in streaming chunks
+            token = ""
+            if delta and getattr(delta, "content", None):
+                token = delta.content
+            elif hasattr(part.choices[0], "message") and part.choices[0].message.content:
+                token = part.choices[0].message.content
+            elif hasattr(part.choices[0], "text") and part.choices[0].text:  # fallback
+                token = part.choices[0].text
 
-        response_text = ""
-        stream = client.completions.create(
-            # NOTE: gpt-3.5-turbo-instruct is legacy. Consider switching to a current instruct-capable model.
-            model="gpt-3.5-turbo-instruct",
-            prompt=prompt,
-            max_tokens=int(max_tokens),
-            temperature=float(temperature),
-            top_p=float(top_p),
-            stream=True,
-        )
-
-        for event in stream:
-            if hasattr(event, "choices") and event.choices:
-                token = event.choices[0].text or ""
+            if token:
                 response_text += token
                 yield response_text
+    except Exception as e:
+        yield f"❌ OpenAI-compatible error: {type(e).__name__}: {e}"
+
+
+def stream_gemini(
+    model: str,
+    prompt: str,
+    temperature: float,
+    top_p: float,
+    max_tokens: int,
+    seed: Optional[int],
+    api_key: str,
+) -> Generator[str, None, None]:
+    """
+    Streams from Google Gemini via google.genai SDK.
+    """
+    if genai is None:
+        yield "❌ Gemini SDK not installed. Add `google-genai` to requirements.txt."
+        return
+
+    client = genai.Client(api_key=api_key)
+
+    # Build generation config (Gemini supports these fields; seed is optional)
+    gen_cfg = {
+        "temperature": float(temperature),
+        "top_p": float(top_p),
+        "max_output_tokens": int(max_tokens),
+    }
+    if seed is not None:
+        gen_cfg["seed"] = int(seed)
+
+    response_text = ""
+    try:
+        with client.responses.stream(
+            model=model,
+            input=prompt,
+            config=genai_types.GenerateContentConfig(
+                temperature=gen_cfg["temperature"],
+                top_p=gen_cfg["top_p"],
+                max_output_tokens=gen_cfg["max_output_tokens"],
+                seed=gen_cfg.get("seed"),
+            ),
+        ) as stream:
+            for event in stream:
+                # Each event may carry incremental text in candidates[0].content.parts[…].text
+                try:
+                    for cand in getattr(event, "candidates", []) or []:
+                        parts = getattr(cand, "content", None)
+                        if parts and getattr(parts, "parts", None):
+                            for p in parts.parts:
+                                txt = getattr(p, "text", None)
+                                if txt:
+                                    response_text += txt
+                                    yield response_text
+                except Exception:
+                    # Best-effort incremental parse
+                    pass
+
+            # Ensure final text is yielded (for some drivers, the last event is summary)
+            final = getattr(stream, "text", None)
+            if final and final not in response_text:
+                response_text += final
+                yield response_text
 
     except Exception as e:
-        # Don't leak secrets or full tracebacks to the UI.
-        yield f"❌ Error while generating completion: {type(e).__name__}. Check your model name, key, or params."
+        yield f"❌ Gemini error: {type(e).__name__}: {e}"
+
 
+# -------- Gradio callback --------
+def multi_llm_complete(
+    provider: str,
+    model: str,
+    prompt: str,
+    max_tokens: int,
+    temperature: float,
+    top_p: float,
+    seed_text: str,
+    # API keys (user enters). You can also support the 8-digit backdoor pattern per provider:
+    openai_key_input: str,
+    gemini_key_input: str,
+    deepseek_key_input: str,
+):
+    # Resolve seed
+    seed: Optional[int] = None
+    if seed_text and str(seed_text).strip().isdigit():
+        seed = int(str(seed_text).strip())
 
+    # Resolve keys (optionally allow an 8-digit backdoor per provider)
+    if provider == "OpenAI":
+        api_key = _resolve_key(openai_key_input, "OPENAI_BACKDOOR_KEY", "OPENAI_KEY") or ""
+        if not api_key:
+            yield "⚠️ Enter a valid OpenAI API key."
+            return
+        # Stream via OpenAI
+        for chunk in stream_openai_like(
+            model=model,
+            prompt=prompt,
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=max_tokens,
+            seed=seed,
+            api_key=api_key,
+            base_url=None,
+        ):
+            yield chunk
+
+    elif provider == "Gemini":
+        api_key = _resolve_key(gemini_key_input, "GEMINI_BACKDOOR_KEY", "GEMINI_KEY") or ""
+        if not api_key:
+            yield "⚠️ Enter a valid Gemini API key."
+            return
+        for chunk in stream_gemini(
+            model=model,
+            prompt=prompt,
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=max_tokens,
+            seed=seed,
+            api_key=api_key,
+        ):
+            yield chunk
+
+    elif provider == "DeepSeek":
+        api_key = _resolve_key(deepseek_key_input, "DEEPSEEK_BACKDOOR_KEY", "DEEPSEEK_KEY") or ""
+        if not api_key:
+            yield "⚠️ Enter a valid DeepSeek API key."
+            return
+        # DeepSeek: OpenAI-compatible endpoint
+        for chunk in stream_openai_like(
+            model=model,
+            prompt=prompt,
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=max_tokens,
+            seed=seed,
+            api_key=api_key,
+            base_url="https://api.deepseek.com",
+        ):
+            yield chunk
+
+    else:
+        yield "❌ Unknown provider selection."
+
+
+# -------- UI --------
 with gr.Blocks() as demo:
-    gr.Markdown("## ✍️ Text Completion Demo (OpenAI instruct)")
+    gr.Markdown("## 🔀 Multi-LLM Chat (OpenAI • Gemini • DeepSeek)")
     gr.Markdown(
-        "Enter a prompt, adjust decoding parameters, and watch the model complete your text."
+        "Pick a provider & model, enter the provider’s API key, tune params, and stream the reply. "
+        "Seed (if supported) improves reproducibility."
     )
 
     with gr.Row():
-        with gr.Column(scale=2):
-            prompt = gr.Textbox(
-                label="Prompt",
-                placeholder="Type the beginning of your text...",
-                lines=4,
-            )
-            max_tokens = gr.Slider(
-                minimum=1, maximum=1024, value=100, step=1, label="Max tokens"
+        with gr.Column(scale=1):
+            provider = gr.Dropdown(
+                choices=list(PROVIDERS.keys()),
+                value="OpenAI",
+                label="Provider",
             )
-            temperature = gr.Slider(
-                minimum=0.0, maximum=2.0, value=0.7, step=0.1, label="Temperature"
+            model = gr.Dropdown(
+                choices=PROVIDERS["OpenAI"],
+                value="gpt-4o",
+                label="Model",
             )
-            top_p = gr.Slider(
-                minimum=0.1, maximum=1.0, value=1.0, step=0.05, label="Top-p"
-            )
-            api_key = gr.Textbox(
-                placeholder="sk-... Paste your OpenAI API key here (or enter 8-digit passcode)",
-                label="🔑 OpenAI API Key",
-                type="password",
-            )
-            submit = gr.Button("Generate Completion")
-        with gr.Column(scale=3):
-            output = gr.Textbox(
-                label="Generated Completion",
-                lines=15,
+
+            def _update_models(p):
+                return gr.update(choices=PROVIDERS[p], value=PROVIDERS[p][0])
+
+            provider.change(_update_models, inputs=provider, outputs=model)
+
+            prompt = gr.Textbox(
+                label="Prompt",
+                placeholder="Ask anything…",
+                lines=6,
             )
 
+            max_tokens = gr.Slider(1, 4096, value=512, step=1, label="Max tokens")
+            temperature = gr.Slider(0.0, 2.0, value=0.7, step=0.1, label="Temperature")
+            top_p = gr.Slider(0.0, 1.0, value=1.0, step=0.01, label="Top-p")
+            seed = gr.Textbox(label="🎲 Seed (optional integer)", placeholder="e.g., 42")
+
+        with gr.Column(scale=1):
+            gr.Markdown("### API Keys (per provider)")
+            openai_key = gr.Textbox(label="OpenAI API Key", type="password", placeholder="sk-... or 8-digit passcode")
+            gemini_key = gr.Textbox(label="Gemini API Key", type="password", placeholder="AI Studio key or 8-digit passcode")
+            deepseek_key = gr.Textbox(label="DeepSeek API Key", type="password", placeholder="ds-... or 8-digit passcode")
+
+            submit = gr.Button("▶️ Generate", variant="primary")
+            output = gr.Textbox(label="Response", lines=18)
+
     submit.click(
-        fn=complete_text,
-        inputs=[prompt, max_tokens, temperature, top_p, api_key],
+        fn=multi_llm_complete,
+        inputs=[
+            provider, model, prompt,
+            max_tokens, temperature, top_p, seed,
+            openai_key, gemini_key, deepseek_key
+        ],
         outputs=output,
     )
 
 if __name__ == "__main__":
-    # On Spaces, server_name='0.0.0.0' helps; share=False by default.
+    # On Spaces, consider server_name='0.0.0.0'
     demo.launch()