Update app.py

app.py

@@ -1,6 +1,7 @@
 """
-🚀 NVIDIA AI Multi-Model Space
-- 38 modelli NVIDIA NIM VERIFICATI e FUNZIONANTI (test 2026-07-04)
+🚀 NVIDIA AI Multi-Model Space v3.1
+- 38 modelli NVIDIA NIM VERIFICATI e FUNZIONANTI
+- Auto-adattamento messaggi per modelli senza 'system role'
 - Memoria breve (RAM) e lunga (SQLite)
 - API REST GET/POST + SSE Streaming
 - Server MCP integrato
@@ -52,7 +53,6 @@ HTTP_TIMEOUT = httpx.Timeout(120.0, connect=10.0)
 
 # ══════════════════════════════════════════════════════════════
 # CATALOGO — SOLO MODELLI VERIFICATI FUNZIONANTI (test 2026-07-04)
-# 38 modelli confermati OK — ordinati per velocità
 # ══════════════════════════════════════════════════════════════
 
 NVIDIA_MODELS = {
@@ -87,7 +87,7 @@ NVIDIA_MODELS = {
         "name": "⚡ Gemma 2 2B",
         "category": "LLM",
         "context": 8192,
-        "description": "Compact Gemma — 212ms"
+        "description": "Compact Gemma — 212ms (no system role)"
     },
     "nvidia/llama-3.1-nemotron-nano-8b-v1": {
         "name": "⚡ Nemotron Nano 8B v1",
@@ -151,7 +151,7 @@ NVIDIA_MODELS = {
         "name": "🚀 Gemma 3n E2B",
         "category": "LLM",
         "context": 8192,
-        "description": "Gemma 3 Nano — 380ms"
+        "description": "Gemma 3 Nano — 380ms (no system role)"
     },
     "mistralai/mistral-nemotron": {
         "name": "🚀 Mistral Nemotron",
@@ -233,7 +233,7 @@ NVIDIA_MODELS = {
         "name": "💪 DiffusionGemma 26B",
         "category": "LLM",
         "context": 131072,
-        "description": "Diffusion-based Gemma — 843ms"
+        "description": "Diffusion-based Gemma — 843ms (no system role)"
     },
 
     # ═══════════════════════════════════════════════════════════
@@ -305,6 +305,67 @@ NVIDIA_MODELS = {
     },
 }
 
+# ══════════════════════════════════════════════════════════════
+# MODELLI CHE NON SUPPORTANO IL ROLE "system"
+# (verranno auto-convertiti: system → prefisso del primo user msg)
+# ══════════════════════════════════════════════════════════════
+
+MODELS_NO_SYSTEM_ROLE = {
+    # Gemma family
+    "google/gemma-2-2b-it",
+    "google/gemma-3n-e2b-it",
+    "google/diffusiongemma-26b-a4b-it",
+    # Aggiornato dinamicamente in caso di errore "system role not supported"
+}
+
+
+def normalize_messages(messages: list[dict], model: str) -> list[dict]:
+    """
+    Adatta i messaggi al modello:
+    - Se il modello non supporta 'system', converte il system prompt
+      come prefisso del primo messaggio user.
+    - Rimuove messaggi vuoti.
+    """
+    if not messages:
+        return messages
+
+    # Se il modello supporta system, non fare nulla
+    if model not in MODELS_NO_SYSTEM_ROLE:
+        return messages
+
+    # Estrai tutti i system prompt
+    system_parts = []
+    non_system = []
+    for m in messages:
+        if m.get("role") == "system":
+            content = (m.get("content") or "").strip()
+            if content:
+                system_parts.append(content)
+        else:
+            non_system.append(m)
+
+    if not system_parts:
+        return non_system if non_system else messages
+
+    # Prependi il system al primo user message
+    system_text = "\n\n".join(system_parts)
+    prepended = False
+    for i, m in enumerate(non_system):
+        if m.get("role") == "user":
+            non_system[i] = {
+                "role": "user",
+                "content": f"[System instructions]\n{system_text}\n\n[User message]\n{m.get('content', '')}"
+            }
+            prepended = True
+            break
+
+    if not prepended:
+        # Nessun user msg trovato, aggiungi come user
+        non_system.insert(0, {"role": "user", "content": system_text})
+
+    return non_system
+
+
 # ══════════════════════════════════════════════════════════════
 # MEMORIA
 # ══════════════════════════════════════════════════════════════
@@ -314,10 +375,26 @@ memory = MemoryManager(
     max_long_tokens=int(os.getenv("MAX_LONG_MEMORY_TOKENS", 50000))
 )
 
+
 # ═════════════════════════════════════════════��════════════════
-# CLIENT NVIDIA
+# CLIENT NVIDIA (con auto-adattamento system role)
 # ══════════════════════════════════════════════════════════════
 
+def _is_system_role_error(err_text: str) -> bool:
+    """Rileva errori dovuti a system role non supportato"""
+    if not err_text:
+        return False
+    err_lower = err_text.lower()
+    keywords = [
+        "system role not supported",
+        "does not support 'system'",
+        "does not support system",
+        "system role is not supported",
+        "role 'system' not allowed",
+    ]
+    return any(k in err_lower for k in keywords)
+
+
 async def nvidia_chat_stream(
     messages: list[dict],
     model: str = DEFAULT_MODEL,
@@ -328,6 +405,10 @@ async def nvidia_chat_stream(
     if not model or not str(model).strip():
         model = DEFAULT_MODEL
 
+    # 🎯 Auto-adatta i messaggi al modello
+    original_messages = messages
+    messages = normalize_messages(messages, model)
+
     headers = {
         "Authorization": f"Bearer {NVIDIA_API_KEY}",
         "Content-Type": "application/json",
@@ -348,12 +429,43 @@ async def nvidia_chat_stream(
             f"{NVIDIA_BASE_URL}/chat/completions",
             headers=headers, json=payload,
         ) as response:
+
+            # 🎯 AUTO-RETRY se system role non supportato
             if response.status_code != 200:
                 err = (await response.aread()).decode(errors="ignore")[:500]
+                if _is_system_role_error(err) and model not in MODELS_NO_SYSTEM_ROLE:
+                    print(f"[AUTO-FIX] Aggiunto {model} a MODELS_NO_SYSTEM_ROLE")
+                    MODELS_NO_SYSTEM_ROLE.add(model)
+                    # Ri-normalizza e riprova (con un nuovo stream)
+                    payload["messages"] = normalize_messages(original_messages, model)
+                    async with client.stream(
+                        "POST",
+                        f"{NVIDIA_BASE_URL}/chat/completions",
+                        headers=headers, json=payload,
+                    ) as retry_response:
+                        if retry_response.status_code != 200:
+                            err2 = (await retry_response.aread()).decode(errors="ignore")[:500]
+                            raise Exception(f"NVIDIA API {retry_response.status_code}: {err2}")
+                        async for line in retry_response.aiter_lines():
+                            if line.startswith("data: "):
+                                data = line[6:]
+                                if data.strip() == "[DONE]":
+                                    return
+                                try:
+                                    chunk = json.loads(data)
+                                    delta = chunk["choices"][0].get("delta", {})
+                                    if "content" in delta and delta["content"]:
+                                        yield delta["content"]
+                                except (json.JSONDecodeError, KeyError, IndexError):
+                                    continue
+                    return
+
+                # Altri errori
                 if response.status_code == 404:
-                    raise Exception(f"Modello '{model}' non disponibile")
+                    raise Exception(f"Modello '{model}' non disponibile (404)")
                 raise Exception(f"NVIDIA API {response.status_code}: {err}")
 
+            # Success normale
             async for line in response.aiter_lines():
                 if line.startswith("data: "):
                     data = line[6:]
@@ -379,36 +491,58 @@ async def nvidia_chat(
     if not model or not str(model).strip():
         model = DEFAULT_MODEL
 
+    # 🎯 Auto-adatta i messaggi al modello
+    original_messages = messages
+    messages = normalize_messages(messages, model)
+
     headers = {
         "Authorization": f"Bearer {NVIDIA_API_KEY}",
         "Content-Type": "application/json",
     }
-    payload = {
-        "model": model,
-        "messages": messages,
-        "temperature": temperature,
-        "max_tokens": max_tokens,
-        "top_p": top_p,
-        "stream": False,
-    }
 
-    if client:
-        resp = await client.post(
+    async def _do_request(c: httpx.AsyncClient, msgs: list[dict]) -> httpx.Response:
+        return await c.post(
             f"{NVIDIA_BASE_URL}/chat/completions",
-            headers=headers, json=payload,
+            headers=headers,
+            json={
+                "model": model,
+                "messages": msgs,
+                "temperature": temperature,
+                "max_tokens": max_tokens,
+                "top_p": top_p,
+                "stream": False,
+            },
         )
+
+    async def _call(c: httpx.AsyncClient) -> str:
+        resp = await _do_request(c, messages)
+
+        # 🎯 AUTO-RETRY se system role non supportato
+        if resp.status_code != 200:
+            err_body = resp.text[:500]
+            if _is_system_role_error(err_body) and model not in MODELS_NO_SYSTEM_ROLE:
+                print(f"[AUTO-FIX] Aggiunto {model} a MODELS_NO_SYSTEM_ROLE")
+                MODELS_NO_SYSTEM_ROLE.add(model)
+                # Retry con messaggi rinormalizzati
+                retry_msgs = normalize_messages(original_messages, model)
+                resp = await _do_request(c, retry_msgs)
+                if resp.status_code == 200:
+                    return resp.json()["choices"][0]["message"]["content"]
+
+            if resp.status_code == 404:
+                raise Exception(f"Modello '{model}' non disponibile")
+            raise Exception(f"NVIDIA API {resp.status_code}: {resp.text[:500]}")
+
+        try:
+            return resp.json()["choices"][0]["message"]["content"]
+        except (KeyError, IndexError, TypeError):
+            raise Exception(f"Risposta NVIDIA non valida per {model}: {resp.text[:200]}")
+
+    if client:
+        return await _call(client)
     else:
         async with httpx.AsyncClient(timeout=HTTP_TIMEOUT, limits=HTTP_LIMITS) as c:
-            resp = await c.post(
-                f"{NVIDIA_BASE_URL}/chat/completions",
-                headers=headers, json=payload,
-            )
-
-    if resp.status_code != 200:
-        if resp.status_code == 404:
-            raise Exception(f"Modello '{model}' non disponibile")
-        raise Exception(f"NVIDIA API {resp.status_code}: {resp.text[:500]}")
-    return resp.json()["choices"][0]["message"]["content"]
+            return await _call(c)
 
 
 # ══════════════════════════════════════════════════════════════
@@ -418,7 +552,7 @@ async def nvidia_chat(
 app = FastAPI(
     title="🚀 NVIDIA AI Multi-Model API",
     description=f"{len(NVIDIA_MODELS)} modelli verificati e funzionanti",
-    version="3.0.0",
+    version="3.1.0",
 )
 
 app.add_middleware(
@@ -484,9 +618,10 @@ async def root():
 async def info():
     return {
         "service": "🚀 NVIDIA AI Multi-Model",
-        "version": "3.0.0",
+        "version": "3.1.0",
         "default_model": DEFAULT_MODEL,
         "models_available": len(NVIDIA_MODELS),
+        "models_no_system_role": sorted(MODELS_NO_SYSTEM_ROLE),
         "all_models_verified": True,
         "last_verified": "2026-07-04",
     }
@@ -519,6 +654,7 @@ async def list_models(category: Optional[str] = None):
         "total": len(models),
         "categories": sorted(set(m["category"] for m in NVIDIA_MODELS.values())),
         "default": DEFAULT_MODEL,
+        "models_no_system_role": sorted(MODELS_NO_SYSTEM_ROLE),
     }
 
 
@@ -526,7 +662,11 @@ async def list_models(category: Optional[str] = None):
 async def get_model_info(model_id: str):
     if model_id not in NVIDIA_MODELS:
         raise HTTPException(404, f"Modello '{model_id}' non nel catalogo")
-    return {"model_id": model_id, **NVIDIA_MODELS[model_id]}
+    return {
+        "model_id": model_id,
+        **NVIDIA_MODELS[model_id],
+        "supports_system_role": model_id not in MODELS_NO_SYSTEM_ROLE,
+    }
 
 
 # ══════════════════════════════════════════════════════════════
@@ -535,10 +675,14 @@ async def get_model_info(model_id: str):
 
 @app.get("/v1/debug/test-model")
 async def debug_test_model(model: str = Query(DEFAULT_MODEL)):
+    """Testa un modello con system + user (come nella UI)"""
     try:
         start = time.time()
         response = await nvidia_chat(
-            messages=[{"role": "user", "content": "Say 'ok'."}],
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": "Say 'ok'."},
+            ],
             model=model, max_tokens=10,
         )
         return {
@@ -546,35 +690,51 @@ async def debug_test_model(model: str = Query(DEFAULT_MODEL)):
             "model": model,
             "response": response,
             "elapsed_ms": round((time.time() - start) * 1000),
+            "supports_system_role": model not in MODELS_NO_SYSTEM_ROLE,
         }
     except Exception as e:
         return {"status": "❌ ERROR", "model": model, "error": str(e)}
 
 
+@app.get("/v1/debug/no-system-models")
+async def debug_no_system_models():
+    """Lista modelli che non supportano il role 'system'"""
+    return {
+        "models_no_system_role": sorted(MODELS_NO_SYSTEM_ROLE),
+        "total": len(MODELS_NO_SYSTEM_ROLE),
+        "note": "Questi modelli ricevono automaticamente il system_prompt come prefisso del primo user message."
+    }
+
+
 async def _test_single(mid: str, client: httpx.AsyncClient, sem: asyncio.Semaphore) -> dict:
     async with sem:
         start = time.time()
         try:
+            # Test realistico: system + user (come la UI)
             resp = await nvidia_chat(
-                messages=[{"role": "user", "content": "hi"}],
-                model=mid, max_tokens=3, client=client,
+                messages=[
+                    {"role": "system", "content": "You are a helpful assistant."},
+                    {"role": "user", "content": "Say 'ok'"},
+                ],
+                model=mid, max_tokens=5, client=client,
             )
             return {
                 "model": mid, "status": "✅",
                 "elapsed_ms": round((time.time() - start) * 1000),
                 "preview": (resp or "")[:30],
+                "supports_system_role": mid not in MODELS_NO_SYSTEM_ROLE,
             }
         except Exception as e:
             return {
                 "model": mid, "status": "❌",
                 "elapsed_ms": round((time.time() - start) * 1000),
-                "error": str(e)[:120],
+                "error": str(e)[:150],
             }
 
 
 @app.get("/v1/debug/test-all-parallel")
 async def debug_test_all_parallel(concurrency: int = Query(15, ge=1, le=50)):
-    """⚡ Test parallelo async di tutti i modelli"""
+    """⚡ Test parallelo async di tutti i modelli del catalogo"""
     start = time.time()
     testable = list(NVIDIA_MODELS.keys())
     sem = asyncio.Semaphore(concurrency)
@@ -590,6 +750,7 @@ async def debug_test_all_parallel(concurrency: int = Query(15, ge=1, le=50)):
             "working": len(working),
             "broken": len(broken),
             "total_time_seconds": round(time.time() - start, 2),
+            "models_no_system_role": sorted(MODELS_NO_SYSTEM_ROLE),
         },
         "working_models_by_speed": working,
         "broken_models": broken,
@@ -690,7 +851,8 @@ async def _stream_response(req: ChatRequest, session_id: str):
         full = []
         try:
             yield {"event": "start", "data": json.dumps({
-                "session_id": session_id, "model": req.model, "timestamp": time.time()
+                "session_id": session_id, "model": req.model, "timestamp": time.time(),
+                "supports_system_role": req.model not in MODELS_NO_SYSTEM_ROLE,
             })}
             async for chunk in nvidia_chat_stream(
                 messages=messages, model=req.model,
@@ -768,7 +930,7 @@ async def delete_session(session_id: str):
 MCP_TOOLS = [
     {
         "name": "nvidia_chat",
-        "description": "Chat with any verified NVIDIA NIM model with memory",
+        "description": "Chat with any verified NVIDIA NIM model with memory (auto-adapts system role)",
         "inputSchema": {
             "type": "object",
             "properties": {
@@ -851,7 +1013,7 @@ async def mcp_endpoint(request: Request):
     if method == "initialize":
         return _ok({
             "protocolVersion": "2024-11-05",
-            "serverInfo": {"name": "nvidia-ai", "version": "3.0.0"},
+            "serverInfo": {"name": "nvidia-ai", "version": "3.1.0"},
             "capabilities": {
                 "tools": {"listChanged": False},
                 "resources": {"subscribe": False, "listChanged": False}
@@ -973,8 +1135,8 @@ code{{color:#7ec8e3}} table{{border-collapse:collapse;width:100%}}
 th,td{{padding:8px;border:1px solid #333;text-align:left}}
 th{{background:#16213e;color:#76b900}}
 </style></head><body>
-<h1>🚀 NVIDIA AI Multi-Model API v3.0</h1>
-<p><b>{len(NVIDIA_MODELS)} modelli VERIFICATI</b> e funzionanti (test 2026-07-04)</p>
+<h1>🚀 NVIDIA AI Multi-Model API v3.1</h1>
+<p><b>{len(NVIDIA_MODELS)} modelli VERIFICATI</b> + auto-adattamento system role</p>
 
 <h2>💬 Chat POST</h2>
 <pre>curl -X POST /v1/chat -H "Content-Type: application/json" \\
@@ -986,6 +1148,9 @@ th{{background:#16213e;color:#76b900}}
 <h2>⚡ Test Parallelo</h2>
 <pre>curl "/v1/debug/test-all-parallel?concurrency=15"</pre>
 
+<h2>🎯 Modelli senza system role (auto-adattati)</h2>
+<pre>curl "/v1/debug/no-system-models"</pre>
+
 <h2>🔌 MCP</h2>
 <pre>curl -X POST /v1/mcp -H "Content-Type: application/json" \\
   -d '{{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{{}}}}'</pre>
@@ -1057,12 +1222,12 @@ with gr.Blocks(
     css=".gradio-container{max-width:1400px !important;} footer{display:none !important;}"
 ) as demo:
     gr.Markdown(f"""
