Update app.py

app.py

@@ -9,35 +9,30 @@ from groq import Groq
 from mistralai import Mistral
 import google.generativeai as genai
 
-# --- CONFIGURAÇÕES GLOBAIS ---
+# --- CONFIGURAÇÕES DE CLIENTES ---
 
 # 1. LOCAL (H200)
 LOCAL_MODEL_ID = "Qwen/Qwen2.5-Coder-32B-Instruct"
 local_model = None
 local_tokenizer = None
 
-# 2. CLIENTES DE NUVEM
-groq_key = os.environ.get("GROQ_API_KEY")
-groq_client = Groq(api_key=groq_key) if groq_key else None
+# 2. NUVEM
+groq_client = Groq(api_key=os.environ.get("GROQ_API_KEY")) if os.environ.get("GROQ_API_KEY") else None
+mistral_client = Mistral(api_key=os.environ.get("MISTRAL_API_KEY")) if os.environ.get("MISTRAL_API_KEY") else None
+if os.environ.get("GEMINI_API_KEY"):
+    genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))
 
-mistral_key = os.environ.get("MISTRAL_API_KEY")
-mistral_client = Mistral(api_key=mistral_key) if mistral_key else None
-
-gemini_key = os.environ.get("GEMINI_API_KEY")
-if gemini_key:
-    genai.configure(api_key=gemini_key)
-
-# --- HELPER: Converte imagem para Base64 (Para Mistral) ---
+# --- HELPER: Imagem para Base64 (Mistral) ---
 def encode_image(image_path):
     with open(image_path, "rb") as image_file:
         return base64.b64encode(image_file.read()).decode('utf-8')
 
-# --- FUNÇÃO 1: LOCAL H200 (ZeroGPU) ---
+# --- FUNÇÃO 1: LOCAL H200 ---
 @spaces.GPU(duration=60)
 def run_local_h200(messages):
-    # Verifica se tem imagem (não suportado)
-    if isinstance(messages[-1]['content'], list):
-         return "⚠️ Erro: O modelo local Qwen não suporta imagens."
+    # O Qwen local não suporta imagens via Gradio fácil, rejeitamos se tiver
+    if isinstance(messages[-1]['content'], list) or (isinstance(messages[-1]['content'], str) and os.path.exists(messages[-1]['content'])):
+         return "⚠️ O modelo Qwen Local H200 suporta apenas texto. Use Gemini ou Pixtral para imagens."
 
     global local_model, local_tokenizer
     if local_model is None:
@@ -47,191 +42,187 @@ def run_local_h200(messages):
             LOCAL_MODEL_ID, torch_dtype=torch.bfloat16, device_map="cuda"
         )
     
-    text = local_tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    # Extrai apenas o texto da última mensagem se for complexa
+    text_content = messages[-1]['content']
+    if isinstance(text_content, list): # Fallback defensivo
+        text_content = next((item['text'] for item in text_content if item['type'] == 'text'), "")
+
+    # Simplifica histórico para texto puro pro Qwen
+    text_messages = []
+    for m in messages[:-1]:
+        content = m['content']
+        if isinstance(content, list):
+             content = next((item['text'] for item in content if item['type'] == 'text'), "")
+        text_messages.append({"role": m['role'], "content": content})
+    text_messages.append({"role": "user", "content": text_content})
+
+    text = local_tokenizer.apply_chat_template(text_messages, tokenize=False, add_generation_prompt=True)
     inputs = local_tokenizer([text], return_tensors="pt").to(local_model.device)
     outputs = local_model.generate(**inputs, max_new_tokens=2048, temperature=0.6, do_sample=True)
     return local_tokenizer.decode(outputs[0][inputs.input_ids.shape[1]:], skip_special_tokens=True)
 
 # --- FUNÇÃO 2: GROQ ---
 def run_groq(messages, model_id):
