Update app.py

app.py

@@ -1,7 +1,5 @@
 import os
 import logging
-import base64
-import mimetypes
 from datetime import datetime
 from zoneinfo import ZoneInfo
 from functools import lru_cache
@@ -35,8 +33,6 @@ MODELS = {
     "meta-llama/Llama-3.3-70B-Instruct": {"max_tokens": 8192},
     "deepseek-ai/DeepSeek-V3": {"max_tokens": 131072},
     "openai/gpt-oss-120b": {"max_tokens": 8192},
-    # Hier könnten weitere Vision-Modelle stehen, sofern vom Anbieter unterstützt
-    "meta-llama/Llama-4-Maverick-17B-128E": {"max_tokens": 8192}, 
 }
 MODEL_CHOICES = list(MODELS.keys())
 MAX_TOKENS_GLOBAL = max(v["max_tokens"] for v in MODELS.values())
@@ -77,37 +73,29 @@ def clamp_tokens(model: str, max_tokens) -> int:
     except: v = 2048
     return max(1, min(v, model_max))
 
+# --- WICHTIG: Clean Response ohne Blockieren ---
 def _clean_response(text: str) -> str:
     marker = "<|channel|>final<|message|>"
+    # Wenn der Marker da ist -> alles davor abschneiden (sauber)
     if marker in text:
         return text.split(marker, 1)[-1]
+    # Wenn der Marker NICHT da ist -> Text trotzdem anzeigen
     return text
 
 def content_to_text(content) -> str:
-    """Extrahiert nur den Textteil aus komplexen Nachrichten für Logs/Suche."""
     if content is None: return ""
     if isinstance(content, str): return content
     if isinstance(content, list):
-        # Filtert Dateipfade (die meist Tupel oder Dicts sind) heraus
-        return "\n".join([str(p.get("text", "") or p.get("content", "")) for p in content if isinstance(p, dict) and "text" in p]).strip()
-    if isinstance(content, tuple): # Falls Gradio Datei-Tupel sendet
-        return "" 
+        return "\n".join([str(p.get("text", "") or p.get("content", "")) for p in content if isinstance(p, dict)]).strip()
     return str(content)
 
 def normalize_history_messages(history):
-    """Bereinigt die History, behält aber die Struktur für Gradio bei."""
     history = history or []
-    # Hier machen wir nichts destruktives, da Gradio 5+ komplexe Objekte (Bilder) in der History braucht.
-    return history
-
-def encode_image(image_path):
-    """Wandelt Bilddatei in Base64 String um."""
-    try:
-        with open(image_path, "rb") as image_file:
-            return base64.b64encode(image_file.read()).decode('utf-8')
-    except Exception as e:
-        logging.error(f"Fehler beim Kodieren des Bildes: {e}")
-        return None
+    out = []
+    for m in history:
+        if isinstance(m, dict) and m.get("role") in ("user", "assistant", "system"):
+            out.append({"role": m["role"], "content": content_to_text(m["content"])})
+    return out
 
 # ==============================================================================
 # 3) GOOGLE SEARCH
@@ -122,6 +110,7 @@ session = create_session()
 
 @lru_cache(maxsize=128)
 def search_web(query: str) -> str | None:
+    # Sicherheit: Wenn Keys fehlen, direkt None
     if not GOOGLE_API_KEY or not SEARCH_ENGINE_ID or not query:
         return None
     try:
@@ -145,62 +134,33 @@ def search_web(query: str) -> str | None:
 # ==============================================================================
 # 4) CHAT STREAM LOGIK
 # ==============================================================================
-def add_user_message(msg_data, history, profile: gr.OAuthProfile | None = None):
-    """Verarbeitet Input von MultimodalTextbox (Dict mit 'text' und 'files')."""
-    if history is None: history = []
-    
+def add_user_message(msg, history, profile: gr.OAuthProfile | None = None):
+    history = normalize_history_messages(history)
     if not _is_allowed(profile):
         history.append({"role": "assistant", "content": "🔒 Nicht autorisiert."})
-        return gr.MultimodalTextbox(value=None, interactive=False), history, ""
-
-    # msg_data ist bei MultimodalTextbox ein Dictionary: {'text': "...", 'files': ["path..."]}
-    text = ""
-    files = []
-    
-    if isinstance(msg_data, dict):
-        text = msg_data.get("text", "")
-        files = msg_data.get("files", [])
-    elif isinstance(msg_data, str):
-        text = msg_data
+        return "", history, ""
     