-    # 🚀 NVIDIA AI Multi-Model
-    **{len(NVIDIA_MODELS)} modelli VERIFICATI** e funzionanti • Memoria • SSE • MCP • Async
+    # 🚀 NVIDIA AI Multi-Model v3.1
+    **{len(NVIDIA_MODELS)} modelli VERIFICATI** + auto-adattamento system role • Memoria • SSE • MCP
 
     🏠 [UI](/) | 📖 [Docs](/api-docs) | 🔧 [Swagger](/docs) | 🔌 [MCP](/v1/mcp)
 
-    **Default:** `{DEFAULT_MODEL}` (⚡ fastest at 153ms)
+    **Default:** `{DEFAULT_MODEL}` (⚡ 153ms)
     """)
 
     with gr.Tab("💬 Chat"):
@@ -1093,12 +1258,16 @@ with gr.Blocks(
 
     with gr.Tab("🤖 Modelli"):
         gr.Markdown(f"### ���� Catalogo — {len(NVIDIA_MODELS)} modelli verificati")
-        data = [[mi["category"], mi["name"], mid, mi["context"], mi["description"]]
+        data = [[mi["category"], mi["name"], mid, mi["context"], mi["description"],
+                 "❌" if mid in MODELS_NO_SYSTEM_ROLE else "✅"]
                 for mid, mi in NVIDIA_MODELS.items()]
-        gr.Dataframe(headers=["Cat", "Nome", "ID", "Context", "Descrizione"], value=data, interactive=False, wrap=True)
+        gr.Dataframe(
+            headers=["Cat", "Nome", "ID", "Context", "Descrizione", "System Role"],
+            value=data, interactive=False, wrap=True
+        )
 
     with gr.Tab("🚀 Test Parallelo"):
-        gr.Markdown("### ⚡ Verifica live tutti i modelli in parallelo")
+        gr.Markdown("### ⚡ Verifica live tutti i modelli in parallelo (con system prompt)")
         test_btn = gr.Button("🚀 Testa tutti i modelli", variant="primary")
         test_output = gr.JSON(label="Risultati")
 
@@ -1116,6 +1285,7 @@ with gr.Blocks(
                 "✅ funzionanti": len(working),
                 "❌ non_funzionanti": len(broken),
                 "totale": len(results),
+                "models_no_system_role_detected": sorted(MODELS_NO_SYSTEM_ROLE),
                 "working_by_speed": working,
                 "broken": broken,
             }
@@ -1131,6 +1301,29 @@ with gr.Blocks(
         stats_btn.click(get_memory_info, inputs=[mem_session], outputs=[mem_display])
         clear_mem_btn.click(clear_session_memory, inputs=[mem_session], outputs=[mem_display])
 
+    with gr.Tab("🎯 System Role"):
+        gr.Markdown(f"""
+        ## 🎯 Auto-adattamento System Role
+
+        Alcuni modelli (come **Gemma 2**, **Gemma 3n**, **DiffusionGemma**) non supportano il ruolo `system`.
+
+        Questo Space **rileva automaticamente** l'errore e converte il `system_prompt` come **prefisso** del primo messaggio user.
+
+        ### 📋 Modelli attualmente in auto-adattamento:
+        """)
+        no_sys_display = gr.JSON(label="Modelli senza system role")
+
+        def get_no_sys():
+            return {
+                "models_no_system_role": sorted(MODELS_NO_SYSTEM_ROLE),
+                "total": len(MODELS_NO_SYSTEM_ROLE),
+                "note": "Aggiornato dinamicamente quando viene rilevato un errore 'system role not supported'"
+            }
+
+        refresh_btn = gr.Button("🔄 Aggiorna lista")
+        refresh_btn.click(get_no_sys, outputs=[no_sys_display])
+        demo.load(get_no_sys, outputs=[no_sys_display])
+
     with gr.Tab("📖 Docs"):
         gr.Markdown("""
         ## 📖 Documentazione
@@ -1145,6 +1338,7 @@ with gr.Blocks(
         - `GET /v1/chat/stream` — SSE streaming
         - `POST /v1/mcp` — MCP JSON-RPC
         - `GET /v1/debug/test-all-parallel` — Test parallelo
+        - `GET /v1/debug/no-system-models` — Modelli senza system role
         """)