Upload 5 files

Dockerfile

@@ -1,9 +1,15 @@
 FROM python:3.11-slim
+
 WORKDIR /app
+
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
+
 RUN mkdir -p templates
+
 COPY templates/ templates/
 COPY main.py .
+
 EXPOSE 7860
+
 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -6,3 +6,19 @@ colorTo: gray
 sdk: docker
 pinned: false
 ---
+
+# Mission Control AI
+
+Full-stack agent orchestration — FastAPI backend with direct LLM calls + pixel office frontend.
+
+## Setup
+
+Add these secrets in your Space settings (Settings → Variables and secrets):
+
+- `GOOGLE_API_KEY` — Google AI Studio key
+- `OPENROUTER_API_KEY` — OpenRouter key  
+- `GROQ_API_KEY` — Groq key (substitute/fallback)
+
+## Health check
+
+Visit `/api/health` to verify all providers are configured.

main.py

@@ -1,39 +1,208 @@
+import os
+import asyncio
+import httpx
 from fastapi import FastAPI, Request
 from fastapi.responses import HTMLResponse, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
-import httpx
 from datetime import datetime
 from pathlib import Path
 
 app = FastAPI()
+app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_methods=["*"], allow_headers=["*"])
 
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
+# ── ENV KEYS (set in HuggingFace Space Secrets) ──────────────────────────
+GOOGLE_API_KEY    = os.getenv("GOOGLE_API_KEY", "")
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "")
+GROQ_API_KEY      = os.getenv("GROQ_API_KEY", "")
 
-N8N_WEBHOOK = "https://n8n-mission-control.fly.dev/webhook/mission-control"
-
-mission_history = []
+# ── PROVIDERS ─────────────────────────────────────────────────────────────
+PROVIDERS = {
+    "gemini": {
+        "name": "Google Gemini",
+        "type": "gemini",
+        "key": GOOGLE_API_KEY,
+    },
+    "openrouter": {
+        "name": "OpenRouter",
+        "type": "openai_compat",
+        "key": OPENROUTER_API_KEY,
+        "base_url": "https://openrouter.ai/api/v1/chat/completions",
+        "headers": {
+            "HTTP-Referer": "https://huggingface.co/spaces/vfven/mission-control-ui",
+            "X-Title": "Mission Control AI",
+        },
+    },
+    "groq": {
+        "name": "Groq",
+        "type": "openai_compat",
+        "key": GROQ_API_KEY,
+        "base_url": "https://api.groq.com/openai/v1/chat/completions",
+        "headers": {},
+    },
+}
 
+# ── AGENTS ────────────────────────────────────────────────────────────────
 AGENTS = [
-    {"key": "manager",   "name": "Manager",   "role": "Project Coordinator"},
-    {"key": "developer", "name": "Developer", "role": "Senior Engineer"},
-    {"key": "analyst",   "name": "Analyst",   "role": "Business Analyst"},
+    {
+        "key": "manager",
+        "name": "Manager",
+        "role": "Gerente de proyecto experto en coordinar equipos y planificar estrategias.",
+        "provider": "gemini",
+        "models": [
+            "gemini-2.5-flash-preview-04-17",
+            "gemini-2.0-flash",
+            "gemini-1.5-flash",
+        ],
+    },
+    {
+        "key": "developer",
+        "name": "Developer",
+        "role": "Programador senior especialista en crear aplicaciones y soluciones técnicas.",
+        "provider": "openrouter",
+        "models": [
+            "qwen/qwen3-4b:free",
+            "meta-llama/llama-3.3-70b-instruct:free",
+            "mistralai/mistral-small-3.1-24b-instruct:free",
+            "google/gemma-3-12b-it:free",
+            "qwen/qwen-2.5-72b-instruct:free",
+        ],
+    },
+    {
+        "key": "analyst",
+        "name": "Analyst",
+        "role": "Analista de negocios experto en evaluar viabilidad, riesgos y oportunidades.",
+        "provider": "openrouter",
+        "models": [
+            "meta-llama/llama-3.3-70b-instruct:free",
+            "mistralai/mistral-small-3.1-24b-instruct:free",
+            "google/gemma-3-27b-it:free",
+            "qwen/qwen3-4b:free",
+            "google/gemma-3-12b-it:free",
+        ],
+    },
 ]
 
