astrololo/services/logic/app/llm/factory.py

"""Wybór dostawcy LLM (LOG-31) — jedyne miejsce znające konkretne implementacje.

Domyślny jest **model lokalny**: prompt niesie oryginalne opisy z baz, więc
domyślnie nic nie opuszcza naszej sieci (LOG-32). Chmurę włącza się świadomie —
przez konfigurację albo pojedyncze żądanie.

Konfiguracja jest **per dostawca**, bo UI pozwala przełączać go przy każdym żądaniu.
Wspólne `LLM_*` nie wystarczy: ustawienie `LLM_BASE_URL` na lokalny model kierowałoby
tam także żądania do OpenAI, a `LLM_MODEL=llama3.1:8b` kazałoby Anthropic użyć modelu
llama. Dlatego każdy dostawca ma własny komplet zmiennych.

Zmienne środowiskowe:
  LLM_PROVIDER      local (domyślnie) | openai | anthropic — dostawca domyślny
  LLM_TIMEOUT       sekundy (domyślnie 120)
  LLM_MAX_TOKENS    limit długości odpowiedzi (domyślnie 2000)

  <DOSTAWCA>_MODEL / _BASE_URL / _API_KEY — konfiguracja konkretnego dostawcy:
  LOCAL_MODEL, LOCAL_BASE_URL                          (klucz zwykle zbędny)
  OPENAI_MODEL, OPENAI_BASE_URL, OPENAI_API_KEY
  ANTHROPIC_MODEL, ANTHROPIC_BASE_URL, ANTHROPIC_API_KEY

  Klucze WYŁĄCZNIE z sekretu — nigdy w repo, w UI ani w logach.

Zgodność wstecz: wspólne `LLM_MODEL` / `LLM_BASE_URL` / `LLM_API_KEY` nadal działają,
ale stosują się TYLKO do dostawcy domyślnego (LLM_PROVIDER) — czyli konfiguracja
instalacji jednodostawcowej zostaje nietknięta, a pozostali dostawcy jej nie dziedziczą.
"""
from __future__ import annotations

import os

from app.llm.base import LLMError, LLMProvider
from app.llm.providers import AnthropicProvider, ChatCompletionsProvider

LOCAL = "local"
OPENAI = "openai"
ANTHROPIC = "anthropic"
PROVIDERS = (LOCAL, OPENAI, ANTHROPIC)

_DEFAULT_MODEL = {
    LOCAL: "llama3.1:8b",
    OPENAI: "gpt-4o-mini",
    ANTHROPIC: "claude-sonnet-5",
}
_DEFAULT_URL = {
    # Ollama i vLLM wystawiają zgodne API pod /v1
    LOCAL: "http://localhost:11434/v1",
    OPENAI: "https://api.openai.com/v1",
    ANTHROPIC: "https://api.anthropic.com",
}


def default_provider_name() -> str:
    return os.getenv("LLM_PROVIDER", LOCAL).lower()


def max_tokens() -> int:
    return int(os.getenv("LLM_MAX_TOKENS", "2000"))


def timeout() -> float:
    return float(os.getenv("LLM_TIMEOUT", "120"))


def setting(provider: str, suffix: str, fallback: str = "") -> str:
    """Ustawienie dostawcy: <DOSTAWCA>_<SUFIKS> → LLM_<SUFIKS> → wbudowana domyślna.

    Wspólne `LLM_*` stosuje się WYŁĄCZNIE do dostawcy domyślnego — inaczej adres
    lokalnego modelu przejąłby żądania do chmury (i odwrotnie).
    """
    specific = os.getenv(f"{provider.upper()}_{suffix}")
    if specific:
        return specific
    if provider == default_provider_name():
        generic = os.getenv(f"LLM_{suffix}")
        if generic:
            return generic
    return fallback


def build_provider(name: str | None = None) -> LLMProvider:
    name = (name or default_provider_name()).lower()
    if name not in PROVIDERS:
        raise LLMError(f"Nieznany dostawca LLM: {name!r} (dostępne: {', '.join(PROVIDERS)})")

    model = setting(name, "MODEL", _DEFAULT_MODEL[name])
    base_url = setting(name, "BASE_URL", _DEFAULT_URL[name])
    api_key = setting(name, "API_KEY")

    if name in (OPENAI, ANTHROPIC) and not api_key:
        raise LLMError(
            f"Brak klucza dla dostawcy {name} — ustaw {name.upper()}_API_KEY "
            f"(z sekretu). Model lokalny klucza nie wymaga."
        )
    if name == ANTHROPIC:
        return AnthropicProvider(base_url, model, api_key, timeout())
    if name == OPENAI:
        return ChatCompletionsProvider(OPENAI, base_url, model, api_key, timeout(),
                                       leaves_lan=True)
    # lokalny — klucz zwykle zbędny; treść NIE opuszcza sieci
    return ChatCompletionsProvider(LOCAL, base_url, model, api_key, timeout(),
                                   leaves_lan=False)