ok

app/api/server.py

@@ -10,6 +10,8 @@ from fastapi.middleware.gzip import GZipMiddleware
 from app.config import get_settings
 from app.core.database import pool_manager
 from app.core.logger import get_logger
+from app.core.redis_client import create_redis_client, close_redis
+from app.core.scripts import load_scripts
 from app.services.embeddings_service import EmbeddingService
 from app.api.v1.router import api_v1_router
 
@@ -43,9 +45,19 @@ async def lifespan(app: FastAPI):
     # await loop.run_in_executor(None, _embedding_service.load_vision_model)  # DISABLED (OOM mitigation)
     _logger.info("Embedding service initialized with dims: %s", _embedding_service.loaded_dimensions)
 
+    redis = create_redis_client(_settings.redis_url) if _settings.redis_url else None
+    scripts = await load_scripts(redis) if redis else {}
+    app.state.redis = redis
+    app.state.scripts = scripts
+    if redis:
+        _logger.info("Redis and Lua scripts initialized")
+    else:
+        _logger.warning("Redis not configured, running in degraded mode")
+
     asyncio.create_task(_self_ping())
     yield
-    _logger.info("Shutting down database connection pools...")
+    _logger.info("Shutting down...")
+    await close_redis(redis)
     await pool_manager.close_all()
 
 

app/api/v1/chat.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
-from typing import Any, Dict
+from typing import Any, Dict, List, Optional
 
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, Request
 
 from app.api.deps import require_auth
 from app.services.chat_service import MODEL_MAP, chat_completion
 
 VALID_MODELS = list(MODEL_MAP.keys())
+VALID_PROVIDERS = ["openprovider", "meganova", "aionlabs"]
 
 router = APIRouter()
 
@@ -15,20 +16,47 @@ router = APIRouter()
 @router.post("/chat/completions")
 async def create_chat_completion(
     body: Dict[str, Any],
+    request: Request,
     token: str = Depends(require_auth),
 ) -> Dict[str, Any]:
-    messages = body.get("messages")
+    messages: Optional[List[Dict[str, str]]] = body.get("messages")
     if not messages or not isinstance(messages, list):
-        raise HTTPException(status_code=400, detail="messages is required and must be a list")
-
-    model = body.get("model")
-    if not model or not isinstance(model, str):
-        raise HTTPException(status_code=400, detail="model is required")
-    if model not in VALID_MODELS:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Invalid model '{model}'. Must be one of: {', '.join(VALID_MODELS)}",
-        )
+        raise HTTPException(status_code=400, detail="messages is required and must be a non-empty array")
+
+    for msg in messages:
+        if not isinstance(msg, dict):
+            raise HTTPException(status_code=400, detail="Each message must be an object")
+        if not isinstance(msg.get("role"), str) or not isinstance(msg.get("content"), str):
+            raise HTTPException(status_code=400, detail="Each message must have string role and content fields")
+        if msg["role"] not in ("system", "user", "assistant"):
+            raise HTTPException(status_code=400, detail=f"Invalid role '{msg['role']}'. Must be system, user, or assistant")
+
+    model: Any = body.get("model")
+    if model is not None:
+        if not isinstance(model, str) or model not in VALID_MODELS:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid model '{model}'. Must be one of: {', '.join(VALID_MODELS)}",
+            )
+
+    provider: Any = body.get("provider")
+    if provider is not None:
+        if not isinstance(provider, str) or provider not in VALID_PROVIDERS:
+            raise HTTPException(
+                status_code=400,
+                detail=f"Invalid provider '{provider}'",
+            )
+
+    return_json: Any = body.get("return_json")
+    if return_json is not None and not isinstance(return_json, bool):
+        raise HTTPException(status_code=400, detail="return_json must be a boolean")
+
+    stream: Any = body.get("stream", False)
+    if not isinstance(stream, bool):
+        raise HTTPException(status_code=400, detail="stream must be a boolean")
+
+    if stream and return_json:
+        raise HTTPException(status_code=400, detail="stream and return_json cannot both be true")
 
     max_tokens = body.get("max_tokens", 1024)
     temperature = body.get("temperature", 0.7)