-    # Nachricht zusammenbauen für Gradio Chatbot (Lokale Anzeige)
-    if text or files:
-        # User Message Block erstellen
-        content_block = []
-        if text:
-            content_block.append(text) # Einfacher Text wird direkt angezeigt
-        
-        # Dateien (Bilder) hinzufügen
-        for f in files:
-            # Gradio Chatbot (type='messages') erwartet (path, alt_text) oder component tuple
-            # Wir nutzen hier den Pfad direkt oder verpacken ihn als Gradio Image Tuple
-            content_block.append((f,)) 
-        
-        # WICHTIG: Wenn Text und Bild gemischt sind, muss es als Liste übergeben werden
-        # Wenn nur Text, reicht String. Wenn nur Bild, Tuple.
-        # Gradio 5+ ist hier flexibel, aber am sichersten ist die Multimodal-Logik.
-        
-        if len(content_block) == 1 and isinstance(content_block[0], str):
-             history.append({"role": "user", "content": content_block[0]})
-        else:
-             # Gemischter Content oder nur Bild
-             # Für die reine Anzeige im Chatbot fügen wir es so hinzu:
-             history.append({"role": "user", "content": content_block})
-
-    return gr.MultimodalTextbox(value=None, interactive=True), history, ""
+    msg = (msg or "").strip()
+    if msg:
+        history.append({"role": "user", "content": msg})
+    return "", history, ""
 
 def chat_stream(
     history, model, system_prompt, max_tokens, temp, top_p, use_search,
     profile: gr.OAuthProfile | None = None,
 ):
+    history = normalize_history_messages(history)
     usage_text = ""
     
+    # 1. Auth Check
     if not _is_allowed(profile):
+        history.append({"role": "assistant", "content": "🔒 Nicht autorisiert."})
         yield history, "🔒"
         return
 
+    # 2. Key Check (Kritisch)
     if not client:
-        history.append({"role": "assistant", "content": "⚠️ **Konfigurations-Fehler:** `HYPERBOLIC_API_KEY` fehlt."})
+        history.append({"role": "assistant", "content": "⚠️ **Konfigurations-Fehler:** `HYPERBOLIC_API_KEY` fehlt in den Umgebungsvariablen."})
         yield history, "❌ Key fehlt"
         return
 
