feat: add DeepSeek, Gemini, Together AI, Cohere to AI provider stack

.env.example

@@ -2,4 +2,8 @@ GROQ_API_KEY=
 CEREBRAS_API_KEY=
 OPENROUTER_API_KEY=
 MISTRAL_API_KEY=
+DEEPSEEK_API_KEY=
+TOGETHER_API_KEY=
+COHERE_API_KEY=
+GEMINI_API_KEY=
 SECRET_KEY=change-me

app/core/ai.py

@@ -1,4 +1,12 @@
-"""Multi-provider AI engine. Runtime chain: Groq -> Cerebras -> OpenRouter -> Mistral -> Ollama."""
+"""Multi-provider AI engine with smart task routing.
+
+Runtime chain: Groq -> Cerebras -> OpenRouter -> Mistral -> Ollama.
+Task hints route to the best model for the job:
+  - "arabic"   → large models (70B+) for Arabic NLP quality
+  - "code"     → code-optimized models
+  - "fast"     → smallest/fastest model available
+  - "default"  → standard free-tier chain
+"""
 import json, logging, os, re, requests
 
 logger = logging.getLogger(__name__)
@@ -10,12 +18,20 @@ _PROVIDER_URLS = {
     "openrouter": "https://openrouter.ai/api/v1/chat/completions",
     "mistral":    "https://api.mistral.ai/v1/chat/completions",
     "openai":     "https://api.openai.com/v1/chat/completions",
+    "deepseek":   "https://api.deepseek.com/chat/completions",
+    "together":   "https://api.together.xyz/v1/chat/completions",
+    "cohere":     "https://api.cohere.com/v2/chat",
 }