@@ -36,15 +64,26 @@ async def create_chat_completion(
 
     response_format = body.get("response_format", None)
 
+    redis = getattr(request.app.state, "redis", None)
+    scripts = getattr(request.app.state, "scripts", None)
+
     try:
         result = await chat_completion(
             messages=messages,
             model=model,
+            provider=provider,
             response_format=response_format,
             max_tokens=max_tokens,
             temperature=temperature,
             top_p=top_p,
+            redis=redis,
+            scripts=scripts,
         )
         return result
     except RuntimeError as e:
+        if "All AI providers exhausted" in str(e) or "All API keys are locked" in str(e):
+            raise HTTPException(
+                status_code=503,
+                detail="All API keys are currently locked. Retry after a few minutes.",
+            )
         raise HTTPException(status_code=502, detail=str(e))

app/config.py

@@ -56,13 +56,42 @@ class Settings(BaseSettings):
     openrouter_mimika_api_key: Optional[str] = None
     aion_lab_keys: str = ""
     ai_api_keys: str = ""
+    proxy_auth_key: str = "changeme"
     request_timeout_ms: int = 60000
+    key_lock_ttl: int = 600
+    rounds_per_model: int = 50
 
     @property
     def max_upload_mb(self) -> int:
         return self.max_upload_bytes // (1024 * 1024)
 
 
+MODELS = [
+    "mistralai/Mistral-Small-3.2-24B-Instruct-2506",
+    "meganova-ai/manta-flash-1.0",
+    "meganova-ai/manta-mini-1.0",
+    "FallenMerick/MN-Violet-Lotus-12B",
+    "Sao10K/L3-70B-Euryale-v2.1",
+    "Sao10K/L3-8B-Stheno-v3.2",
+]
+
+MEGANOVA_BASE_URL = "https://api.meganova.ai"
+MEGANOVA_CHAT_PATH = "/v1/chat/completions"
+
+OPENROUTER_MIMIKA_BASE_URL = "https://openprovider.mimika.in"
+OPENROUTER_MIMIKA_CHAT_PATH = "/v1/chat/completions"
+OPENROUTER_MIMIKA_MODEL = "openprovider/auto-free"
+
+AION_LABS_BASE_URL = "https://api.aionlabs.ai"
+AION_LABS_CHAT_PATH = "/v1/chat/completions"
+AION_LABS_DEFAULT_MODEL = "aion-labs/aion-2.5"
+
+DEFAULT_MAX_TOKENS = 1024
+DEFAULT_TEMPERATURE = 0.7
+DEFAULT_TOP_P = 0.9
+DEFAULT_STREAM = False
+
+
 @lru_cache(maxsize=1)
 def get_settings() -> Settings:
     return Settings()

app/core/redis_client.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+import logging
+from typing import Optional
+
+from redis.asyncio import Redis
+
+from app.config import get_settings
+
+logger = logging.getLogger(__name__)
+
+
+def create_redis_client(redis_url: str) -> Optional[Redis]:
+    if not redis_url:
+        logger.warning("REDIS_URL not configured, Redis features disabled")
+        return None
+    logger.info("Connecting to Redis at %s", redis_url.split("@")[-1] if "@" in redis_url else redis_url)
+    return Redis.from_url(
+        redis_url,
+        max_connections=10,
+        socket_connect_timeout=5,
+        socket_timeout=5,
+        retry_on_timeout=True,
+        decode_responses=True,
+    )
+
+
+async def close_redis(redis: Optional[Redis]) -> None:
+    if redis:
+        await redis.aclose()
+        logger.info("Redis connection closed")

app/core/scripts.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Dict, Optional
+
+from redis.asyncio import Redis
+
+logger = logging.getLogger(__name__)
+
+LUA_DIR = Path(__file__).resolve().parent.parent.parent / "lua"
+
+
+def load_lua(filename: str) -> str:
+    path = LUA_DIR / filename
+    return path.read_text(encoding="utf-8")
+
+
+async def load_scripts(redis: Optional[Redis]) -> Dict[str, str]:
+    if not redis:
+        logger.warning("Redis not available, Lua scripts not loaded")
+        return {}
+    acquire_slot_sha = await redis.script_load(load_lua("acquire_slot.lua"))
+    lock_key_sha = await redis.script_load(load_lua("lock_key.lua"))
+    logger.info("Lua scripts loaded")
+    return {
+        "acquire_slot_sha": acquire_slot_sha,
+        "lock_key_sha": lock_key_sha,
+    }

app/services/chat_service.py

@@ -1,18 +1,34 @@
 from __future__ import annotations
 
-import asyncio
 import json
 import logging
-import re
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional
 
 import aiohttp
-
-from app.config import get_settings
+from redis.asyncio import Redis
+
+from app.config import (
+    AION_LABS_BASE_URL,
+    AION_LABS_CHAT_PATH,
+    AION_LABS_DEFAULT_MODEL,
+    DEFAULT_MAX_TOKENS,
+    DEFAULT_TEMPERATURE,
+    DEFAULT_TOP_P,
+    MEGANOVA_BASE_URL,
+    MEGANOVA_CHAT_PATH,
+    MODELS,
+    OPENROUTER_MIMIKA_BASE_URL,
+    OPENROUTER_MIMIKA_CHAT_PATH,
+    OPENROUTER_MIMIKA_MODEL,
+    get_settings,
+)
+from app.utils.json_utils import extract_json_blocks
 
 logger = logging.getLogger(__name__)
 _settings = get_settings()
 
+PREFIX = "ai_lb"
+AION_PREFIX = "ai_lb:aion"
 DEFAULT_JSON_PROMPT = "Return your response as a valid JSON object inside a JSON code block (```json)."
 
 MODEL_MAP: Dict[str, str] = {
@@ -21,64 +37,33 @@ MODEL_MAP: Dict[str, str] = {
     "agentdeck-0.1": "openprovider",
 }
 
+KEY_IDS: List[str] = []
+KEY_MAP: Dict[str, str] = {}
 
-def build_default_system_prompt(model_name: str) -> str:
-    return (
-        f"Role: You are LLM model {model_name}. "
-        f"You are built by AgentDeck. "
-        f"You are a helpful, respectful, and honest assistant. "
-        f"Always respond in a concise and accurate manner."
-    )
-
-MEGANOVA_BASE_URL = "https://api.meganova.ai"
-MEGANOVA_CHAT_PATH = "/v1/chat/completions"
-MEGANOVA_MODEL = "meganova-ai/manta-flash-1.0"
-
-OPENROUTER_MIMIKA_BASE_URL = "https://openprovider.mimika.in"
-OPENROUTER_MIMIKA_CHAT_PATH = "/v1/chat/completions"
-OPENROUTER_MIMIKA_MODEL = "openprovider/auto-free"
 
-AION_LABS_BASE_URL = "https://api.aionlabs.ai"
-AION_LABS_CHAT_PATH = "/v1/chat/completions"
-AION_LABS_DEFAULT_MODEL = "aion-labs/aion-2.5"
+def _refresh_keys() -> None:
+    global KEY_IDS, KEY_MAP
+    keys_str = _settings.ai_api_keys
+    if keys_str:
+        keys = [k.strip() for k in keys_str.split(",") if k.strip()]
+        KEY_IDS = [f"k{i}" for i in range(len(keys))]
+        KEY_MAP = {f"k{i}": key for i, key in enumerate(keys)}
+    else:
+        KEY_IDS = []
+        KEY_MAP = {}
 
-REDIS_PREFIX = "ai_lb:aion"
 
+_refresh_keys()
 
-def extract_json_blocks(text: str) -> List[Any]:
-    blocks: List[Any] = []
 
-    # try parsing the entire text as JSON first
-    stripped = text.strip()
-    try:
-        blocks.append(json.loads(stripped))
-        return blocks
-    except json.JSONDecodeError:
-        pass
-
-    # fallback: extract from ```json code blocks
-    pattern = r"```json\s*\n?(.*?)```"
-    for match in re.findall(pattern, text, re.DOTALL):
-        stripped = match.strip()
-        if stripped:
-            try:
-                blocks.append(json.loads(stripped))
-            except json.JSONDecodeError:
-                logger.warning("Failed to parse JSON block: %s", stripped[:100])
-
-    # fallback: try to find any top-level {...} or [...] in the text
-    if not blocks:
-        for delim in (("{", "}"), ("[", "]")):
-            start = text.find(delim[0])
-            end = text.rfind(delim[1])
-            if start != -1 and end != -1 and end > start:
-                candidate = text[start : end + 1]
-                try:
-                    blocks.append(json.loads(candidate))
-                except json.JSONDecodeError:
-                    pass
-
-    return blocks
+def build_default_system_prompt(model_name: Optional[str]) -> str:
+    name = model_name or "agentdeck-1.0"
+    return (
+        f"Role: You are LLM model {name}. "
+        f"You are built by AgentDeck. "
+        f"You are a helpful, respectful, and honest assistant. "
+        f"Always respond in a concise and accurate manner."
+    )
 
 
 def inject_system_identity(
@@ -110,45 +95,48 @@ def prepare_messages(
     has_system = messages and messages[0].get("role") == "system"
 
     if has_system:
-        messages[0] = {
-            "role": "system",
-            "content": f"{messages[0]['content']}\n\n{DEFAULT_JSON_PROMPT}",
-        }
+        return [
+            {
+                "role": "system",
+                "content": f"{messages[0]['content']}\n\n{DEFAULT_JSON_PROMPT}",
+            },
+            *messages[1:],
+        ]
 
-    return messages
+    return [
+        {"role": "system", "content": DEFAULT_JSON_PROMPT},
+        *messages,
+    ]
 
 
 def attach_json_content(
     response_data: Dict[str, Any],
     response_format: Optional[Dict[str, str]],
-) -> Dict[str, Any]:
+) -> None:
     if not response_format or response_format.get("type") != "json_object":
-        return response_data
+        return
 
     try:
         choices = response_data.get("choices", [])
         if not choices:
-            return response_data
+            return
         content = choices[0].get("message", {}).get("content", "")
         if content:
             parsed = extract_json_blocks(content)
             if parsed:
-                choices[0]["message"]["content"] = json.dumps(
-                    parsed[0] if len(parsed) == 1 else parsed,
-                    ensure_ascii=False,
+                response_data["parsed"] = (
+                    parsed[0] if len(parsed) == 1 else parsed
                 )
     except Exception as exc:
-        choices[0]["message"]["content"] = json.dumps({"error": str(exc)})
-
-    return response_data
+        response_data["parsed"] = {"error": str(exc)}
 
 
 async def call_openrouter_mimika(
     messages: List[Dict[str, str]],
     response_format: Optional[Dict[str, str]],
-    max_tokens: int = 1024,
-    temperature: float = 0.7,
-    top_p: float = 0.9,
+    max_tokens: int = DEFAULT_MAX_TOKENS,
+    temperature: float = DEFAULT_TEMPERATURE,
+    top_p: float = DEFAULT_TOP_P,
 ) -> Optional[Dict[str, Any]]:
     api_key = _settings.openrouter_mimika_api_key
     if not api_key:
@@ -181,7 +169,8 @@ async def call_openrouter_mimika(
                     logger.warning("OpenRouter Mimika HTTP %d", resp.status)
                     return None
                 data = await resp.json()
-                return attach_json_content(data, response_format)
+                attach_json_content(data, response_format)
+                return data
     except Exception as exc:
         logger.warning("OpenRouter Mimika failed: %s", exc)
         return None
@@ -195,76 +184,354 @@ def _get_meganova_key() -> Optional[str]:
     return keys[0] if keys else None
 
 
+async def _acquire_slot(
+    redis: Redis,
+    scripts: Dict[str, str],
+) -> Optional[Dict[str, Any]]:
+    _refresh_keys()
+    if not KEY_IDS:
+        return None
+
+    raw = await redis.evalsha(
+        scripts["acquire_slot_sha"],
+        1,
+        PREFIX,
+        json.dumps(KEY_IDS),
+        json.dumps(MODELS),
+        str(_settings.rounds_per_model),
+        str(len(KEY_IDS)),
+    )
+
+    if not raw or raw[0] != "ok":
+        return None
+
+    return {
+        "keyId": raw[1],
+        "model": raw[2],
+        "modelIndex": int(raw[3]),
+    }
+
+
+async def _acquire_slot_for_model(
+    redis: Redis,
+    target_model: str,
+) -> Optional[Dict[str, Any]]:
+    _refresh_keys()
+    if not KEY_IDS:
+        return None
+
+    target_idx = MODELS.index(target_model) if target_model in MODELS else -1
+    if target_idx == -1:
+        return None
+
+    for key_id in KEY_IDS:
+        lock_k = f"{PREFIX}:key:{key_id}:lock"
+        failed_k = f"{PREFIX}:key:{key_id}:m{target_idx}:failed"
+
+        locked = await redis.exists(lock_k)
+        if locked:
+            continue
+
+        failed = await redis.get(failed_k)
+        if failed == "1":
+            continue
+
+        rounds_k = f"{PREFIX}:key:{key_id}:m{target_idx}:rounds"
+        used = int(await redis.get(rounds_k) or "0")
+        if used < _settings.rounds_per_model:
+            await redis.incr(rounds_k)
+            return {
+                "keyId": key_id,
+                "model": target_model,
+                "modelIndex": target_idx,
+            }
+
+    return None
+
+
+async def _mark_failure(
+    redis: Redis,
+    scripts: Dict[str, str],
+    key_id: str,
+    model_index: int,
+) -> str:
+    result = await redis.evalsha(
+        scripts["lock_key_sha"],
+        1,
+        PREFIX,
+        key_id,
+        str(model_index),
+        str(len(MODELS)),
+        str(_settings.key_lock_ttl),
+    )
+    return result
+
+
 async def call_meganova(
+    redis: Redis,
+    scripts: Dict[str, str],
     messages: List[Dict[str, str]],
     response_format: Optional[Dict[str, str]],
-    max_tokens: int = 1024,
-    temperature: float = 0.7,
-    top_p: float = 0.9,
+    max_tokens: int = DEFAULT_MAX_TOKENS,
+    temperature: float = DEFAULT_TEMPERATURE,
+    top_p: float = DEFAULT_TOP_P,
+    target_model: Optional[str] = None,
 ) -> Optional[Dict[str, Any]]:
-    api_key = _get_meganova_key()
-    if not api_key:
-        logger.info("No MegaNova keys configured (ai_api_keys), skipping")
+    if target_model and target_model not in MODELS:
         return None
 
-    prepared = prepare_messages(messages, response_format)
-    payload = {
-        "model": MEGANOVA_MODEL,
-        "messages": prepared,
-        "max_tokens": max_tokens,
-        "temperature": temperature,
-        "top_p": top_p,
-        "stream": False,
-    }
+    total_unique_slots = len(MODELS) * len(KEY_IDS)
+    tried: set = set()
+    hard_cap = total_unique_slots * 2 + 2
+    loops = 0
+
+    max_tries = len(KEY_IDS) if target_model else total_unique_slots
+
+    while len(tried) < max_tries and loops < hard_cap:
+        loops += 1
+
+        slot = (
+            await _acquire_slot_for_model(redis, target_model)
+            if target_model
+            else await _acquire_slot(redis, scripts)
+        )
+
+        if not slot:
+            return None
+
+        combo_key = f"{slot['keyId']}:{slot['modelIndex']}"
+        if combo_key in tried:
+            continue
+        tried.add(combo_key)
+
+        prepared = prepare_messages(messages, response_format)
+        api_key = KEY_MAP.get(slot["keyId"])
+        if not api_key:
+            continue
+
+        payload = {
+            "messages": prepared,
+            "model": slot["model"],
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "top_p": top_p,
+            "stream": False,
+        }
 
-    logger.info("Calling MegaNova...")
-    try:
-        timeout = aiohttp.ClientTimeout(total=_settings.request_timeout_ms / 1000)
-        async with aiohttp.ClientSession(timeout=timeout) as session:
-            async with session.post(
-                f"{MEGANOVA_BASE_URL}{MEGANOVA_CHAT_PATH}",
-                json=payload,
-                headers={
-                    "Authorization": f"Bearer {api_key}",
-                    "Content-Type": "application/json",
-                },
-            ) as resp:
-                if resp.status != 200:
-                    logger.warning("MegaNova HTTP %d", resp.status)
-                    return None
-                data = await resp.json()
-                return attach_json_content(data, response_format)
-    except Exception as exc:
-        logger.warning("MegaNova failed: %s", exc)
+        try:
+            timeout = aiohttp.ClientTimeout(total=_settings.request_timeout_ms / 1000)
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.post(
+                    f"{MEGANOVA_BASE_URL}{MEGANOVA_CHAT_PATH}",
+                    json=payload,
+                    headers={
+                        "Authorization": f"Bearer {api_key}",
+                        "Content-Type": "application/json",
+                    },
+                ) as resp:
+                    if resp.status >= 400:
+                        logger.warning(
+                            "MegaNova HTTP %d for keyId=%s model=%s",
+                            resp.status,
+                            slot["keyId"],
+                            slot["model"],
+                        )
+                        await _mark_failure(redis, scripts, slot["keyId"], slot["modelIndex"])
+                        continue
+
+                    data = await resp.json()
+                    attach_json_content(data, response_format)
+                    return data
+        except Exception as exc:
+            logger.warning("MegaNova request failed: %s", exc)
+            continue
+
+    return None
+
+
+async def _get_next_aion_key(redis: Redis) -> Optional[str]:
+    keys_json = await redis.get(f"{AION_PREFIX}:keys")
+    if not keys_json:
+        return None
+    keys: List[str] = json.loads(keys_json)
+    if not keys:
         return None
 
+    ptr = await redis.incr(f"{AION_PREFIX}:rr_ptr")
+    idx = (ptr - 1) % len(keys)
 
-def get_next_aion_key() -> Tuple[Optional[str], int]:
-    keys_str = _settings.aion_lab_keys
-    if not keys_str:
-        return None, 0
-    keys = [k.strip() for k in keys_str.split(",") if k.strip()]
-    if not keys:
-        return None, 0
-    return keys[0], len(keys)
+    await redis.incr(f"{AION_PREFIX}:key:{idx}:uses")
+    logger.info("[aion] Round-robin: ptr=%s, idx=%s, total=%s", ptr, idx, len(keys))
+    return keys[idx]
 
 
 async def call_aion_labs(
+    redis: Redis,
     messages: List[Dict[str, str]],
     response_format: Optional[Dict[str, str]],
     model: str = AION_LABS_DEFAULT_MODEL,
-    max_tokens: int = 1024,
-    temperature: float = 0.7,
-    top_p: float = 0.9,
+    max_tokens: int = DEFAULT_MAX_TOKENS,
+    temperature: float = DEFAULT_TEMPERATURE,
+    top_p: float = DEFAULT_TOP_P,
 ) -> Optional[Dict[str, Any]]:
-    key, _ = get_next_aion_key()
-    if not key:
-        logger.info("No AION keys configured, skipping")
+    keys_json = await redis.get(f"{AION_PREFIX}:keys")
+    if not keys_json:
+        logger.info("[aion] No keys in Redis, skipping")
+        return None
+    keys: List[str] = json.loads(keys_json)
+    if not keys:
+        return None
+
+    total_tries = min(len(keys), 3)
+    for attempt in range(total_tries):
+        key = await _get_next_aion_key(redis)
+        if not key:
+            return None
+
+        prepared = prepare_messages(messages, response_format)
+        payload = {
+            "model": model,
+            "messages": prepared,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "top_p": top_p,
+            "stream": False,
+        }
+
+        logger.info("[aion] Attempt %s/%s", attempt + 1, total_tries)
+
+        try:
+            timeout = aiohttp.ClientTimeout(total=_settings.request_timeout_ms / 1000)
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.post(
+                    f"{AION_LABS_BASE_URL}{AION_LABS_CHAT_PATH}",
+                    json=payload,
+                    headers={
+                        "Authorization": f"Bearer {key}",
+                        "Content-Type": "application/json",
+                    },
+                ) as resp:
+                    if resp.status != 200:
+                        logger.warning("[aion] Attempt %s HTTP %s", attempt + 1, resp.status)
+                        continue
+                    data = await resp.json()
+                    attach_json_content(data, response_format)
+                    return data
+        except Exception as exc:
+            logger.warning("[aion] Attempt %s failed: %s", attempt + 1, exc)
+            continue
+
+    logger.info("[aion] All attempts exhausted")
+    return None
+
+
+async def chat_completion(
+    messages: List[Dict[str, str]],
+    model: str = "agentdeck-1.0",
+    response_format: Optional[Dict[str, str]] = None,
+    max_tokens: int = DEFAULT_MAX_TOKENS,
+    temperature: float = DEFAULT_TEMPERATURE,
+    top_p: float = DEFAULT_TOP_P,
+    provider: Optional[str] = None,
+    redis: Optional[Redis] = None,
+    scripts: Optional[Dict[str, str]] = None,
+) -> Dict[str, Any]:
+    messages = inject_system_identity(messages, model)
+
+    if not provider:
+        provider = MODEL_MAP.get(model)
+
+    logger.info(
+        "Chat completion: model=%s provider=%s messages=%d",
+        model,
+        provider,
+        len(messages),
+    )
+
+    if provider == "openprovider":
+        result = await call_openrouter_mimika(
+            messages, response_format, max_tokens, temperature, top_p,
+        )
+        if result:
+            return result
+        raise RuntimeError("OpenRouter Mimika request failed")
+
+    if provider == "aionlabs":
+        if redis and scripts:
+            result = await call_aion_labs(
+                redis, messages, response_format, model or AION_LABS_DEFAULT_MODEL,
+                max_tokens, temperature, top_p,
+            )
+            if result:
+                return result
+            raise RuntimeError("AionLabs request failed")
+        # degraded fallback without Redis
+        result = await call_aion_labs_no_redis(
+            messages, response_format, model or AION_LABS_DEFAULT_MODEL,
+            max_tokens, temperature, top_p,
+        )
+        if result:
+            return result
+        raise RuntimeError("AionLabs request failed")
+
+    if provider != "meganova":
+        mimika_result = await call_openrouter_mimika(
+            messages, response_format, max_tokens, temperature, top_p,
+        )
+        if mimika_result is not None:
+            logger.info("OpenRouter Mimika handled request, skipping meganova")
+            return mimika_result
+
+    target = model if model in MODELS else None
+    if redis and scripts:
+        meganova_result = await call_meganova(
+            redis, scripts, messages, response_format,
+            max_tokens, temperature, top_p, target,
+        )
+        if meganova_result is not None:
+            return meganova_result
+    else:
+        meganova_result = await call_meganova_no_redis(
+            messages, response_format, max_tokens, temperature, top_p, target,
+        )
+        if meganova_result is not None:
+            return meganova_result
+
+    logger.info("MegaNova failed, falling back to AionLabs")
+    if redis and scripts:
+        aion_result = await call_aion_labs(
+            redis, messages, response_format, model or AION_LABS_DEFAULT_MODEL,
+            max_tokens, temperature, top_p,
+        )
+        if aion_result is not None:
+            return aion_result
+    else:
+        aion_result = await call_aion_labs_no_redis(
+            messages, response_format, model or AION_LABS_DEFAULT_MODEL,
+            max_tokens, temperature, top_p,
+        )
+        if aion_result is not None:
+            return aion_result
+
+    raise RuntimeError("All AI providers exhausted")
+
+
+async def call_meganova_no_redis(
+    messages: List[Dict[str, str]],
+    response_format: Optional[Dict[str, str]],
+    max_tokens: int = DEFAULT_MAX_TOKENS,
+    temperature: float = DEFAULT_TEMPERATURE,
+    top_p: float = DEFAULT_TOP_P,
+    target_model: Optional[str] = None,
+) -> Optional[Dict[str, Any]]:
+    api_key = _get_meganova_key()
+    if not api_key:
+        logger.info("No MegaNova keys configured, skipping")
         return None
 
     prepared = prepare_messages(messages, response_format)
     payload = {
-        "model": model,
+        "model": target_model or MODELS[1],
         "messages": prepared,
         "max_tokens": max_tokens,
         "temperature": temperature,
@@ -272,58 +539,74 @@ async def call_aion_labs(
         "stream": False,
     }
 
-    logger.info("Calling AionLabs...")
+    logger.info("Calling MegaNova (no Redis)...")
     try:
         timeout = aiohttp.ClientTimeout(total=_settings.request_timeout_ms / 1000)
         async with aiohttp.ClientSession(timeout=timeout) as session:
             async with session.post(
-                f"{AION_LABS_BASE_URL}{AION_LABS_CHAT_PATH}",
+                f"{MEGANOVA_BASE_URL}{MEGANOVA_CHAT_PATH}",
                 json=payload,
                 headers={
-                    "Authorization": f"Bearer {key}",
+                    "Authorization": f"Bearer {api_key}",
                     "Content-Type": "application/json",
                 },
             ) as resp:
                 if resp.status != 200:
-                    logger.warning("AionLabs HTTP %d", resp.status)
+                    logger.warning("MegaNova HTTP %d", resp.status)
                     return None
                 data = await resp.json()
-                return attach_json_content(data, response_format)
+                attach_json_content(data, response_format)
+                return data
     except Exception as exc:
-        logger.warning("AionLabs failed: %s", exc)
+        logger.warning("MegaNova failed: %s", exc)
         return None
 
 
-async def chat_completion(
+async def call_aion_labs_no_redis(
     messages: List[Dict[str, str]],
-    model: str = "agentdeck-1.0",
-    response_format: Optional[Dict[str, str]] = None,
-    max_tokens: int = 1024,
-    temperature: float = 0.7,
-    top_p: float = 0.9,
-) -> Dict[str, Any]:
-    messages = inject_system_identity(messages, model)
-    provider = MODEL_MAP.get(model, "meganova")
-    logger.info("Chat completion: model=%s provider=%s messages=%d", model, provider, len(messages))
-
-    if provider == "openprovider":
-        result = await call_openrouter_mimika(messages, response_format, max_tokens, temperature, top_p)
-        if result:
-            return result
-        raise RuntimeError("OpenRouter Mimika request failed")
-
-    if provider == "aionlabs":
-        result = await call_aion_labs(messages, response_format, AION_LABS_DEFAULT_MODEL, max_tokens, temperature, top_p)
-        if result:
-            return result
-        raise RuntimeError("AionLabs request failed")
-
-    result = await call_meganova(messages, response_format, max_tokens, temperature, top_p)
-    if result:
-        return result
+    response_format: Optional[Dict[str, str]],
+    model: str = AION_LABS_DEFAULT_MODEL,
+    max_tokens: int = DEFAULT_MAX_TOKENS,
+    temperature: float = DEFAULT_TEMPERATURE,
+    top_p: float = DEFAULT_TOP_P,
+) -> Optional[Dict[str, Any]]:
+    keys_str = _settings.aion_lab_keys
+    if not keys_str:
+        logger.info("No AION keys configured, skipping")
+        return None
+    keys = [k.strip() for k in keys_str.split(",") if k.strip()]
+    if not keys:
+        return None
 
-    result = await call_aion_labs(messages, response_format, AION_LABS_DEFAULT_MODEL, max_tokens, temperature, top_p)
-    if result:
-        return result
+    for attempt, key in enumerate(keys[:3]):
+        prepared = prepare_messages(messages, response_format)
+        payload = {
+            "model": model,
+            "messages": prepared,
+            "max_tokens": max_tokens,
+            "temperature": temperature,
+            "top_p": top_p,
+            "stream": False,
+        }
 
-    raise RuntimeError("All AI providers exhausted")
+        logger.info("[aion] (no redis) Attempt %s/%s", attempt + 1, min(len(keys), 3))
+        try:
+            timeout = aiohttp.ClientTimeout(total=_settings.request_timeout_ms / 1000)
+            async with aiohttp.ClientSession(timeout=timeout) as session:
+                async with session.post(
+                    f"{AION_LABS_BASE_URL}{AION_LABS_CHAT_PATH}",
+                    json=payload,
+                    headers={
+                        "Authorization": f"Bearer {key}",
+                        "Content-Type": "application/json",
+                    },
+                ) as resp:
+                    if resp.status != 200:
+                        continue
+                    data = await resp.json()
+                    attach_json_content(data, response_format)
+                    return data
+        except Exception:
+            continue
+
+    return None

app/utils/json_utils.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import json
+import logging
+import re
+from typing import Any, List
+
+logger = logging.getLogger(__name__)
+
+
+def extract_json_blocks(text: str) -> List[Any]:
+    blocks: List[Any] = []
+
+    stripped = text.strip()
+    try:
+        blocks.append(json.loads(stripped))
+        return blocks
+    except json.JSONDecodeError:
+        pass
+
+    pattern = r"```json\s*\n?(.*?)```"
+    for match in re.findall(pattern, text, re.DOTALL):
+        stripped = match.strip()
+        if stripped:
+            try:
+                blocks.append(json.loads(stripped))
+            except json.JSONDecodeError:
+                logger.warning("Failed to parse JSON block: %s", stripped[:100])
+
+    if not blocks:
+        for delim in (("{", "}"), ("[", "]")):
+            start = text.find(delim[0])
+            end = text.rfind(delim[1])
+            if start != -1 and end != -1 and end > start:
+                candidate = text[start : end + 1]
+                try:
+                    blocks.append(json.loads(candidate))
+                except json.JSONDecodeError:
+                    pass
+
+    return blocks

lua/acquire_slot.lua

@@ -0,0 +1,73 @@
+--[[
+  acquire_slot.lua  v4
+  ─────────────────────────────────────────────────────────────────────────────
+  Round-robin slot acquisition. Rounds are a rotation hint, never a lock cause.
+
+  Flow:
+    1. Read rr_ptr — starting key index.
+    2. Walk all keys. Skip failure-locked ones.
+    3. For each unlocked key, walk models from its midx.
+       Skip any model flagged with m{idx}:failed (error-mark from lock_key.lua).
+       For non-failed models, find first where rounds < maxRounds.
+    4. INCR rounds, advance rr_ptr, return slot.
+    5. If a model is error-marked, rotate midx past it and clear the flag.
+    6. If a model is naturally exhausted (rounds >= max),
+       rotate midx to next model and RESET that model's counter
+       so it can be reused — never lock for round exhaustion.
+    7. Return "none" only when ALL keys have an active failure lock.
+
+  Keys:
+    {prefix}:rr_ptr
+    {prefix}:key:{id}:lock       (set only by lock_key.lua on upstream error)
+    {prefix}:key:{id}:midx
+    {prefix}:key:{id}:m{idx}:rounds
+    {prefix}:key:{id}:m{idx}:failed
+]]
+
+local prefix    = KEYS[1]
+local keyIds    = cjson.decode(ARGV[1])
+local models    = cjson.decode(ARGV[2])
+local maxRounds = tonumber(ARGV[3])
+local numKeys   = tonumber(ARGV[4])
+local numModels = #models
+
+local rrPtrK   = prefix .. ":rr_ptr"
+local startPtr = tonumber(redis.call("GET", rrPtrK) or "0") or 0
+
+for attempt = 0, numKeys - 1 do
+  local keySlot = (startPtr + attempt) % numKeys
+  local keyId   = keyIds[keySlot + 1]
+  local lockK   = prefix .. ":key:" .. keyId .. ":lock"
+
+  if redis.call("EXISTS", lockK) == 0 then
+    local midxK = prefix .. ":key:" .. keyId .. ":midx"
+    local mIdx  = tonumber(redis.call("GET", midxK) or "0") or 0
+
+    for mAttempt = 0, numModels - 1 do
+      local realMIdx = (mIdx + mAttempt) % numModels
+      local failedK  = prefix .. ":key:" .. keyId .. ":m" .. realMIdx .. ":failed"
+
+      if redis.call("GET", failedK) == "1" then
+        local nextMIdx = (realMIdx + 1) % numModels
+        redis.call("SET", midxK, tostring(nextMIdx))
+        redis.call("DEL", failedK)
+      else
+        local roundsK  = prefix .. ":key:" .. keyId .. ":m" .. realMIdx .. ":rounds"
+        local used     = tonumber(redis.call("GET", roundsK) or "0") or 0
+
+        if used < maxRounds then
+          redis.call("INCR", roundsK)
+          redis.call("SET", rrPtrK, tostring((keySlot + 1) % numKeys))
+          redis.call("SET", midxK, tostring(realMIdx))
+          return { "ok", keyId, models[realMIdx + 1], tostring(realMIdx) }
+        else
+          local nextMIdx = (realMIdx + 1) % numModels
+          redis.call("SET", midxK, tostring(nextMIdx))
+          redis.call("SET", roundsK, "0")
+        end
+      end
+    end
+  end
+end
+
+return { "none" }

lua/lock_key.lua

@@ -0,0 +1,49 @@
+--[[
+  lock_key.lua  v4
+  ─────────────────────────────────────────────────────────────────────────────
+  Called ONLY on upstream error (4xx / 5xx).
+  Flags the failed model and checks whether other models on the same key remain.
+
+  Rules:
+    - Set a per-model error flag (m{idx}:failed) so acquire_slot skips it.
+    - Advance midx to the next model.
+    - If at least one other model is NOT flagged failed → return "rotated"
+      (key is still usable; balancer will retry immediately).
+    - If ALL models on this key are flagged failed → lock the key for lockTtl.
+      The key unlocks automatically when the TTL expires.
+
+  KEYS[1] = prefix
+  ARGV[1] = keyId
+  ARGV[2] = failed model index (0-based)
+  ARGV[3] = total model count
+  ARGV[4] = lock TTL in seconds
+
+  Returns: "rotated" | "all_exhausted"
+]]
+
+local prefix      = KEYS[1]
+local keyId       = ARGV[1]
+local failedMIdx  = tonumber(ARGV[2])
+local numModels   = tonumber(ARGV[3])
+local lockTtl     = tonumber(ARGV[4])
+
+local midxK   = prefix .. ":key:" .. keyId .. ":midx"
+local lockK   = prefix .. ":key:" .. keyId .. ":lock"
+
+local failedK = prefix .. ":key:" .. keyId .. ":m" .. failedMIdx .. ":failed"
+redis.call("SET", failedK, "1")
+
+local nextMIdx = (failedMIdx + 1) % numModels
+redis.call("SET", midxK, tostring(nextMIdx))
+
+for i = 0, numModels - 1 do
+  if i ~= failedMIdx then
+    local otherFailedK = prefix .. ":key:" .. keyId .. ":m" .. i .. ":failed"
+    if redis.call("GET", otherFailedK) ~= "1" then
+      return "rotated"
+    end
+  end
+end
+
+redis.call("SET", lockK, "1", "EX", lockTtl)
+return "all_exhausted"