modules/ai_provider.py

"""
AI provider layer — OpenAI-compatible.

TelegramGuard talks to any OpenAI-compatible chat API: SiliconFlow (default),
OpenAI, DeepSeek, a local vLLM/Ollama, or any relay. Business code never imports
a vendor SDK — it calls generate_text / generate_vision / generate_audio here.

Config (all via env, see config.py):
  AI_API_KEY        — your key
  AI_BASE_URL       — endpoint (default https://api.siliconflow.cn/v1)
  AI_MODEL          — text model
  AI_VISION_MODELS  — comma-separated vision fallback chain (first fails -> next)
  AI_AUDIO_MODEL    — audio-capable model (optional; voice degrades gracefully)
  AI_IMAGE_MAX_WIDTH — downscale images before upload (default 600)

Optional second provider, used only when the primary is unreachable:
  AI_FALLBACK_API_KEY  — set this to enable the fallback at all
  AI_FALLBACK_BASE_URL — endpoint of the backup relay/vendor
  AI_FALLBACK_MODEL    — text/judge model there
  AI_FALLBACK_VISION_MODEL — vision model there (optional; text model is
                             reused when this is unset)
Leave AI_FALLBACK_API_KEY empty and behaviour is exactly as before.

Design: lazy client init (no network at import, no crash on missing key),
images downscaled before upload, vision falls back down the model chain.
"""

import base64
import io
import logging

import config

logger = logging.getLogger(__name__)

try:
    from openai import AsyncOpenAI
except ImportError:
    AsyncOpenAI = None

try:
    from PIL import Image
except ImportError:
    Image = None


class AIError(Exception):
    pass


_clients = {}

PRIMARY = "primary"
FALLBACK = "fallback"


def _get_client(which=PRIMARY):
    if AsyncOpenAI is None:
        raise AIError("openai package not installed (pip install openai)")
    if which not in _clients:
        if which == FALLBACK:
            key = getattr(config, "AI_FALLBACK_API_KEY", "")
            base = getattr(config, "AI_FALLBACK_BASE_URL", "")
            if not key or not base:
                raise AIError("fallback provider not configured")
        else:
            key = getattr(config, "AI_API_KEY", "")
            base = getattr(config, "AI_BASE_URL", "https://api.siliconflow.cn/v1")
            if not key:
                raise AIError("AI_API_KEY not set")
        _clients[which] = AsyncOpenAI(api_key=key, base_url=base, timeout=90)
    return _clients[which]


def _fallback_enabled():
    return bool(getattr(config, "AI_FALLBACK_API_KEY", "")
                and getattr(config, "AI_FALLBACK_BASE_URL", ""))


def _with_fallback(models, vision=False):
    """Append the backup provider to a model chain, if one is configured.

    Entries are either "model" (primary provider) or (FALLBACK, "model").
    Without AI_FALLBACK_API_KEY this returns the chain untouched, so the
    default deployment behaves exactly as it did before.
    """
    if isinstance(models, str):
        models = [models]
    chain = list(models)
    if _fallback_enabled():
        m = ""
        if vision:
            m = getattr(config, "AI_FALLBACK_VISION_MODEL", "")
        if not m:
            m = getattr(config, "AI_FALLBACK_MODEL", "")
        if m:
            chain.append((FALLBACK, m))
    return chain


def _text_model():
    return getattr(config, "AI_MODEL", "deepseek-ai/DeepSeek-V4-Flash")


def _vision_models():
    raw = getattr(config, "AI_VISION_MODELS", "")
    if raw:
        return [m.strip() for m in raw.split(",") if m.strip()]
    return [
        "Qwen/Qwen3-VL-30B-A3B-Instruct",
        "Qwen/Qwen3-VL-32B-Instruct",
        "Qwen/Qwen3-VL-8B-Instruct",
    ]


def _audio_model():
    return getattr(config, "AI_AUDIO_MODEL", "Qwen/Qwen3-Omni-30B-A3B-Instruct")


def _compress(image_bytes):
    max_w = getattr(config, "AI_IMAGE_MAX_WIDTH", 600)
    if Image is None or not max_w:
        return image_bytes
    try:
        img = Image.open(io.BytesIO(image_bytes))
        if img.mode not in ("RGB", "L"):
            img = img.convert("RGB")
        if img.width > max_w:
            h = max(1, int(img.height * max_w / img.width))
            img = img.resize((max_w, h))
        out = io.BytesIO()
        img.save(out, format="JPEG", quality=85)
        return out.getvalue()
    except Exception as e:
        logger.warning("image compress failed, using original: " + str(e))
        return image_bytes


def _image_part(image_bytes):
    b64 = base64.b64encode(_compress(image_bytes)).decode()
    return {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64," + b64}}


async def _chat(models, messages, max_tokens, temperature):
    if isinstance(models, str):
        models = [models]
    last_err = None
    for entry in models:
        # entry is "model" (primary provider) or (FALLBACK, "model")
        try:
            if isinstance(entry, (tuple, list)):
                which, m = entry[0], entry[1]
            else:
                which, m = PRIMARY, entry
            client = _get_client(which)
        except Exception as e:
            last_err = e
            logger.warning("[AI] entry %r unusable: %s, skipping", entry, e)
            continue
        try:
            resp = await client.chat.completions.create(
                model=m, messages=messages, max_tokens=max_tokens, temperature=temperature
            )
            txt = (resp.choices[0].message.content or "").strip()
            if txt:
                return txt
            last_err = AIError("empty response")
        except Exception as e:
            last_err = e
            logger.warning("[AI] provider=%s model=%s failed: %s", which, m, e)
    raise AIError("all models failed: " + str(last_err))


async def generate_text(prompt, system=None, max_tokens=800, temperature=0.7):
    msgs = []
    if system:
        msgs.append({"role": "system", "content": system})
    msgs.append({"role": "user", "content": prompt})
    return await _chat(_with_fallback(_text_model()), msgs, max_tokens, temperature)


async def generate_vision(prompt, image_bytes, system=None, max_tokens=800, temperature=0.4):
    msgs = []
    if system:
        msgs.append({"role": "system", "content": system})
    msgs.append({"role": "user", "content": [
        {"type": "text", "text": prompt},
        _image_part(image_bytes),
    ]})
    return await _chat(_with_fallback(_vision_models(), vision=True), msgs, max_tokens, temperature)


async def generate_audio(prompt, audio_bytes, fmt="ogg", system=None, max_tokens=800, temperature=0.7):
    b64 = base64.b64encode(audio_bytes).decode()
    msgs = []
    if system:
        msgs.append({"role": "system", "content": system})
    msgs.append({"role": "user", "content": [
        {"type": "text", "text": prompt},
        {"type": "input_audio", "input_audio": {"data": b64, "format": fmt}},
    ]})
    return await _chat(_audio_model(), msgs, max_tokens, temperature)