-    # Verifica se tem imagem (não suportado)
-    if isinstance(messages[-1]['content'], list):
-         return "⚠️ Erro: Os modelos da Groq não suportam imagens."
-         
-    if not groq_client: return "❌ Erro: Configure a GROQ_API_KEY."
+    # Groq (Llama) não vê imagem
+    last_content = messages[-1]['content']
+    if isinstance(last_content, list) or (isinstance(last_content, str) and os.path.exists(last_content)):
+         return "⚠️ Modelos Llama (Groq) não veem imagens. Use Pixtral ou Gemini."
+
+    if not groq_client: return "❌ Erro: Configure GROQ_API_KEY."
+    
+    # Converte formato Gradio novo (list of dicts) para OpenAI simples
+    clean_messages = []
+    for m in messages:
+        content = m['content']
+        if isinstance(content, list): # Remove imagem se tiver sobrado no histórico
+             content = next((item['text'] for item in content if item['type'] == 'text'), "")
+        clean_messages.append({"role": m['role'], "content": content})
+
     try:
         completion = groq_client.chat.completions.create(
-            model=model_id, messages=messages, temperature=0.7, max_tokens=4096
+            model=model_id, messages=clean_messages, temperature=0.7, max_tokens=4096
         )
         return completion.choices[0].message.content
     except Exception as e: return f"❌ Groq Error: {e}"
 
-# --- FUNÇÃO 3: MISTRAL (Com suporte a Pixtral/Imagem) ---
+# --- FUNÇÃO 3: MISTRAL (Com Pixtral) ---
 def run_mistral(messages, model_id):
-    if not mistral_client: return "❌ Erro: Configure a MISTRAL_API_KEY."
+    if not mistral_client: return "❌ Erro: Configure MISTRAL_API_KEY."
 
-    # Processa mensagens para lidar com imagens para o Pixtral
-    processed_messages = []
+    mistral_msgs = []
     for msg in messages:
-        if isinstance(msg['content'], list):
-            # É uma mensagem multimodal
-            content_list = []
-            for item in msg['content']:
+        role = msg['role']
+        content = msg['content']
+        
+        if isinstance(content, str):
+            # Se for caminho de arquivo (Gradio faz isso as vezes)
+            if os.path.exists(content): 
+                base64_img = encode_image(content)
+                mistral_msgs.append({"role": role, "content": [{"type": "image_url", "image_url": f"data:image/jpeg;base64,{base64_img}"}]})
+            else:
+                mistral_msgs.append({"role": role, "content": content})
+        elif isinstance(content, list):
+            new_content = []
+            for item in content:
                 if item['type'] == 'text':
-                    content_list.append({"type": "text", "text": item['text']})
-                elif item['type'] == 'image_url':
-                    # Gradio passa o caminho do arquivo, convertemos para base64 data URL
-                    image_path = item['image_url']['url']
-                    base64_image = encode_image(image_path)
-                    # Assumindo JPEG por padrão, o ideal seria detectar
-                    content_list.append({
-                        "type": "image_url",
-                        "image_url": f"data:image/jpeg;base64,{base64_image}" 
-                    })
-            processed_messages.append({"role": msg['role'], "content": content_list})
-        else:
-            # Mensagem só de texto
-            processed_messages.append(msg)
+                    new_content.append({"type": "text", "text": item['text']})
+                elif item['type'] == 'image': # Gradio 5 usa 'image' ou caminho
+                    image_path = item['image']['path'] if isinstance(item['image'], dict) else item['image']
+                    base64_img = encode_image(image_path)
+                    new_content.append({"type": "image_url", "image_url": f"data:image/jpeg;base64,{base64_img}"})
+            mistral_msgs.append({"role": role, "content": new_content})
 
     try:
-        print(f"🇫🇷 Mistral Target: {model_id} (Multimodal: {'pixtral' in model_id})")
-        res = mistral_client.chat.complete(model=model_id, messages=processed_messages)
+        res = mistral_client.chat.complete(model=model_id, messages=mistral_msgs)
         return res.choices[0].message.content
-    except Exception as e:
-        if "image" in str(e).lower() and "pixtral" not in model_id:
-             return f"⚠️ Erro: Você enviou uma imagem, mas o modelo '{model_id}' não suporta. Use o Pixtral."
-        return f"❌ Mistral Error: {e}"
+    except Exception as e: return f"❌ Mistral Error: {e}"
 
-# --- FUNÇÃO 4: GEMINI (Com suporte a Imagem) ---
+# --- FUNÇÃO 4: GEMINI ---
 def run_gemini(messages, model_id):
-    if not gemini_key: return "❌ Erro: Configure a GEMINI_API_KEY."
+    if not os.environ.get("GEMINI_API_KEY"): return "❌ Erro: Configure GEMINI_API_KEY."
     try:
         model = genai.GenerativeModel(model_id)
+        chat_history = []
         
