Update app.py

app.py

@@ -9,28 +9,31 @@ from groq import Groq
 from mistralai import Mistral
 import google.generativeai as genai
 
-# --- CONFIGURAÇÕES DE CLIENTES ---
-
-# 1. LOCAL (H200)
+# --- CONFIGURAÇÕES ---
+# 1. LOCAL
 LOCAL_MODEL_ID = "Qwen/Qwen2.5-Coder-32B-Instruct"
 local_model = None
 local_tokenizer = None
 
-# 2. NUVEM (Carrega chaves do ambiente)
+# 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"))
 
-# --- HELPER: Imagem para Base64 ---
+# --- HELPER ---
 def encode_image(image_path):
-    with open(image_path, "rb") as image_file:
-        return base64.b64encode(image_file.read()).decode('utf-8')
+    try:
+        with open(image_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode('utf-8')
+    except Exception:
+        return None
+
+# --- FUNÇÕES DE INFERÊNCIA ---
 
-# --- FUNÇÃO 1: LOCAL H200 ---
 @spaces.GPU(duration=60)
 def run_local_h200(messages):
-    # Qwen local não suporta imagem fácil via API, bloqueia se tiver
+    # Qwen Local (Texto puro)
     for m in messages:
         if isinstance(m['content'], list):
              return "⚠️ O modelo Qwen Local H200 suporta apenas texto. Use Gemini ou Pixtral para imagens."
@@ -43,32 +46,34 @@ def run_local_h200(messages):
             LOCAL_MODEL_ID, torch_dtype=torch.bfloat16, device_map="cuda"
         )
     
-    # Processa histórico simples para texto
     text = local_tokenizer.apply_chat_template(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):
-    # Groq não vê imagem
+    # Groq (Texto puro)
     for m in messages:
         if isinstance(m['content'], list):
              return "⚠️ Modelos Groq não veem imagens. Use Pixtral ou Gemini."
-
+    
     if not groq_client: return "❌ Erro: Configure GROQ_API_KEY."
+    
+    # Limpa formato para OpenAI
+    clean_msgs = []
+    for m in messages:
+        clean_msgs.append({"role": m['role'], "content": m['content']})
+
     try:
         completion = groq_client.chat.completions.create(
-            model=model_id, messages=messages, temperature=0.7, max_tokens=4096
+            model=model_id, messages=clean_msgs, 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 (Pixtral) ---
 def run_mistral(messages, model_id):
     if not mistral_client: return "❌ Erro: Configure MISTRAL_API_KEY."
 
-    # Formata mensagens para Mistral (texto ou imagem url)
     mistral_msgs = []
     for msg in messages:
         role = msg['role']
@@ -76,16 +81,19 @@ def run_mistral(messages, model_id):
         
         if isinstance(content, str):
             mistral_msgs.append({"role": role, "content": content})
-        elif isinstance(content, list): # Multimodal
+        elif isinstance(content, list):
             new_content = []
             for item in content:
                 if item['type'] == 'text':
                     new_content.append({"type": "text", "text": item['text']})
-                elif item['type'] == 'image': 
-                    # Gradio 5 passa o path da imagem
-                    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}"})
+                elif item['type'] == 'image_url':
+                    # O router já mandou como data url ou path, vamos garantir
+                    url = item['image_url']['url']
+                    if url.startswith("data:image"):
+                        new_content.append({"type": "image_url", "image_url": url})
+                    else:
+                        b64 = encode_image(url)
+                        if b64: new_content.append({"type": "image_url", "image_url": f"data:image/jpeg;base64,{b64}"})
             mistral_msgs.append({"role": role, "content": new_content})
 
     try:
@@ -93,88 +101,112 @@ def run_mistral(messages, model_id):
         return res.choices[0].message.content
     except Exception as e: return f"❌ Mistral Error: {e}"
 
-# --- FUNÇÃO 4: GEMINI ---
 def run_gemini(messages, model_id):
     if not os.environ.get("GEMINI_API_KEY"): return "❌ Erro: Configure GEMINI_API_KEY."
     try:
         model = genai.GenerativeModel(model_id)
         chat_history = []
         
-        # Histórico (Gradio 5 Messages -> Gemini Parts)
         for msg in messages[:-1]:
             role = "user" if msg['role'] == "user" else "model"
             parts = []
             content = msg['content']
-            if isinstance(content, str):
-                parts.append(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))
+                    elif item['type'] == 'image_url':
+                        path = item['image_url']['url']
+                        if not path.startswith("data:"): parts.append(Image.open(path))
             chat_history.append({"role": role, "parts": parts})
 