+# Groq substitute — used when primary provider fails
+SUBSTITUTE = {
+    "provider": "groq",
+    "models": [
+        "llama-3.3-70b-versatile",
+        "llama3-70b-8192",
+        "gemma2-9b-it",
+        "mixtral-8x7b-32768",
+    ],
+}
+
+mission_history = []
+
 
+# ── CALL GEMINI ────────────────────────────────────────────────────────────
+async def call_gemini(model: str, system: str, user: str, key: str) -> str:
+    url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?key={key}"
+    payload = {
+        "contents": [{"role": "user", "parts": [{"text": f"{system}\n\n{user}"}]}],
+        "generationConfig": {"maxOutputTokens": 1024, "temperature": 0.7},
+    }
+    async with httpx.AsyncClient(timeout=60) as client:
+        r = await client.post(url, json=payload)
+        r.raise_for_status()
+        data = r.json()
+        return data["candidates"][0]["content"]["parts"][0]["text"]
+
+
+# ── CALL OPENAI-COMPAT (OpenRouter / Groq) ────────────────────────────────
+async def call_openai_compat(base_url: str, model: str, system: str, user: str,
+                              key: str, extra_headers: dict) -> str:
+    headers = {
+        "Authorization": f"Bearer {key}",
+        "Content-Type": "application/json",
+        **extra_headers,
+    }
+    payload = {
+        "model": model,
+        "messages": [
+            {"role": "system", "content": system},
+            {"role": "user",   "content": user},
+        ],
+        "max_tokens": 1024,
+        "temperature": 0.7,
+    }
+    async with httpx.AsyncClient(timeout=60) as client:
+        r = await client.post(base_url, json=payload, headers=headers)
+        r.raise_for_status()
+        data = r.json()
+        return data["choices"][0]["message"]["content"]
+
+
+# ── RUN ONE AGENT (with model fallback + groq substitute) ─────────────────
+async def run_agent(agent: dict, task: str) -> dict:
+    prov_key  = agent["provider"]
+    provider  = PROVIDERS[prov_key]
+    models    = agent["models"]
+    system    = (
+        f"Eres {agent['name']}. {agent['role']} "
+        "Responde de forma concisa y profesional en español. "
+        "Máximo 3 párrafos."
+    )
+
+    # Try each model of primary provider
+    last_err = None
+    for model in models:
+        try:
+            if provider["type"] == "gemini":
+                text = await call_gemini(model, system, task, provider["key"])
+            else:
+                text = await call_openai_compat(
+                    provider["base_url"], model, system, task,
+                    provider["key"], provider.get("headers", {})
+                )
+            return {
+                "status":   "active",
+                "message":  text.strip(),
+                "model":    model,
+                "provider": provider["name"],
+            }
+        except Exception as e:
+            last_err = str(e)
+            continue
+
+    # Primary failed — try Groq substitute
+    groq_prov = PROVIDERS["groq"]
+    if groq_prov["key"]:
+        for model in SUBSTITUTE["models"]:
+            try:
+                text = await call_openai_compat(
+                    groq_prov["base_url"], model, system, task,
+                    groq_prov["key"], {}
+                )
+                return {
+                    "status":   "active",
+                    "message":  text.strip(),
+                    "model":    f"{model} (via Groq substitute)",
+                    "provider": "Groq",
+                }
+            except Exception as e:
+                last_err = str(e)
+                continue
+
+    # All failed
+    return {
+        "status":  "resting",
+        "message": f"All providers unavailable. Last error: {last_err}",
+        "model":   "",
+        "reason":  "all_providers_failed",
+    }
+
+
+# ── ROUTES ─────────────────────────────────────────────────────────────────
 @app.get("/", response_class=HTMLResponse)
 async def root():