-        gemini_history = []
-        for m in messages:
-            role = "user" if m['role'] == 'user' else "model"
-            
-            if isinstance(m['content'], list):
-                # Mensagem multimodal
-                parts = []
-                for item in m['content']:
-                    if item['type'] == 'text':
-                        parts.append(item['text'])
-                    elif item['type'] == 'image_url':
-                        # Gemini aceita PIL Image ou caminho
-                        image_path = item['image_url']['url']
-                        img = Image.open(image_path)
-                        parts.append(img)
-                gemini_history.append({"role": role, "parts": parts})
+        # Converte histórico para formato Gemini
+        for msg in messages[:-1]: # Tudo menos a última (que é o prompt atual)
+            role = "user" if msg['role'] == "user" else "model"
+            parts = []
+            content = msg['content']
+            if isinstance(content, str):
+                parts.append(content)
+            elif isinstance(content, list):
+                for item in content:
+                    if item['type'] == 'text': parts.append(item['text'])
+                    elif item['type'] == 'image': 
+                        path = item['image']['path'] if isinstance(item['image'], dict) else item['image']
+                        parts.append(Image.open(path))
+            chat_history.append({"role": role, "parts": parts})
+
+        # Processa a mensagem atual
+        last_msg = messages[-1]
+        current_parts = []
+        content = last_msg['content']
+        if isinstance(content, str):
+            if os.path.exists(content): # É um upload direto sem texto
+                 current_parts.append(Image.open(content))
             else:
-                # Mensagem só de texto
-                gemini_history.append({"role": role, "parts": [m['content']]})
-
-        # A última mensagem é o prompt atual
-        prompt_parts = gemini_history.pop()
-        
-        # Inicia o chat com o histórico
-        chat = model.start_chat(history=gemini_history)
-        response = chat.send_message(prompt_parts['parts'])
-        
+                 current_parts.append(content)
+        elif isinstance(content, list):
+            for item in content:
+                if item['type'] == 'text': current_parts.append(item['text'])
+                elif item['type'] == 'image': 
+                    path = item['image']['path'] if isinstance(item['image'], dict) else item['image']
+                    current_parts.append(Image.open(path))
+
+        chat = model.start_chat(history=chat_history)
+        response = chat.send_message(current_parts)
         return response.text
     except Exception as e: return f"❌ Gemini Error ({model_id}): {e}"
 
-# --- ROTEADOR CENTRAL (Adaptado para Multimodal) ---
+# --- ROTEADOR ---
 def router(message, history, model_selector):
-    # 'message' agora é um dicionário: {"text": "...", "files": ["path/to/image.jpg"]}
+    # No Gradio 5, 'message' já vem formatado, e 'history' também.
+    # Precisamos combinar para passar pro backend
     
-    # 1. Formata o Histórico
-    messages = []
-    for user_msg, bot_msg in history:
-        # Mensagem do usuário (pode ter imagem)
-        if isinstance(user_msg, dict):
-            content = [{"type": "text", "text": user_msg.get("text", "")}]
-            for file_path in user_msg.get("files", []):
-                content.append({"type": "image_url", "image_url": {"url": file_path}})
-            messages.append({"role": "user", "content": content})
-        elif user_msg:
-            messages.append({"role": "user", "content": user_msg})
-            
-        # Mensagem do bot (sempre texto por enquanto)
-        if bot_msg:
-            messages.append({"role": "assistant", "content": bot_msg})
-
-    # 2. Formata a Mensagem Atual
-    current_content = [{"type": "text", "text": message.get("text", "")}]
-    for file_path in message.get("files", []):
-        current_content.append({"type": "image_url", "image_url": {"url": file_path}})
+    # Constrói a lista completa de mensagens
+    full_history = history + [message]
     
-    # Se for só texto, simplifica para string (para compatibilidade com funções antigas)
-    if len(current_content) == 1 and current_content[0]['type'] == 'text' and not message.get("files"):
-        messages.append({"role": "user", "content": current_content[0]['text']})
-    else:
-        # Se tiver imagem ou for misto, manda a lista estruturada
-        messages.append({"role": "user", "content": current_content})
-
-    # --- MAPEAMENTO DE MODELOS (SEUS IDs COMPROVADOS!) ---
+    if "Gemini" in model_selector:
+        # Extrai ID do Gemini (ex: "✨ Google: Gemini 3" -> "gemini-3.0-pro-preview")
+        if "Gemini 3" in model_selector: tid = "gemini-3.0-pro-preview" #
+        elif "2.5 Pro" in model_selector: tid = "gemini-2.5-pro"         #
+        elif "2.5 Flash" in model_selector: tid = "gemini-2.5-flash"     #
+        elif "2.0 Flash" in model_selector: tid = "gemini-2.0-flash-exp" # Hacker ID real
+        else: tid = "gemini-1.5-flash"
+        return run_gemini(full_history, tid)
     