-        # Mensagem Atual (Última)
-        current_content = messages[-1]['content']
+        last_msg = messages[-1]
         current_parts = []
-        if isinstance(current_content, str):
-            current_parts.append(current_content)
-        elif isinstance(current_content, list):
-            for item in current_content:
+        content = last_msg['content']
+        if isinstance(content, str): 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))
+                elif item['type'] == 'image_url':
+                    path = item['image_url']['url']
+                    if not path.startswith("data:"): 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 ---
+# --- ROTEADOR INTELIGENTE (Compatível Gradio 4) ---
 def router(message, history, model_selector):
-    # No Gradio 5 com type="messages", history já vem atualizado e message é o payload novo
-    # Mas para o chat funcionar fluido, vamos reconstruir o array completo
-    # history é lista de dicts [{'role':'user', ...}, {'role':'assistant', ...}]
+    # Em Gradio 4 com multimodal=True, 'message' é um dict: {'text': '...', 'files': ['path']}
     
-    # 1. Constrói o histórico completo incluindo a mensagem atual
-    full_history = history + [message]
+    # 1. Reconstrói histórico padronizado
+    formatted_history = []
+    for user_msg, bot_msg in history:
+        # User (pode ter imagem antiga, mas Gradio 4 passa files separados no histórico visual)
+        # Simplificando: Assumimos texto no histórico visual do Gradio 4
+        if isinstance(user_msg, dict): # Caso raro no history
+             formatted_history.append({"role": "user", "content": user_msg.get("text")})
+        else:
+             formatted_history.append({"role": "user", "content": str(user_msg)})
+        
+        # Bot
+        if bot_msg:
+            formatted_history.append({"role": "assistant", "content": str(bot_msg)})
+
+    # 2. Formata a mensagem ATUAL (Onde a imagem está agora)
+    current_content = []
+    text_input = message.get("text", "")
+    files = message.get("files", [])
+
+    if text_input:
+        current_content.append({"type": "text", "text": text_input})
     
-    # 2. Roteamento
+    for file_path in files:
+        # Adiciona imagem para processamento
+        current_content.append({"type": "image_url", "image_url": {"url": file_path}})
+
+    # Se não tem imagem, manda string simples (melhor compatibilidade)
+    if not files:
+        formatted_history.append({"role": "user", "content": text_input})
+    else:
+        formatted_history.append({"role": "user", "content": current_content})
+
+    # 3. Roteamento
     if "Gemini" in model_selector:
-        if "3.0" in model_selector: tid = "gemini-3.0-pro-preview" # Aposta no beta
+        tid = "gemini-1.5-flash" # Default seguro
+        if "3.0" 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"
-        else: tid = "gemini-1.5-flash"
-        return run_gemini(full_history, tid)
+        return run_gemini(formatted_history, tid)
     
     elif "Mistral" in model_selector:
+        tid = "mistral-large-latest"
         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)
+        return run_mistral(formatted_history, tid)
 
     elif "Groq" in model_selector:
-        return run_groq(full_history, "llama-3.3-70b-versatile")
+        return run_groq(formatted_history, "llama-3.3-70b-versatile")
         
     elif "H200" in model_selector:
-        return run_local_h200(full_history)
+        return run_local_h200(formatted_history)
         
     return "Modelo desconhecido."
 
-# --- INTERFACE GRADIO 5 ---
-with gr.Blocks(fill_height=True) as demo:
-    gr.Markdown("# 🔀 APIDOST V7: The Vision Update")
+# --- INTERFACE ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🔀 APIDOST V7: Vision Update (Stable)")
     
     with gr.Row():
         model_dropdown = gr.Dropdown(
             choices=[
                 "✨ Google: Gemini 3.0 Pro (Experimental)",
                 "✨ Google: Gemini 2.5 Flash",
+                "✨ Google: Gemini 2.0 Flash (Exp)",
                 "☁️ Groq: Llama 3.3 70B",
                 "🇫🇷 Mistral: Pixtral Large (Vision) 🖼️",
                 "🇫🇷 Mistral: Large 2512 (Dez/25)",
@@ -185,13 +217,13 @@ with gr.Blocks(fill_height=True) as demo:
             interactive=True
         )
 
-    # type="messages" é vital para o Gradio 5 entender o formato novo
+    # REMOVIDO type="messages" (Isso corrige o erro!)
     chat = gr.ChatInterface(
         fn=router,
-        type="messages", 
         additional_inputs=[model_dropdown],
-        multimodal=True,
+        multimodal=True, # Isso ativa o upload de imagens no Gradio 4
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    # Configuração de rede padrão
+    demo.launch(server_name="0.0.0.0", server_port=7860)