Dépendances CUDA & Bot Telegram optionnel

✅ Solution 1 : Imports conditionnels

Remplacer les imports globaux par des imports conditionnels :

# alfred.py — remplacer les lignes 18-19

# Imports conditionnels
if TELEGRAM_TOKEN:
    from telegram import Bot, Update
    from telegram.request import HTTPXRequest
    TELEGRAM_AVAILABLE = True
else:
    Bot = None
    Update = None
    TELEGRAM_AVAILABLE = False

Cela permet au serveur de démarrer sans python-telegram-bot installé. Les fonctionnalités Telegram sont désactivées gracieusement.

✅ Solution 2 : Bot conditionnel dans lifespan()

Modifier lifespan() pour ne gérer le bot que s'il existe :

@asynccontextmanager
async def lifespan(app: FastAPI):
    # ... chargement historique ...

    if TELEGRAM_AVAILABLE:
        await register_tools(bot, call_llm_subagent, CONFIG, LAST_SOURCE, WS_CONNECTIONS, model_service)
    else:
        await register_tools(None, call_llm_subagent, CONFIG, LAST_SOURCE, WS_CONNECTIONS, model_service)

    heartbeat_task = asyncio.create_task(heartbeat_loop())
    unload_task = asyncio.create_task(model_service.unload_loop())

    if TELEGRAM_AVAILABLE:
        async with bot:
            yield
    else:
        yield

    heartbeat_task.cancel()
    unload_task.cancel()
    await client.aclose()

✅ Solution 3 : Webhook conditionnel

Monter le webhook uniquement si le token est défini :

if TELEGRAM_AVAILABLE:
    @app.post("/webhook/telegram")
    async def telegram_endpoint(http_request: Request, background_tasks: BackgroundTasks):
        # ... code existant ...
        pass

Ou utiliser une route conditionnelle dans app.router.routes après la création de l'app.

✅ Solution 4 : Heartbeat multi-canal

Modifier trigger_heartbeat() pour utiliser tous les canaux actifs, pas seulement Telegram :

async def trigger_heartbeat(chat_id: str):
    hb_file = Path(f"alfred-data/{chat_id}/heartbeat.md")
    if not hb_file.exists():
        return

    if chat_id in ACTIVE_TASKS:
        logger.info(f"[{chat_id}] Heartbeat ignoré : une tâche est déjà active.")
        return

    channels = []
    if TELEGRAM_AVAILABLE:
        channels.append(TelegramChannel(bot, mcp))
    # Ajouter WebSocketChannel si des connections WebSocket existent

    for channel in channels:
        request = ChannelRequest(chat_id, hb_file.read_text(encoding="utf-8"))
        await process_request(channel, request)

✅ Solution 5 : Outils MCP conditionnels

Dans mcp_server.py, les commandes /link_xxx et /confirm_link doivent être enregistrées uniquement si bot est disponible. Le register_tools() doit accepter bot=None et filtrer les outils dépendants de Telegram.

✅ Solution 1 : Extras dans pyproject.toml

Séparer les dépendances en extras optionnels. L'utilisateur installe uniquement ce dont il a besoin :

# pyproject.toml

[project]
dependencies = [
    "fastapi>=0.110.0",
    "uvicorn>=0.29.0",
    "httpx>=0.27.0",
    "python-dotenv>=1.0.0",
    "jinja2>=3.1.0",
    "asyncio>=3.4.3",
    "aiofiles>=24.1.0",
    "soundfile>=0.12.1",
    "static-ffmpeg>=2.4",
    "websockets>=13.0",
    "PyJWT>=2.8.0",
    "python-multipart>=0.0.9",
    "orjson>=3.10.0",
    "mcp>=1.0.0",
]

[project.optional-dependencies]
image = [
    "torch>=2.3.0",
    "diffusers>=0.30.0",
    "transformers>=4.41.0",
    "accelerate>=0.33.0",
    "sentencepiece>=0.2.0",
]
audio = [
    "omnivoice>=1.0.0",
    "soundfile>=0.12.1",
    "faster-whisper>=1.0.0",
    "ctranslate2>=4.3.0",
]
telegram = [
    "python-telegram-bot[httpx]>=21.7",
]
full = [
    "alfred[image,audio,telegram]",
]