-    # Rota Google
-    if "Gemini 3" in model_selector:
-        return run_gemini(messages, "gemini-3.0-pro-preview") #
-    elif "Gemini 2.5 Pro" in model_selector:
-        return run_gemini(messages, "gemini-2.5-pro") #
-    elif "Gemini 2.5 Flash" in model_selector:
-        return run_gemini(messages, "gemini-2.5-flash") #
-    elif "Gemini 2.0 Flash" in model_selector:
-        return run_gemini(messages, "gemini-2.0-flash") #
-        
-    # Rota Groq
-    elif "Llama 3.3" in model_selector:
-        return run_groq(messages, "llama-3.3-70b-versatile")
-        
-    # Rota Mistral
-    elif "Pixtral Large" in model_selector:
-        return run_mistral(messages, "pixtral-large-latest") # VISÃO!
-    elif "Mistral Large 2512" in model_selector:
-        return run_mistral(messages, "mistral-large-2512")
-    elif "Magistral Medium" in model_selector:
-        return run_mistral(messages, "magistral-medium-latest")
-    elif "Codestral 2508" in model_selector:
-        return run_mistral(messages, "codestral-2508")
+    elif "Mistral" in model_selector:
+        if "Pixtral" in model_selector: tid = "pixtral-large-latest"
+        elif "2512" in model_selector: tid = "mistral-large-2512"
+        elif "Magistral" in model_selector: tid = "magistral-medium-latest"
+        elif "Codestral" in model_selector: tid = "codestral-2508"
+        else: tid = "mistral-large-latest"
+        return run_mistral(full_history, tid)
+
+    elif "Groq" in model_selector:
+        return run_groq(full_history, "llama-3.3-70b-versatile")
         
-    # Rota Local
     elif "H200" in model_selector:
-        return run_local_h200(messages)
-    else:
-        return "⚠️ Modelo não configurado no roteador."
+        return run_local_h200(full_history)
+        
+    return "Modelo desconhecido."
 
-# --- UI ---
+# --- INTERFACE ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🔀 APIDOST Router V6: Vision Unleashed")
+    gr.Markdown("# 🔀 APIDOST V6: Vision Unleashed")
     
     with gr.Row():
         model_dropdown = gr.Dropdown(
             choices=[
-                "✨ Google: Gemini 3.0 Pro (Preview)",
+                "✨ Google: Gemini 3.0 Pro (Experimental)",
                 "✨ Google: Gemini 2.5 Pro",
                 "✨ Google: Gemini 2.5 Flash",
-                "✨ Google: Gemini 2.0 Flash",
+                "✨ Google: Gemini 2.0 Flash (Exp)",
                 "☁️ Groq: Llama 3.3 70B",
                 "🇫🇷 Mistral: Pixtral Large (Vision) 🖼️",
                 "🇫🇷 Mistral: Large 2512 (Dez/25)",
                 "🇫🇷 Mistral: Magistral Medium (VIP)",
-                "🇫🇷 Mistral: Codestral 2508 (Code)",
                 "🔥 Local H200: Qwen 2.5 Coder"
             ],
-            value="🇫🇷 Mistral: Pixtral Large (Vision) 🖼️", 
-            label="Escolha o Cérebro",
+            value="🇫🇷 Mistral: Pixtral Large (Vision) 🖼️",
+            label="Cérebro",
             interactive=True
         )
-    
-    # ATENÇÃO: multimodal=True HABILITA O UPLOAD DE IMAGENS
+
+    # type="messages" é o padrão novo do Gradio 5 para chat multimodal
     chat = gr.ChatInterface(
-        fn=router, 
+        fn=router,
+        type="messages", 
         additional_inputs=[model_dropdown],
-        multimodal=True, # O SEGREDO ESTÁ AQUI!
-        textbox=gr.MultimodalTextbox(placeholder="Digite e/ou cole uma imagem...", file_types=["image"], interactive=True)
+        multimodal=True
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    # A SOLUÇÃO DO ERRO 'LOCALHOST' ESTÁ AQUI:
+    demo.launch(server_name="0.0.0.0", server_port=7860, ssr_mode=False)