-    html = Path("templates/index.html").read_text()
-    return HTMLResponse(content=html)
+    return HTMLResponse(Path("templates/index.html").read_text())
 
 
 @app.get("/api/agents")
 async def get_agents():
-    return {"agents": AGENTS}
+    return {"agents": [{"key": a["key"], "name": a["name"], "role": a["role"]} for a in AGENTS]}
 
 
 @app.get("/api/history")
@@ -45,73 +214,54 @@ async def get_history():
 async def run_mission(request: Request):
     body = await request.json()
     task = body.get("task", "").strip()
-
     if not task:
         return JSONResponse({"error": "No task provided"}, status_code=400)
 
     started_at = datetime.now().isoformat()
 
-    try:
-        async with httpx.AsyncClient(timeout=300) as client:
-            resp = await client.post(
-                N8N_WEBHOOK,
-                json={"task": task},
-                headers={"Content-Type": "application/json"},
-            )
-
-        if resp.status_code != 200:
-            return JSONResponse({"error": f"n8n returned {resp.status_code}"}, status_code=502)
-
-        data = resp.json()
-        if isinstance(data, list):
-            data = data[0]
-
-        results = {}
-        for agent in AGENTS:
-            k   = agent["key"]
-            raw = data.get(k, {})
-
-            if isinstance(raw, dict):
-                status  = raw.get("status", "active")
-                message = raw.get("message", "")
-                model   = raw.get("model", "") or raw.get("provider", "")
-            else:
-                status  = "active"
-                message = str(raw)
-                model   = ""
-
-            if status in ("resting", "rate_limit"):
-                status = "resting"
+    # Run all agents in parallel
+    tasks = [run_agent(agent, task) for agent in AGENTS]
+    results_list = await asyncio.gather(*tasks, return_exceptions=True)
 
-            results[k] = {
-                "status":  status,
-                "message": message,
-                "model":   model,
+    results = {}
+    for agent, result in zip(AGENTS, results_list):
+        if isinstance(result, Exception):
+            results[agent["key"]] = {
+                "status": "resting", "message": str(result), "model": ""
             }
+        else:
+            results[agent["key"]] = result
+
+    # Simple final summary from manager response
+    manager_msg = results.get("manager", {}).get("message", "")
+    final = manager_msg[:200] + "..." if len(manager_msg) > 200 else manager_msg
+
+    entry = {
+        "id":         len(mission_history) + 1,
+        "task":       task,
+        "started_at": started_at,
+        "ended_at":   datetime.now().isoformat(),
+        "results":    results,
+        "final":      final,
+    }
+    mission_history.append(entry)
+
+    return JSONResponse({
+        "success":    True,
+        "task":       task,
+        "results":    results,
+        "final":      final,
+        "mission_id": entry["id"],
+    })
+
 
-        final_raw = data.get("final", {})
-        final_msg = final_raw.get("message", "") if isinstance(final_raw, dict) else str(final_raw)
-
-        entry = {
-            "id":         len(mission_history) + 1,
-            "task":       task,
-            "started_at": started_at,
-            "ended_at":   datetime.now().isoformat(),
-            "status":     "completed",
-            "results":    results,
-            "final":      final_msg,
+@app.get("/api/health")
+async def health():
+    return {
+        "status": "ok",
+        "providers": {
+            "gemini":     "configured" if GOOGLE_API_KEY     else "missing key",
+            "openrouter": "configured" if OPENROUTER_API_KEY else "missing key",
+            "groq":       "configured" if GROQ_API_KEY       else "missing key",
         }
-        mission_history.append(entry)
-
-        return JSONResponse({
-            "success":    True,
-            "task":       task,
-            "results":    results,
-            "final":      final_msg,
-            "mission_id": entry["id"],
-        })
-
-    except httpx.TimeoutException:
-        return JSONResponse({"error": "Request timed out"}, status_code=504)
-    except Exception as e:
-        return JSONResponse({"error": str(e)}, status_code=500)
+    }