+
+# ── Model tiers per provider ──
 _FREE_MODELS = {
     "groq":       "llama-3.1-8b-instant",
     "cerebras":   "llama3.1-8b",
     "openrouter": "google/gemma-3-12b-it:free",
     "mistral":    "mistral-small-latest",
+    "deepseek":   "deepseek-chat",
+    "together":   "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+    "cohere":     "command-r",
 }
 _PREMIUM_MODELS = {
     "groq":       "llama-3.3-70b-versatile",
@@ -23,28 +39,77 @@ _PREMIUM_MODELS = {
     "openrouter": "google/gemma-3-27b-it:free",
     "mistral":    "mistral-medium-latest",
     "openai":     "gpt-4o-mini",
+    "deepseek":   "deepseek-chat",
+    "together":   "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+    "cohere":     "command-r-plus",
+}
+
+# ── Task-specific model routing ──
+# Maps task hints to the best model per provider.
+# "arabic" needs large models for Arabic morphology, grammar, dialect awareness.
+# "code" needs code-tuned models for test generation, SQL, schema analysis.
+# "fast" uses smallest models for quick responses.
+_TASK_MODELS = {
+    "arabic": {
+        "groq":       "llama-3.3-70b-versatile",
+        "cerebras":   "qwen-3-235b-a22b-instruct-2507",
+        "openrouter": "google/gemma-3-27b-it:free",
+        "mistral":    "mistral-medium-latest",
+        "deepseek":   "deepseek-chat",
+        "together":   "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+        "cohere":     "command-r-plus",
+    },
+    "code": {
+        "groq":       "llama-3.3-70b-versatile",
+        "cerebras":   "qwen-3-235b-a22b-instruct-2507",
+        "openrouter": "google/gemma-3-27b-it:free",
+        "mistral":    "mistral-medium-latest",
+        "deepseek":   "deepseek-chat",
+        "together":   "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+        "cohere":     "command-r-plus",
+    },
+    "fast": {
+        "groq":       "llama-3.1-8b-instant",
+        "cerebras":   "llama3.1-8b",
+        "openrouter": "google/gemma-3-12b-it:free",
+        "mistral":    "mistral-small-latest",
+        "deepseek":   "deepseek-chat",
+        "together":   "meta-llama/Llama-3.3-70B-Instruct-Turbo-Free",
+        "cohere":     "command-r",
+    },
+}
+
+# ── Task-specific provider priority ──
+_TASK_PRIORITY = {
+    "arabic":  ["cerebras", "deepseek", "groq", "together", "openrouter", "cohere", "mistral"],
+    "code":    ["deepseek", "groq", "cerebras", "together", "openrouter", "cohere", "mistral"],
+    "fast":    ["cerebras", "groq", "together", "deepseek", "openrouter", "cohere", "mistral"],
+    "default": ["groq", "cerebras", "deepseek", "together", "openrouter", "cohere", "mistral"],
+}
+
+_CHAIN_CFG = {
+    "groq":       {"key_env": "GROQ_API_KEY",       "timeout": 30, "extra": {}},
+    "cerebras":   {"key_env": "CEREBRAS_API_KEY",   "timeout": 30, "extra": {}},
+    "openrouter": {"key_env": "OPENROUTER_API_KEY", "timeout": 45,
+                   "extra": {"HTTP-Referer": "https://github.com/Moealsarraj", "X-Title": "AI Tools"}},
+    "mistral":    {"key_env": "MISTRAL_API_KEY",    "timeout": 40, "extra": {}},
+    "deepseek":   {"key_env": "DEEPSEEK_API_KEY",   "timeout": 60, "extra": {}},
+    "together":   {"key_env": "TOGETHER_API_KEY",   "timeout": 45, "extra": {}},
+    "cohere":     {"key_env": "COHERE_API_KEY",     "timeout": 45, "extra": {}},
 }
-_CHAIN_CFG = [
-    {"name": "groq",       "key_env": "GROQ_API_KEY",       "timeout": 30, "extra": {}},
-    {"name": "cerebras",   "key_env": "CEREBRAS_API_KEY",   "timeout": 30, "extra": {}},
-    {"name": "openrouter", "key_env": "OPENROUTER_API_KEY", "timeout": 45,
-     "extra": {"HTTP-Referer": "https://github.com/Moealsarraj", "X-Title": "AI Tools"}},
-    {"name": "mistral",    "key_env": "MISTRAL_API_KEY",    "timeout": 40, "extra": {}},
-]
-
-# Build the runtime provider list — all providers with valid keys
-_PROVIDERS = []
-for _p in _CHAIN_CFG:
-    _k = os.environ.get(_p["key_env"], "")
+
+# Build available providers (those with valid keys)
+_AVAILABLE = {}
+for _name, _cfg in _CHAIN_CFG.items():
+    _k = os.environ.get(_cfg["key_env"], "")
     if _k:
-        _PROVIDERS.append({
-            "name":    _p["name"],
-            "url":     _PROVIDER_URLS[_p["name"]],
-            "model":   _FREE_MODELS[_p["name"]],
+        _AVAILABLE[_name] = {
+            "name":    _name,
+            "url":     _PROVIDER_URLS[_name],
             "key":     _k,
-            "timeout": _p["timeout"],
-            "extra":   _p["extra"],
-        })
+            "timeout": _cfg["timeout"],
+            "extra":   _cfg["extra"],
+        }
 
 # Ollama fallback
 _OLLAMA_PROVIDER = None
@@ -57,7 +122,85 @@ try:
 except Exception:
     pass
 
-_AI_AVAILABLE = bool(_PROVIDERS or _OLLAMA_PROVIDER)
+# ── Google Gemini (special API format) ──
+_GEMINI_KEY = os.environ.get("GEMINI_API_KEY", "")
+if _GEMINI_KEY:
+    _AVAILABLE["gemini"] = {
+        "name": "gemini",
+        "url": "https://generativelanguage.googleapis.com/v1beta/models",
+        "key": _GEMINI_KEY,
+        "timeout": 60,
+        "extra": {},
+    }
+    _FREE_MODELS["gemini"] = "gemini-2.0-flash"
+    _PREMIUM_MODELS["gemini"] = "gemini-2.0-flash"
+    for task in _TASK_MODELS:
+        _TASK_MODELS[task]["gemini"] = "gemini-2.0-flash"
+    for task in _TASK_PRIORITY:
+        if "gemini" not in _TASK_PRIORITY[task]:
+            _TASK_PRIORITY[task].insert(2, "gemini")
+
+_AI_AVAILABLE = bool(_AVAILABLE or _OLLAMA_PROVIDER)
+
+
+def _post_gemini(key: str, model: str, messages: list, max_tokens: int, timeout: int = 60) -> str:
+    """Call Google Gemini API (non-OpenAI format)."""
+    # Convert OpenAI message format to Gemini format
+    contents = []
+    system_text = ""
+    for msg in messages:
+        role = msg["role"]
+        if role == "system":
+            system_text = msg["content"]
+            continue
+        contents.append({
+            "role": "user" if role == "user" else "model",
+            "parts": [{"text": msg["content"]}],
+        })
+
+    body = {
+        "contents": contents,
+        "generationConfig": {"maxOutputTokens": max_tokens},
+    }
+    if system_text:
+        body["systemInstruction"] = {"parts": [{"text": system_text}]}
+
+    url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?key={key}"
+    r = requests.post(url, json=body, timeout=timeout)
+    r.raise_for_status()
+    data = r.json()
+    return _clean(data["candidates"][0]["content"]["parts"][0]["text"])
+
+
+def get_available_providers() -> list[dict]:
+    """Return list of available providers with their model info."""
+    providers = []
+    for name, prov in _AVAILABLE.items():
+        providers.append({
+            "name": name,
+            "model_free": _FREE_MODELS.get(name, ""),
+            "model_premium": _PREMIUM_MODELS.get(name, ""),
+        })
+    return providers
+
+
+def call_ai_single(provider_name: str, messages: list, system: str = "",
+                   max_tokens: int = 2048, use_premium: bool = True) -> str:
+    """Call a specific provider directly (no fallback chain)."""
+    if provider_name not in _AVAILABLE:
+        raise ValueError(f"Provider {provider_name!r} not available")
+    prov = _AVAILABLE[provider_name]
+    models = _PREMIUM_MODELS if use_premium else _FREE_MODELS
+    model = models.get(provider_name, prov.get("model", ""))
+    if system:
+        messages = [{"role": "system", "content": system}] + messages
+    if provider_name == "gemini":
+        return _post_gemini(prov["key"], model, messages, max_tokens, prov["timeout"])
+    return _post_openai(
+        prov["url"], prov["key"], model,
+        messages, max_tokens, prov["extra"], prov["timeout"]
+    )
+
 
 _RE_THINK = re.compile(r"<think>.*?</think>", re.DOTALL)
 _RE_OPEN  = re.compile(r"^```[a-z]*\n?", re.MULTILINE)
@@ -77,8 +220,28 @@ def _post_openai(url, key, model, messages, max_tokens, extra_headers, timeout=6
     r.raise_for_status()
     return _clean(r.json()["choices"][0]["message"]["content"])
 
+
+def _build_chain(task_hint: str) -> list[dict]:
+    """Build an ordered provider chain for the given task hint."""
+    hint = task_hint if task_hint in _TASK_PRIORITY else "default"
+    priority = _TASK_PRIORITY[hint]
+    models = _TASK_MODELS.get(hint, _FREE_MODELS)
+
+    chain = []
+    for name in priority:
+        if name in _AVAILABLE:
+            prov = _AVAILABLE[name].copy()
+            prov["model"] = models.get(name, _FREE_MODELS.get(name, ""))
+            chain.append(prov)
+    return chain
+
+
 def call_ai(messages: list, system: str = "", max_tokens: int = 2048,
-            api_key_row: dict | None = None) -> str:
+            api_key_row: dict | None = None, task_hint: str = "default") -> str:
+    """Call AI with smart task-based routing.
+
+    task_hint: "arabic" | "code" | "fast" | "default"
+    """
     if system:
         messages = [{"role": "system", "content": system}] + messages
     # Custom API key path (used by e.g. Wasit/Amin integrations)
@@ -101,16 +264,23 @@ def call_ai(messages: list, system: str = "", max_tokens: int = 2048,
     if not _AI_AVAILABLE:
         raise RuntimeError("No AI provider. Set GROQ_API_KEY or similar in .env")
     # Ollama-only path
-    if not _PROVIDERS and _OLLAMA_PROVIDER:
+    if not _AVAILABLE and _OLLAMA_PROVIDER:
         r = requests.post(f"{_OLLAMA_BASE}/api/chat",
             json={"model": _OLLAMA_PROVIDER["model"], "messages": messages, "stream": False},
             timeout=120)
         r.raise_for_status()
         return _clean(r.json()["message"]["content"])
-    # Runtime chain: try each provider, fall back on 429 or transient errors
+    # Smart task-routed chain
+    chain = _build_chain(task_hint)
+    if not chain:
+        chain = _build_chain("default")
+
     last_exc = None
-    for prov in _PROVIDERS:
+    for prov in chain:
         try:
+            logger.debug("Trying %s/%s for task=%s", prov["name"], prov["model"], task_hint)
+            if prov["name"] == "gemini":
+                return _post_gemini(prov["key"], prov["model"], messages, max_tokens, prov["timeout"])
             return _post_openai(
                 prov["url"], prov["key"], prov["model"],
                 messages, max_tokens, prov["extra"], prov["timeout"]
@@ -214,6 +384,7 @@ def _extract_json(raw: str):
     raise ValueError(f"AI returned non-JSON: {raw[:200]}")
 
 def call_ai_json(messages: list, system: str = "", max_tokens: int = 2048,
-                 api_key_row: dict | None = None) -> dict | list:
-    raw = call_ai(messages, system=system, max_tokens=max_tokens, api_key_row=api_key_row)
+                 api_key_row: dict | None = None, task_hint: str = "default") -> dict | list:
+    raw = call_ai(messages, system=system, max_tokens=max_tokens,
+                  api_key_row=api_key_row, task_hint=task_hint)
     return _extract_json(raw)