[tool.uv]
# Configuration UV spécifique
compile-bytecode = true

Installation minimale : uv sync (juste le serveur web)
Installation IA : uv sync --extra full (tout)
Installation ciblée : uv sync --extra image (juste la génération d'images)

✅ Solution 2 : Imports lazy dans model_service.py

Déplacer les imports lourds à l'intérieur des méthodes qui les utilisent, pas au niveau du module :

# model_service.py

class ModelService:
    def __init__(self, device="CPU", timeout=900):
        self._models = {}
        self._last_used = {}
        self._device = device
        self.timeout = timeout
        self._loaders = {
            "image_generation": self._load_sdxl_turbo,
            "audio_generation": self._load_omnivoice,
            "audio_transcription": self._load_whisper_medium,
        }

    async def _load_sdxl_turbo(self):
        # Import lazy — ne plante que si on appelle cette méthode
        try:
            import torch
            from diffusers import AutoPipelineForText2Image
        except ImportError as e:
            raise RuntimeError("Package 'torch' et 'diffusers' requis pour la génération d'images. Installez : uv pip install alfred[image]") from e

        # ... reste du chargement ...

    async def _load_omnivoice(self):
        try:
            from omnivoice import OmniVoice
        except ImportError as e:
            raise RuntimeError("Package 'omnivoice' requis pour la synthèse vocale. Installez : uv pip install alfred[audio]") from e

    async def _load_whisper_medium(self):
        try:
            from faster_whisper import WhisperModel
        except ImportError as e:
            raise RuntimeError("Package 'faster-whisper' requis pour la transcription. Installez : uv pip install alfred[audio]") from e

✅ Solution 3 : Feature flags dans .env

Ajouter des variables d'environnement pour contrôler quelles fonctionnalités sont activées :

# .env

# Fonctionnalités
ENABLE_IMAGE_GEN=true
ENABLE_AUDIO_GENERATION=true
ENABLE_AUDIO_TRANSCRIPTION=true
ENABLE_TELEGRAM=true

# Si ENABLE_TELEGRAM=false, le bot n'est jamais instancié
# Si ENABLE_IMAGE_GEN=false, torch/diffusers ne sont jamais importés
# Si ENABLE_AUDIO_GENERATION=false, omnivoice n'est jamais importé
# Si ENABLE_AUDIO_TRANSCRIPTION=false, faster-whisper n'est jamais importé

Dans model_service.py, le constructeur vérifie ces flags :

class ModelService:
    def __init__(self, device="CPU", timeout=900):
        self._models = {}
        self._last_used = {}
        self._device = device
        self.timeout = timeout

        # Enregistrer les loaders conditionnellement
        if os.getenv("ENABLE_IMAGE_GEN", "false").lower() == "true":
            self._loaders["image_generation"] = self._load_sdxl_turbo

        if os.getenv("ENABLE_AUDIO_GENERATION", "false").lower() == "true":
            self._loaders["audio_generation"] = self._load_omnivoice

        if os.getenv("ENABLE_AUDIO_TRANSCRIPTION", "false").lower() == "true":
            self._loaders["audio_transcription"] = self._load_whisper_medium

✅ Solution 4 : PyTorch CPU par défaut

Dans pyproject.toml, utiliser PyTorch CPU par défaut et un extra CUDA :

[project.optional-dependencies]
torch-cpu = [
    "torch>=2.3.0",
]
torch-cuda = [
    "torch>=2.3.0",
    "torchvision>=0.18.0",
    "torchaudio>=2.3.0",
]

# Par défaut, on installe le CPU
[tool.uv]
default-extras = ["torch-cpu"]

Ou utiliser les indices PyTorch officiels :

# Dans pyproject.toml
[[tool.uv.index]]
name = "pytorch-cpu"
url = "https://download.pytorch.org/whl/cpu"

# Dans les dépendances
"torch>=2.3.0; extra == 'image' and not sys_platform == 'darwin'"]