@@ -208,25 +168,15 @@ def chat_stream(
         yield history, usage_text
         return
 
-    # Letzte User-Nachricht analysieren (kann String oder Liste sein)
-    last_msg_content = history[-1]["content"]
-    user_text_for_search = ""
+    user_text = history[-1]["content"]
     
-    if isinstance(last_msg_content, str):
-        user_text_for_search = last_msg_content
-    elif isinstance(last_msg_content, list):
-        # Text extrahieren für Suche
-        for item in last_msg_content:
-            if isinstance(item, str):
-                user_text_for_search += item + " "
-
-    # Web Search Logic
+    # 3. Web Search Check (Warnung statt Crash)
     context_add = ""
-    if use_search and user_text_for_search.strip():
+    if use_search:
         if not GOOGLE_API_KEY or not SEARCH_ENGINE_ID:
-            history.append({"role": "assistant", "content": "⚠️ Google Suche an, aber Keys fehlen. Mache weiter..."})
+            history.append({"role": "assistant", "content": "⚠️ Google Suche an, aber `GOOGLE_API_KEY` oder `GOOGLE_CX` fehlen. Mache ohne Suche weiter..."})
         else:
-            search_res = search_web(user_text_for_search)
+            search_res = search_web(user_text)
             if search_res:
                 now = _local_now()
                 short_res = _truncate(search_res, WEB_CONTEXT_MAX_CHARS)
@@ -235,59 +185,21 @@ def chat_stream(
                     f"{short_res}\n----------------------------------"
                 )
 
-    # Messages für API aufbauen
+    # 4. Message Assembly
     messages = []
     if system_prompt.strip():
         messages.append({"role": "system", "content": system_prompt})
+    
+    for m in history[:-1]:
+        messages.append(m)
+    
+    messages.append({"role": "user", "content": user_text + context_add})
 
-    # History durchgehen und für API formatieren
-    for m in history:
-        role = m["role"]
-        content = m["content"]
-        
-        if role == "assistant":
-            messages.append({"role": role, "content": content_to_text(content)})
-            continue
-            
-        if role == "user":
-            # Fall 1: Nur Text
-            if isinstance(content, str):
-                # Kontext zur letzten Nachricht hinzufügen falls nötig
-                final_text = content
-                if m == history[-1] and context_add:
-                    final_text += context_add
-                messages.append({"role": role, "content": final_text})
-            
-            # Fall 2: Multimodal (Liste von Text/Dateien)
-            elif isinstance(content, list):
-                api_content_list = []
-                for item in content:
-                    if isinstance(item, str):
-                        # Textteil
-                        txt_val = item
-                        if m == history[-1] and context_add: # Context nur ans Ende
-                             txt_val += context_add
-                        api_content_list.append({"type": "text", "text": txt_val})
-                    elif isinstance(item, tuple) and len(item) > 0:
-                        # Dateipfad (Bild)
-                        file_path = item[0]
-                        mime_type, _ = mimetypes.guess_type(file_path)
-                        if not mime_type: mime_type = "image/jpeg"
-                        
-                        b64_img = encode_image(file_path)
-                        if b64_img:
-                            api_content_list.append({
-                                "type": "image_url",
-                                "image_url": {
-                                    "url": f"data:{mime_type};base64,{b64_img}"
-                                }
-                            })
-                messages.append({"role": role, "content": api_content_list})
-
-    # Placeholder für Antwort
+    # Placeholder
     history.append({"role": "assistant", "content": ""})
     yield history, usage_text
 
+    # 5. API Call
     try:
         completion = client.chat.completions.create(
             model=model,
@@ -303,24 +215,30 @@ def chat_stream(
         completion_tokens = 0
         
         for chunk in completion:
+            # Text Content sicher extrahieren
             delta = ""
             if hasattr(chunk, "choices") and chunk.choices and len(chunk.choices) > 0:
                 delta = chunk.choices[0].delta.content or ""
             
             if delta:
                 full_response += delta
+                # Hier der Fix: Wir zeigen immer Text an, damit nichts hängt.
+                # Wenn der Clean-Marker kommt, springt der Text um auf "sauber".
                 clean_text = _clean_response(full_response)
                 history[-1]["content"] = clean_text
                 yield history, usage_text
             
+            # Usage Stats
             if hasattr(chunk, "usage") and chunk.usage:
                 completion_tokens = chunk.usage.completion_tokens or 0
                 
+            # Finish Reason Check (Safety gegen NoneType Fehler)
             if hasattr(chunk, "choices") and chunk.choices and len(chunk.choices) > 0:
                 finish = getattr(chunk.choices[0], "finish_reason", None)
                 if finish in ["stop", "length"]:
                     break
         
+        # Final Costs
         if completion_tokens > 0:
             cost = cost_from_completion_tokens(model, completion_tokens)
             usage_text = f"Tokens: {completion_tokens} | Kosten: ${cost:.5f}"
@@ -338,22 +256,14 @@ def update_tokens_ui(model):
     val = int(MODELS.get(model, {}).get("max_tokens", 2048))
     return gr.update(maximum=val, value=min(2048, val))
 
-with gr.Blocks(title="Hyperbolic Chat (Multimodal)", fill_height=True) as demo:
-    gr.Markdown("## 🚀 Hyperbolic Chat (Multimodal • Env Vars)")
+with gr.Blocks(title="Hyperbolic Chat", fill_height=True) as demo:
+    gr.Markdown("## 🚀 Hyperbolic Chat (Env Vars • Allowlist: dtometzki)")
     
     with gr.Row():
         with gr.Column(scale=4):
-            # Type='messages' ist wichtig für Multimodal Rendering
-            chatbot = gr.Chatbot(height=700) 
+            chatbot = gr.Chatbot(height=700)
             with gr.Row():
-                # MultimodalTextbox statt normaler Textbox
-                msg_input = gr.MultimodalTextbox(
-                    file_count="multiple",
-                    placeholder="Eingabe (Text oder Bild)...",
-                    show_label=False,
-                    scale=4,
-                    file_types=["image"]
-                )
+                msg_input = gr.Textbox(placeholder="Eingabe...", show_label=False, scale=4)
                 submit_btn = gr.Button("Senden", variant="primary", scale=1)
             
             clear_btn = gr.Button("🗑️ Verlauf leeren")
@@ -376,7 +286,6 @@ with gr.Blocks(title="Hyperbolic Chat (Multimodal)", fill_height=True) as demo:
     # Event Wiring
     params = [chatbot, model_dd, system_txt, tokens_sld, temp_sld, top_p_sld, use_search_chk]
     
-    # Multimodal Input triggert direkt beim Absenden
     msg_input.submit(add_user_message, [msg_input, chatbot], [msg_input, chatbot], queue=False).then(
         chat_stream, params, [chatbot, usage_md], queue=True
     )
@@ -392,10 +301,10 @@ def check_keys_startup():
     print("\n" + "="*40)
     print("🔎 STARTUP CHECK:")
     if HYPERBOLIC_API_KEY: print("✅ HYPERBOLIC_API_KEY gefunden.")
-    else: print("❌ HYPERBOLIC_API_KEY fehlt!")
+    else: print("❌ HYPERBOLIC_API_KEY fehlt! Chat wird Fehler zeigen.")
     
     if GOOGLE_API_KEY and SEARCH_ENGINE_ID: print("✅ Google Search Keys gefunden.")
-    else: print("⚠️  Google Search Keys fehlen.")
+    else: print("⚠️  Google Search Keys fehlen (Suche wird ignoriert).")
     print("="*40 + "\n")
 
 check_keys_startup()