@danhachuel/thunderbolt 0.3.12 → 0.3.14

package/app/main.py

@@ -34,6 +34,7 @@ from hermes_ui.cuts import CutsError, download_direct_video_url, generate_clips,
 from hermes_ui.mcp import detect_local_service, install_skill_locally, load_integrations, load_server_config, read_packaged_skill, save_server_config, update_integration
 from hermes_ui.mcp_server import server_status, start_server, stop_server
 from hermes_ui.material_sources import material_api_keys, material_source_catalog, selected_material_source, update_material_api_keys
+from hermes_ui.llm_providers import LLM_CARDS_KEY, LLM_ACTIVE_CARD_KEY, LLM_PROVIDER_CATALOG, apply_llm_cards_to_settings, ensure_llm_provider_cards, new_llm_card, normalize_llm_card, provider_definition, test_llm_provider_card, stamp_test_result
 from hermes_ui.music import list_music_files, materialize_suno_audio, request_suno_generation, store_music_file
 from hermes_ui.media_downloader import AUDIO_FORMATS, VIDEO_CONTAINERS, VIDEO_QUALITY_OPTIONS, MediaDownloadError, build_download_options, clear_media_download_history, dependency_status, download_media, list_media_downloads, media_download_file
 from hermes_ui.notifications import clear_notifications, list_notifications, mark_all_notifications_read, mark_notification_read, notification_event_catalog, notification_preferences, record_notification, reconcile_persisted_notifications, save_notification_preferences, unread_notification_count
@@ -54,7 +55,7 @@ from integrations.youtube_direct_credentials import delete_credentials_document,
 from integrations.youtube_batch import account_key as youtube_batch_account_key, account_status as youtube_batch_account_status, authorize_account as authorize_youtube_batch_account, delete_account_token as delete_youtube_batch_token, list_my_channels as list_youtube_batch_channels, loopback_redirect_uri
 from integrations.local_runtime import MoneyPrinterRuntime
 from integrations.moneyprinter_config import sync_moneyprinter_config
-from integrations.openai_model_discovery import DEFAULT_NVIDIA_NIM_BASE_URL, ModelDiscoveryError, fetch_openai_compatible_models
+from integrations.openai_model_discovery import DEFAULT_NVIDIA_NIM_BASE_URL
 
 DEFAULT_UI_LANGUAGE = "en"
 
@@ -206,6 +207,15 @@ st.markdown("""
 [data-testid="stRadio"] label { border:1px solid color-mix(in srgb, currentColor 18%, transparent); background:color-mix(in srgb, currentColor 4%, transparent); }
 [data-testid="stRadio"] label:has(input:checked) { border-color:var(--tb-gold); background:rgba(197,155,85,.24); }
 [data-testid="stRadio"] label:has(input:checked) { background:linear-gradient(145deg, color-mix(in srgb, var(--tb-gold) 24%, transparent), color-mix(in srgb, currentColor 6%, transparent)); }
+.tb-api-status { display:inline-flex; align-items:center; gap:.38rem; margin:.08rem 0 .55rem; padding:.18rem .55rem; border-radius:999px; font-size:.78rem; font-weight:700; line-height:1.2; border:1px solid rgba(128,128,128,.24); }
+.tb-api-status__dot { display:inline-flex; align-items:center; justify-content:center; width:1rem; height:1rem; border-radius:50%; font-size:.68rem; font-weight:800; }
+.tb-api-status--missing { color:#9a6700; background:rgba(245,158,11,.16); border-color:rgba(245,158,11,.45); }
+.tb-api-status--missing .tb-api-status__dot { color:#fff; background:#d99000; }
+.tb-api-status--local { color:#2563eb; background:rgba(59,130,246,.10); border-color:rgba(59,130,246,.35); }
+.tb-api-status--ready { color:#15803d; background:rgba(34,197,94,.12); border-color:rgba(34,197,94,.36); }
+.tb-api-status--ready .tb-api-status__dot { color:#fff; background:#16a34a; }
+.tb-api-status--error { color:#b91c1c; background:rgba(239,68,68,.10); border-color:rgba(239,68,68,.34); }
+.tb-api-status--error .tb-api-status__dot { color:#fff; background:#dc2626; }
 [data-testid="stStatusWidget"] { border-color:rgba(128,128,128,.28) !important; background:rgba(128,128,128,.06) !important; }
 [data-testid="stStatusWidget"] { border-color:color-mix(in srgb, currentColor 18%, transparent) !important; background:color-mix(in srgb, currentColor 4%, transparent) !important; }
 /* O menu de idiomas usa layout nativo da aplicação; o toolbar do Streamlit não é alterado. */
@@ -3671,6 +3681,7 @@ def render_material_source_api_keys(settings: dict[str, Any]) -> None:
     row_key = f"material_source_key_rows_{selected_source}"
     row_count = max(len(current_keys), int(st.session_state.get(row_key, len(current_keys) or 1)))
     if selected_source == "local":
+        _render_credential_status("", local=True, required=False)
         st.info("A fonte local não usa API key. Os materiais devem existir na pasta configurada do storage.")
         if st.button("Guardar fonte local", type="primary", key="save_local_material_source"):
             settings["video_source"] = selected_source
@@ -3678,6 +3689,7 @@ def render_material_source_api_keys(settings: dict[str, Any]) -> None:
             st.success("Fonte de materiais guardada: ficheiros locais.")
             st.rerun()
         return
+    _render_credential_status(any(str(item or "").strip() for item in current_keys))
     with st.form(f"material_api_keys_form_{selected_source}"):
         key_values: list[str] = []
         for index in range(row_count):
@@ -3697,6 +3709,199 @@ def render_material_source_api_keys(settings: dict[str, Any]) -> None:
     st.caption(f"{len(current_keys)} chave(s) actualmente guardada(s) para {source_labels.get(selected_source, selected_source)}. As chaves são mantidas no storage local e usadas com rotação interna.")
 
 
+def _api_status_badge(label: str, kind: str = "missing") -> None:
+    """Render a compact status chip that remains legible in both native themes."""
+    safe_kind = kind if kind in {"missing", "local", "ready", "error"} else "missing"
+    marker = "!" if safe_kind == "missing" else "✓" if safe_kind == "ready" else "×" if safe_kind == "error" else "•"
+    visible_label = ui_text(label, current_ui_language())
+    st.markdown(
+        f'<span class="tb-api-status tb-api-status--{safe_kind}"><span class="tb-api-status__dot">{marker}</span>{visible_label}</span>',
+        unsafe_allow_html=True,
+    )
+
+
+def _credential_status(value: Any, *, local: bool = False, required: bool = True) -> tuple[str, str]:
+    if local:
+        return "local", "Local / sem API key"
+    if required and not str(value or "").strip():
+        return "missing", "Missing key"
+    return "ready", "Configured"
+
+
+def _render_credential_status(value: Any, *, local: bool = False, required: bool = True) -> None:
+    kind, label = _credential_status(value, local=local, required=required)
+    _api_status_badge(label, kind)
+
+
+def _llm_card_config_status(card: dict[str, Any]) -> tuple[str, str]:
+    definition = provider_definition(card.get("provider"))
+    if definition.local:
+        return "local", "Local / sem API key"
+    if definition.requires_api_key and not str(card.get("api_key") or "").strip():
+        return "missing", "Missing key"
+    if definition.show_base_url and not str(card.get("base_url") or "").strip():
+        return "missing", "Missing configuration"
+    if not str(card.get("model") or "").strip():
+        return "missing", "Missing configuration"
+    return "ready", "Configured"
+
+
+def _persist_llm_cards(settings: dict[str, Any], cards: list[dict[str, Any]], active_id: str = "") -> dict[str, Any]:
+    updated = apply_llm_cards_to_settings(settings, cards, active_id)
+    write_json("settings.json", updated)
+    return updated
+
+
+def _render_llm_card(settings: dict[str, Any], cards: list[dict[str, Any]], index: int) -> None:
+    card = normalize_llm_card(cards[index], index)
+    cards[index] = card
+    card_id = str(card["id"])
+    definition = provider_definition(card.get("provider"))
+    with st.container(border=True):
+        header_cols = st.columns([3.2, 1.2])
+        with header_cols[0]:
+            st.subheader(definition.label)
+            if definition.description:
+                st.caption(definition.description)
+        with header_cols[1]:
+            status_kind, status_label = _llm_card_config_status(card)
+            _api_status_badge(status_label, status_kind)
+        with st.form(f"llm_card_form_{card_id}"):
+            key_col, model_col = st.columns(2)
+            with key_col:
+                api_key = card.get("api_key", "")
+                if definition.requires_api_key:
+                    api_key = st.text_input("API key", value=str(api_key or ""), type="password", key=f"llm_card_{card_id}_api_key")
+                else:
+                    st.caption("Este provider não exige API key.")
+                    api_key = ""
+            with model_col:
+                model_catalog = st.session_state.get(f"llm_model_catalog_{card_id}", [])
+                current_model = str(card.get("model") or "")
+                if model_catalog:
+                    manual_model = "__manual_model__"
+                    options = [manual_model, *[str(item) for item in model_catalog]]
+                    selected = st.selectbox(
+                        "Modelo",
+                        options,
+                        index=options.index(current_model) if current_model in options else 0,
+                        format_func=lambda value: "Escrever modelo manualmente" if value == manual_model else value,
+                        key=f"llm_card_{card_id}_model_select",
+                    )
+                    model = st.text_input("Modelo manual", value=current_model if selected == manual_model and current_model not in model_catalog else "", key=f"llm_card_{card_id}_model_manual") if selected == manual_model else selected
+                else:
+                    model = st.text_input("Modelo", value=current_model, help="ID do modelo usado pelo endpoint Chat Completions.", key=f"llm_card_{card_id}_model")
+            if definition.show_base_url:
+                base_url = st.text_input(
+                    "Base URL",
+                    value=str(card.get("base_url") or definition.default_base_url),
+                    help="Endpoint OpenAI-compatible deste provider; só aparece quando é configurável.",
+                    key=f"llm_card_{card_id}_base_url",
+                )
+            else:
+                base_url = str(card.get("base_url") or definition.default_base_url)
+                if base_url:
+                    st.caption(f"Endpoint gerido pelo provider: {base_url}")
+            extra_values: dict[str, str] = {}
+            if definition.extra_fields:
+                extra_cols = st.columns(len(definition.extra_fields))
+                for extra_col, field_name in zip(extra_cols, definition.extra_fields):
+                    with extra_col:
+                        extra_values[field_name] = st.text_input(
+                            field_name.replace("_", " ").title(),
+                            value=str(card.get(field_name) or ""),
+                            key=f"llm_card_{card_id}_{field_name}",
+                        )
+            enabled = st.checkbox("Provider activo", value=bool(card.get("enabled", True)), key=f"llm_card_{card_id}_enabled")
+            primary_llm = st.checkbox(
+                "LLM principal",
+                value=str(settings.get(LLM_ACTIVE_CARD_KEY) or "") == card_id,
+                help="Usar este cartão como provider principal para geração de temas, roteiros, títulos e keywords.",
+                key=f"llm_card_{card_id}_primary",
+            )
+            telegram_llm = st.checkbox(
+                "LLM Telegram",
+                value=bool(card.get("telegram_llm", False)),
+                help="Usar este cartão exclusivamente para o roteamento de notificações Telegram. Apenas um cartão pode ficar seleccionado.",
+                key=f"llm_card_{card_id}_telegram",
+            )
+            action_cols = st.columns([1.35, 1.35, 1.1])
+            with action_cols[0]:
+                test_clicked = st.form_submit_button("Testar chamada API", use_container_width=True)
+            with action_cols[1]:
+                refresh_clicked = st.form_submit_button("Consultar modelos", use_container_width=True)
+            with action_cols[2]:
+                save_clicked = st.form_submit_button("Salvar", type="primary", use_container_width=True)
+            remove_clicked = False
+            if definition.code != "openai":
+                remove_clicked = st.form_submit_button("Remover cartão", use_container_width=True)
+
+        edited = dict(card)
+        edited.update({"api_key": str(api_key or "").strip(), "model": str(model or "").strip(), "base_url": str(base_url or "").strip(), "enabled": bool(enabled), "telegram_llm": bool(telegram_llm), **extra_values})
+        cards[index] = edited
+        if test_clicked:
+            test_result = test_llm_provider_card(edited)
+            edited["test_result"] = stamp_test_result(test_result)
+            _persist_llm_cards(settings, cards, str(settings.get(LLM_ACTIVE_CARD_KEY) or card_id))
+            if test_result.get("ok"):
+                st.success(f"Teste API: {test_result['message']}")
+            else:
+                st.error(f"Teste API: {test_result['message']}")
+        elif refresh_clicked:
+            try:
+                from integrations.openai_model_discovery import fetch_openai_compatible_models
+                discovered = fetch_openai_compatible_models(edited.get("api_key", ""), edited.get("base_url", ""))
+                st.session_state[f"llm_model_catalog_{card_id}"] = discovered
+                _persist_llm_cards(settings, cards, str(settings.get(LLM_ACTIVE_CARD_KEY) or card_id))
+                st.success(f"{len(discovered)} modelo(s) disponíveis neste endpoint.")
+            except Exception:
+                st.error("Não foi possível consultar os modelos deste endpoint.")
+        elif save_clicked:
+            active_id = card_id if primary_llm and enabled else str(settings.get(LLM_ACTIVE_CARD_KEY) or "")
+            _persist_llm_cards(settings, cards, active_id)
+            st.success("Cartão LLM guardado.")
+            st.rerun()
+        elif remove_clicked:
+            remaining = [item for item in cards if str(item.get("id")) != card_id]
+            _persist_llm_cards(settings, remaining, str(settings.get(LLM_ACTIVE_CARD_KEY) or ""))
+            st.success("Cartão LLM removido.")
+            st.rerun()
+
+        saved_test = edited.get("test_result") or card.get("test_result")
+        if isinstance(saved_test, dict) and saved_test.get("message"):
+            if saved_test.get("status") == "success":
+                st.success(f"Último teste: {saved_test['message']}")
+            else:
+                st.error(f"Último teste: {saved_test['message']}")
+
+
+def render_llm_provider_cards(settings: dict[str, Any]) -> None:
+    """Renderizar cartões LLM fora da form global para permitir acções por cartão."""
+    migrated, changed = ensure_llm_provider_cards(settings)
+    cards = [dict(item) for item in migrated.get(LLM_CARDS_KEY, [])]
+    if changed:
+        settings.update(migrated)
+        write_json("settings.json", settings)
+    with st.expander("LLM — providers e modelos", expanded=False):
+        st.caption("Configure cada provider num cartão independente. Pode repetir o mesmo provider para manter várias API keys; o cartão activo é usado pela geração de conteúdo.")
+        for index in range(len(cards)):
+            _render_llm_card(settings, cards, index)
+        st.divider()
+        st.markdown("**Adicionar provider LLM**")
+        provider_codes = [item.code for item in LLM_PROVIDER_CATALOG]
+        provider_to_add = st.selectbox(
+            "Provider LLM",
+            provider_codes,
+            format_func=lambda value: ui_text(provider_definition(value).label, current_ui_language()),
+            key="llm_new_provider_choice",
+        )
+        if st.button("Configurar Novo Provedor LLM", type="primary", use_container_width=True, key="add_llm_provider_card"):
+            new_card = new_llm_card(provider_to_add, card_id=f"llm-{provider_to_add}-{uuid.uuid4().hex[:8]}")
+            cards.append(new_card)
+            _persist_llm_cards(settings, cards, str(settings.get(LLM_ACTIVE_CARD_KEY) or DEFAULT_LLM_CARD_ID))
+            st.rerun()
+
+
 def render_settings():
     st.title("Configuração API")
     st.caption("Configuração das APIs, providers, serviços e ferramentas técnicas usados pelo Thunderbolt. As credenciais ficam no storage local e não são enviadas para o GitHub.")
@@ -3729,6 +3934,7 @@ def render_settings():
                         kaggle_api_key = text_setting("Kaggle API Key", "kaggle_api_key", secret=True, help_text="Chave criada em Kaggle > Settings > API. Nunca é incluída no notebook ou no GitHub.")
                     with kaggle_cols[2]:
                         kaggle_kernel_slug = text_setting("Slug da kernel", "kaggle_kernel_slug", help_text="Identificador da kernel remota, por exemplo thunderbolt-niche-finder.")
+                    _render_credential_status(kaggle_api_key)
 
                 with st.expander("Niche Finder — execução através da Apify", expanded=False):
                     st.caption("O token fica guardado apenas no storage local. A aba Niche Finder Apify só usa este serviço depois de clicar no botão de pesquisa.")
@@ -3741,6 +3947,7 @@ def render_settings():
                         apify_poll_interval = st.number_input("Intervalo de consulta (s)", min_value=1, max_value=120, value=int(settings.get("apify_poll_interval_seconds", 10)), step=1)
                     with apify_cols[3]:
                         apify_run_timeout = st.number_input("Limite da execução (s)", min_value=30, max_value=7200, value=int(settings.get("apify_run_timeout_seconds", 900)), step=30)
+                    _render_credential_status(apify_api_token)
 
                 with st.expander("Nano Banana — geração de thumbnails", expanded=False):
                     st.caption("A Nano Banana gera a imagem final das thumbnails a partir da variante escolhida. A chave é guardada apenas no storage local e é distinta da chave do Gemini usado como LLM textual.")
@@ -3751,94 +3958,49 @@ def render_settings():
                     with nano_cols[1]:
                         gemini_image_aspect_ratio = st.selectbox("Proporção da thumbnail", ["16:9", "9:16", "1:1", "4:5"], index=["16:9", "9:16", "1:1", "4:5"].index(str(settings.get("gemini_image_aspect_ratio") or "16:9")) if str(settings.get("gemini_image_aspect_ratio") or "16:9") in {"16:9", "9:16", "1:1", "4:5"} else 0)
                         gemini_image_size = st.selectbox("Tamanho da imagem", ["1K", "2K", "4K"], index=["1K", "2K", "4K"].index(str(settings.get("gemini_image_size") or "1K")) if str(settings.get("gemini_image_size") or "1K") in {"1K", "2K", "4K"} else 0)
+                    _render_credential_status(gemini_image_api_key)
 
-                with st.expander("LLM — providers e modelos", expanded=False):
-                    provider_options = ["openai", "moonshot", "shengsuanyun", "gemini", "deepseek", "qwen", "azure", "volcengine", "grok", "minimax", "mimo", "cloudflare", "modelscope", "aihubmix", "aimlapi", "evolink", "ollama", "oneapi", "litellm", "groq", "pollinations"]
-                    current_llm_provider = str(settings.get("llm_provider") or DEFAULT_LLM_PROVIDER).strip().lower()
-                    llm_provider = st.selectbox("LLM provider", provider_options, index=provider_options.index(current_llm_provider) if current_llm_provider in provider_options else 0)
-                    st.markdown("**OpenAI/ NVIDIA NIM — API key, Base URL e modelo**")
-                    st.caption("O provider interno continua a ser `openai`, mas pode usar qualquer endpoint OpenAI-compatible. Para NVIDIA NIM, a Base URL predefinida é `https://integrate.api.nvidia.com/v1`; o selector consulta `/models` e deixa um campo manual como fallback.")
-                    openai_cols = st.columns(3)
-                    with openai_cols[0]:
-                        openai_api_key = text_setting("OpenAI/ NVIDIA NIM API key", "openai_api_key", secret=True, help_text="API key do OpenAI ou do NVIDIA Build/NIM. A credencial fica apenas no storage local.")
-                    with openai_cols[1]:
-                        openai_base_url = st.text_input("OpenAI/ NVIDIA NIM Base URL", value=str(settings.get("openai_base_url", "") or DEFAULT_NVIDIA_NIM_BASE_URL), help="Ex.: https://integrate.api.nvidia.com/v1. O Thunderbolt acrescenta /models para descobrir os modelos.", key="settings_openai_base_url")
-                    with openai_cols[2]:
-                        cached_catalog = st.session_state.get("openai_model_catalog", {})
-                        catalog_key = f"{openai_base_url.strip()}::{hashlib.sha256(openai_api_key.encode('utf-8')).hexdigest()}"
-                        cached_models = list(cached_catalog.get("models", [])) if cached_catalog.get("key") == catalog_key else []
-                        current_model_name = str(settings.get("openai_model_name", "") or "")
-                        manual_option = "__manual_model__"
-                        if cached_models:
-                            model_options = [manual_option, *cached_models]
-                            model_index = model_options.index(current_model_name) if current_model_name in model_options else 0
-                            selected_model = st.selectbox("Modelo OpenAI/ NVIDIA NIM", model_options, index=model_index, format_func=lambda value: "Escrever modelo manualmente" if value == manual_option else value, key="settings_openai_model_select")
-                            if selected_model == manual_option:
-                                openai_model_name = st.text_input("Modelo manual", value=current_model_name if current_model_name not in cached_models else "", help="Ex.: nvidia_nim/minimaxai/minimax-m3", key="settings_openai_model_manual")
-                            else:
-                                openai_model_name = selected_model
-                        else:
-                            openai_model_name = st.text_input("Modelo OpenAI/ NVIDIA NIM", value=current_model_name, help="Pode escrever um ID manualmente se o endpoint não disponibilizar /models.", key="settings_openai_model_name")
-                    refresh_openai_models = st.form_submit_button("Consultar/actualizar modelos NIM", use_container_width=True)
-                    if cached_catalog.get("key") == catalog_key and cached_catalog.get("error"):
-                        st.warning(str(cached_catalog["error"]))
-                    elif cached_models:
-                        st.caption(f"{len(cached_models)} modelo(s) carregado(s) a partir de {openai_base_url.rstrip('/')}/models.")
-                    else:
-                        st.info("Preencha a API key e clique em Consultar/actualizar modelos NIM para carregar os IDs disponíveis.")
-                    llm_fields = [
-                        ("Moonshot / Kimi", "moonshot", True), ("Shengsuan Cloud", "shengsuanyun", True),
-                        ("Google Gemini", "gemini", True), ("DeepSeek", "deepseek", True), ("Alibaba Qwen", "qwen", True),
-                        ("Azure OpenAI", "azure", True), ("VolcEngine Ark", "volcengine", True), ("xAI Grok", "grok", True),
-                        ("MiniMax", "minimax", True), ("Xiaomi MiMo", "mimo", True), ("Cloudflare AI Gateway", "cloudflare", True),
-                        ("ModelScope", "modelscope", True), ("AIHubMix", "aihubmix", True), ("AIML API", "aimlapi", True),
-                        ("EvoLink", "evolink", True), ("Ollama", "ollama", False), ("OneAPI", "oneapi", True),
-                        ("LiteLLM", "litellm", False), ("Groq", "groq", True), ("Pollinations AI", "pollinations", True),
-                    ]
-                    for label, prefix, has_key in llm_fields:
-                        st.markdown(f"**{label}**")
-                        cols = st.columns(3)
-                        with cols[0]:
-                            if has_key:
-                                settings[f"{prefix}_api_key"] = text_setting("API key", f"{prefix}_api_key", secret=True)
-                            else:
-                                settings[f"{prefix}_api_key"] = settings.get(f"{prefix}_api_key", "")
-                        with cols[1]:
-                            settings[f"{prefix}_base_url"] = text_setting("Base URL", f"{prefix}_base_url")
-                        with cols[2]:
-                            settings[f"{prefix}_model_name"] = text_setting("Model", f"{prefix}_model_name")
 
                 with st.expander("Voz, TTS e música — Azure Speech, restantes serviços e Suno", expanded=False):
                     cols = st.columns(2)
                     with cols[0]:
                         azure_speech_key = text_setting("Azure Speech key", "azure_speech_key", secret=True)
+                        _render_credential_status(azure_speech_key)
                         azure_speech_region = text_setting("Azure Speech region", "azure_speech_region")
                         siliconflow_tts_api_key = text_setting("SiliconFlow TTS API key", "siliconflow_tts_api_key", secret=True)
+                        _render_credential_status(siliconflow_tts_api_key)
                         minimax_tts_api_key = text_setting("MiniMax TTS API key", "minimax_tts_api_key", secret=True)
+                        _render_credential_status(minimax_tts_api_key)
                         minimax_tts_base_url = text_setting("MiniMax TTS Base URL", "minimax_tts_base_url")
                         minimax_tts_model_id = text_setting("MiniMax TTS model", "minimax_tts_model_id")
                         minimax_tts_voice_id = text_setting("MiniMax TTS voice ID", "minimax_tts_voice_id")
                     with cols[1]:
                         elevenlabs_api_key = text_setting("ElevenLabs API key", "elevenlabs_api_key", secret=True)
+                        _render_credential_status(elevenlabs_api_key)
                         elevenlabs_model_id = text_setting("ElevenLabs model", "elevenlabs_model_id")
                         chatterbox_base_url = text_setting("Chatterbox Base URL", "chatterbox_base_url")
                         chatterbox_api_key = text_setting("Chatterbox API key", "chatterbox_api_key", secret=True)
+                        _render_credential_status(chatterbox_api_key, local=True, required=False)
                         chatterbox_model_id = text_setting("Chatterbox model", "chatterbox_model_id")
                         sonilo_api_key = text_setting("Sonilo API key", "sonilo_api_key", secret=True)
+                        _render_credential_status(sonilo_api_key)
                         sonilo_base_url = text_setting("Sonilo Base URL", "sonilo_base_url")
                         st.markdown("**Suno — agente musical opcional**")
                         suno_api_key = text_setting("Suno API key", "suno_api_key", secret=True)
+                        _render_credential_status(suno_api_key)
                         suno_api_base_url = text_setting("Suno API Base URL", "suno_api_base_url", help_text="Use o endpoint compatível fornecido pelo seu acesso Suno; não é inventado pelo Thunderbolt.")
                         suno_api_endpoint = text_setting("Suno API endpoint", "suno_api_endpoint", help_text="Ex.: /api/generate")
 
                 with st.expander("TikTok for Developers — Client ID e Client Secret", expanded=False):
                     st.caption("Apenas as credenciais da aplicação ficam nesta UI. Redirect URI, scopes, autorização e tokens são geridos no TikTok for Developers Playground.")
                     tiktok_client_key = text_setting("TikTok Client ID", "tiktok_client_key", secret=True)
+                    _render_credential_status(tiktok_client_key)
                     tiktok_client_secret = text_setting("TikTok Client Secret", "tiktok_client_secret", secret=True)
 
                 with st.expander("Publicação através do Upload-Post", expanded=False):
                     upload_post_enabled = st.checkbox("Activar Upload-Post", bool(settings.get("upload_post_enabled", False)))
                     upload_post_api_key = text_setting("Upload-Post API key", "upload_post_api_key", secret=True)
+                    _render_credential_status(upload_post_api_key)
                     upload_post_username = text_setting("Upload-Post username", "upload_post_username")
                     upload_post_platforms = text_setting("Plataformas Upload-Post", "upload_post_platforms")
                     upload_post_auto_upload = st.checkbox("Publicar automaticamente após gerar", bool(settings.get("upload_post_auto_upload", False)))
@@ -3850,6 +4012,7 @@ def render_settings():
                     postiz_cols = st.columns(2)
                     with postiz_cols[0]:
                         postiz_api_key = text_setting("Postiz API key", "postiz_api_key", secret=True, help_text="API key criada nas definições do Postiz. A API HTTP usa o valor bruto no cabeçalho Authorization.")
+                        _render_credential_status(postiz_api_key)
                         postiz_base_url = text_setting("Postiz Public API Base URL", "postiz_base_url", help_text="Cloud: https://api.postiz.com/public/v1 · Self-hosted: https://seu-servidor/api/public/v1")
                         postiz_integration_id = text_setting("Postiz integração padrão", "postiz_integration_id", help_text="ID do canal/integração devolvido por GET /integrations.")
                     with postiz_cols[1]:
@@ -3857,23 +4020,12 @@ def render_settings():
                         postiz_auto_publish = st.checkbox("Permitir publicação imediata no Postiz", bool(settings.get("postiz_auto_publish", False)))
                     st.caption("No Upload, a aba Postiz permite carregar as integrações e enviar vídeos manualmente. No fluxo recomendado, Postiz só é tentado depois da API Oficial e do Upload directo.")
 
-                if refresh_openai_models:
-                    try:
-                        discovered_models = fetch_openai_compatible_models(openai_api_key, openai_base_url)
-                        st.session_state["openai_model_catalog"] = {"key": catalog_key, "models": discovered_models, "error": ""}
-                        st.success(f"{len(discovered_models)} modelo(s) carregado(s) do endpoint OpenAI-compatible.")
-                        st.rerun()
-                    except ModelDiscoveryError as exc:
-                        st.session_state["openai_model_catalog"] = {"key": catalog_key, "models": [], "error": str(exc)}
-                        st.rerun()
-
                 save_all_settings = st.form_submit_button("Guardar configurações do Thunderbolt", type="primary")
                 if save_all_settings:
                     settings.update({
                         "port": port, "moneyprinter_path": moneyprinter_path,
                         "kaggle_username": kaggle_username.strip(), "kaggle_api_key": kaggle_api_key.strip(), "kaggle_kernel_slug": kaggle_kernel_slug.strip() or "thunderbolt-niche-finder",
                         "apify_api_token": apify_api_token.strip(), "apify_actor_id": apify_actor_id.strip() or DEFAULT_ACTOR_ID, "apify_poll_interval_seconds": int(apify_poll_interval), "apify_run_timeout_seconds": int(apify_run_timeout),
-                        "llm_provider": llm_provider, "openai_api_key": openai_api_key, "openai_base_url": openai_base_url, "openai_model_name": openai_model_name,
                         "gemini_image_api_key": gemini_image_api_key, "gemini_image_model": gemini_image_model, "gemini_image_aspect_ratio": gemini_image_aspect_ratio, "gemini_image_size": gemini_image_size,
                         "azure_speech_key": azure_speech_key, "azure_speech_region": azure_speech_region,
                         "siliconflow_tts_api_key": siliconflow_tts_api_key, "minimax_tts_api_key": minimax_tts_api_key,
@@ -3898,6 +4050,7 @@ def render_settings():
                             st.success("Configurações guardadas localmente. Indique uma pasta válida do motor de vídeo para sincronizar config.toml.")
                     except Exception as exc:
                         st.warning(f"Configurações locais guardadas, mas não foi possível sincronizar config.toml: {exc}")
+        render_llm_provider_cards(settings)
         with material_sources_tab:
             render_material_source_api_keys(settings)
 

package/hermes_ui/creative_generation.py

@@ -8,6 +8,8 @@ from typing import Any
 
 import requests
 
+from .llm_providers import active_llm_card, provider_definition
+
 
 ROOT = Path(__file__).resolve().parents[1]
 REFERENCES_DIR = ROOT / "seed" / "references"
@@ -28,14 +30,12 @@ class CreativeGenerationError(RuntimeError):
 
 
 def _provider_config(settings: dict[str, Any]) -> tuple[str, str, str, str]:
-    provider = str(settings.get("llm_provider") or "openai").strip().lower()
-    key = str(settings.get(f"{provider}_api_key") or "").strip()
-    base_url = str(settings.get(f"{provider}_base_url") or "").strip()
-    model = str(settings.get(f"{provider}_model_name") or "").strip()
-    if provider == "openai":
-        base_url = base_url or "https://api.openai.com/v1"
-    elif provider == "ollama":
-        base_url = base_url or "http://127.0.0.1:11434/v1"
+    card = active_llm_card(settings)
+    provider = str(card.get("provider") or "openai").strip().lower()
+    definition = provider_definition(provider)
+    key = str(card.get("api_key") or "").strip()
+    base_url = str(card.get("base_url") or "").strip() or definition.default_base_url
+    model = str(card.get("model") or "").strip()
     if not base_url:
         raise CreativeGenerationError(
             f"O provider LLM '{provider}' não tem Base URL configurada em Configuração API > API Keys > Serviços e modelos."
@@ -44,7 +44,7 @@ def _provider_config(settings: dict[str, Any]) -> tuple[str, str, str, str]:
         raise CreativeGenerationError(
             f"O provider LLM '{provider}' não tem modelo configurado em Configuração API > API Keys > Serviços e modelos."
         )
-    if provider not in {"ollama", "litellm"} and not key:
+    if definition.requires_api_key and not key:
         raise CreativeGenerationError(
             f"Configure a API key do provider LLM '{provider}' em Configuração API > API Keys > Serviços e modelos."
         )

package/hermes_ui/languages.py

@@ -141,6 +141,73 @@ UI_TRANSLATIONS: dict[str, dict[str, str]] = {
 }
 
 
+# Labels for the independent LLM provider cards.
+_LLM_TRANSLATIONS: dict[str, dict[str, str]] = {
+    "pt": {
+        "LLM — providers e modelos": "LLM — providers e modelos", "Adicionar provider LLM": "Adicionar provider LLM", "Provider LLM": "Provider LLM", "Configurar Novo Provedor LLM": "Configurar Novo Provedor LLM", "API key": "API key", "Modelo": "Modelo", "Base URL": "Base URL", "Modelo manual": "Modelo manual", "Escrever modelo manualmente": "Escrever modelo manualmente", "Provider activo": "Provider activo", "LLM Telegram": "LLM Telegram", "Testar chamada API": "Testar chamada API", "Consultar modelos": "Consultar modelos", "Salvar": "Salvar", "Remover cartão": "Remover cartão", "Último teste:": "Último teste:", "Teste API:": "Teste API:", "Missing key": "Missing key", "Missing configuration": "Missing configuration", "Configured": "Configurado", "Local / sem API key": "Local / sem API key", "Este provider não exige API key.": "Este provider não exige API key.", "OpenAI / NVIDIA NIM": "OpenAI / NVIDIA NIM", "OpenRouter": "OpenRouter", "Moonshot / Kimi": "Moonshot / Kimi", "Shengsuan Cloud": "Shengsuan Cloud", "Google Gemini": "Google Gemini", "DeepSeek": "DeepSeek", "Alibaba Qwen / DashScope": "Alibaba Qwen / DashScope", "Mistral": "Mistral", "Groq": "Groq", "xAI Grok": "xAI Grok", "MiniMax": "MiniMax", "Xiaomi MiMo": "Xiaomi MiMo", "Cloudflare Workers AI": "Cloudflare Workers AI", "ModelScope": "ModelScope", "AIHubMix": "AIHubMix", "AIML API": "AIML API", "EvoLink": "EvoLink", "Ollama": "Ollama", "LM Studio": "LM Studio", "llama.cpp": "llama.cpp", "OneAPI": "OneAPI", "LiteLLM Proxy": "Proxy LiteLLM", "Pollinations AI": "Pollinations AI", "Together AI": "Together AI", "Fireworks AI": "Fireworks AI", "SiliconFlow": "SiliconFlow", "Cohere": "Cohere", "Hugging Face": "Hugging Face", "GitHub Models": "GitHub Models", "Cerebras": "Cerebras", "SambaNova": "SambaNova", "Perplexity": "Perplexity", "OpenAI-compatible personalizado": "OpenAI-compatible personalizado",
+    },
+    "en": {
+        "LLM — providers e modelos": "LLM — providers and models", "Adicionar provider LLM": "Add LLM provider", "Provider LLM": "LLM provider", "Configurar Novo Provedor LLM": "Configure New LLM Provider", "API key": "API key", "Modelo": "Model", "Base URL": "Base URL", "Modelo manual": "Manual model", "Escrever modelo manualmente": "Write model manually", "Provider activo": "Provider enabled", "LLM Telegram": "LLM Telegram", "Testar chamada API": "Test API call", "Consultar modelos": "Fetch models", "Salvar": "Save", "Remover cartão": "Remove card", "Último teste:": "Last test:", "Teste API:": "API test:", "Missing key": "Missing key", "Missing configuration": "Missing configuration", "Configured": "Configured", "Local / sem API key": "Local / no API key", "Este provider não exige API key.": "This provider does not require an API key.", "OpenAI / NVIDIA NIM": "OpenAI / NVIDIA NIM", "OpenRouter": "OpenRouter", "Moonshot / Kimi": "Moonshot / Kimi", "Shengsuan Cloud": "Shengsuan Cloud", "Google Gemini": "Google Gemini", "DeepSeek": "DeepSeek", "Alibaba Qwen / DashScope": "Alibaba Qwen / DashScope", "Mistral": "Mistral", "Groq": "Groq", "xAI Grok": "xAI Grok", "MiniMax": "MiniMax", "Xiaomi MiMo": "Xiaomi MiMo", "Cloudflare Workers AI": "Cloudflare Workers AI", "ModelScope": "ModelScope", "AIHubMix": "AIHubMix", "AIML API": "AIML API", "EvoLink": "EvoLink", "Ollama": "Ollama", "LM Studio": "LM Studio", "llama.cpp": "llama.cpp", "OneAPI": "OneAPI", "LiteLLM Proxy": "LiteLLM Proxy", "Pollinations AI": "Pollinations AI", "Together AI": "Together AI", "Fireworks AI": "Fireworks AI", "SiliconFlow": "SiliconFlow", "Cohere": "Cohere", "Hugging Face": "Hugging Face", "GitHub Models": "GitHub Models", "Cerebras": "Cerebras", "SambaNova": "SambaNova", "Perplexity": "Perplexity", "OpenAI-compatible personalizado": "Custom OpenAI-compatible",
+    },
+    "zh": {
+        "LLM — providers e modelos": "LLM — 提供商和模型", "Adicionar provider LLM": "添加 LLM 提供商", "Provider LLM": "LLM 提供商", "Configurar Novo Provedor LLM": "配置新的 LLM 提供商", "API key": "API 密钥", "Modelo": "模型", "Base URL": "基础 URL", "Modelo manual": "手动模型", "Escrever modelo manualmente": "手动输入模型", "Provider activo": "启用提供商", "LLM Telegram": "Telegram LLM", "Testar chamada API": "测试 API 调用", "Consultar modelos": "获取模型", "Salvar": "保存", "Remover cartão": "删除卡片", "Último teste:": "上次测试：", "Teste API:": "API 测试：", "Missing key": "缺少密钥", "Missing configuration": "缺少配置", "Configured": "已配置", "Local / sem API key": "本地 / 无需 API 密钥", "Este provider não exige API key.": "此提供商不需要 API 密钥。", "OpenAI / NVIDIA NIM": "OpenAI / NVIDIA NIM", "OpenRouter": "OpenRouter", "Moonshot / Kimi": "Moonshot / Kimi", "Shengsuan Cloud": "Shengsuan Cloud", "Google Gemini": "Google Gemini", "DeepSeek": "DeepSeek", "Alibaba Qwen / DashScope": "阿里 Qwen / DashScope", "Mistral": "Mistral", "Groq": "Groq", "xAI Grok": "xAI Grok", "MiniMax": "MiniMax", "Xiaomi MiMo": "小米 MiMo", "Cloudflare Workers AI": "Cloudflare Workers AI", "ModelScope": "ModelScope", "AIHubMix": "AIHubMix", "AIML API": "AIML API", "EvoLink": "EvoLink", "Ollama": "Ollama", "LM Studio": "LM Studio", "llama.cpp": "llama.cpp", "OneAPI": "OneAPI", "LiteLLM Proxy": "LiteLLM 代理", "Pollinations AI": "Pollinations AI", "Together AI": "Together AI", "Fireworks AI": "Fireworks AI", "SiliconFlow": "SiliconFlow", "Cohere": "Cohere", "Hugging Face": "Hugging Face", "GitHub Models": "GitHub Models", "Cerebras": "Cerebras", "SambaNova": "SambaNova", "Perplexity": "Perplexity", "OpenAI-compatible personalizado": "自定义 OpenAI 兼容",
+    },
+    "de": {
+        "LLM — providers e modelos": "LLM — Anbieter und Modelle", "Adicionar provider LLM": "LLM-Anbieter hinzufügen", "Provider LLM": "LLM-Anbieter", "Configurar Novo Provedor LLM": "Neuen LLM-Anbieter konfigurieren", "API key": "API-Schlüssel", "Modelo": "Modell", "Base URL": "Basis-URL", "Modelo manual": "Manuelles Modell", "Escrever modelo manualmente": "Modell manuell eingeben", "Provider activo": "Anbieter aktiv", "LLM Telegram": "LLM Telegram", "Testar chamada API": "API-Aufruf testen", "Consultar modelos": "Modelle abrufen", "Salvar": "Speichern", "Remover cartão": "Karte entfernen", "Último teste:": "Letzter Test:", "Teste API:": "API-Test:", "Missing key": "Schlüssel fehlt", "Missing configuration": "Konfiguration fehlt", "Configured": "Konfiguriert", "Local / sem API key": "Lokal / kein API-Schlüssel", "Este provider não exige API key.": "Dieser Anbieter benötigt keinen API-Schlüssel.", "OpenAI / NVIDIA NIM": "OpenAI / NVIDIA NIM", "OpenRouter": "OpenRouter", "Moonshot / Kimi": "Moonshot / Kimi", "Shengsuan Cloud": "Shengsuan Cloud", "Google Gemini": "Google Gemini", "DeepSeek": "DeepSeek", "Alibaba Qwen / DashScope": "Alibaba Qwen / DashScope", "Mistral": "Mistral", "Groq": "Groq", "xAI Grok": "xAI Grok", "MiniMax": "MiniMax", "Xiaomi MiMo": "Xiaomi MiMo", "Cloudflare Workers AI": "Cloudflare Workers AI", "ModelScope": "ModelScope", "AIHubMix": "AIHubMix", "AIML API": "AIML API", "EvoLink": "EvoLink", "Ollama": "Ollama", "LM Studio": "LM Studio", "llama.cpp": "llama.cpp", "OneAPI": "OneAPI", "LiteLLM Proxy": "LiteLLM-Proxy", "Pollinations AI": "Pollinations AI", "Together AI": "Together AI", "Fireworks AI": "Fireworks AI", "SiliconFlow": "SiliconFlow", "Cohere": "Cohere", "Hugging Face": "Hugging Face", "GitHub Models": "GitHub-Modelle", "Cerebras": "Cerebras", "SambaNova": "SambaNova", "Perplexity": "Perplexity", "OpenAI-compatible personalizado": "Benutzerdefiniertes OpenAI-kompatibles",
+    },
+    "vi": {
+        "LLM — providers e modelos": "LLM — nhà cung cấp và mô hình", "Adicionar provider LLM": "Thêm nhà cung cấp LLM", "Provider LLM": "Nhà cung cấp LLM", "Configurar Novo Provedor LLM": "Định cấu hình nhà cung cấp LLM mới", "API key": "Khóa API", "Modelo": "Mô hình", "Base URL": "URL cơ sở", "Modelo manual": "Mô hình thủ công", "Escrever modelo manualmente": "Nhập mô hình thủ công", "Provider activo": "Bật nhà cung cấp", "LLM Telegram": "LLM Telegram", "Testar chamada API": "Kiểm tra lệnh gọi API", "Consultar modelos": "Lấy danh sách mô hình", "Salvar": "Lưu", "Remover cartão": "Xóa thẻ", "Último teste:": "Lần kiểm tra cuối:", "Teste API:": "Kiểm tra API:", "Missing key": "Thiếu khóa", "Missing configuration": "Thiếu cấu hình", "Configured": "Đã cấu hình", "Local / sem API key": "Cục bộ / không cần khóa API", "Este provider não exige API key.": "Nhà cung cấp này không yêu cầu khóa API.", "OpenAI / NVIDIA NIM": "OpenAI / NVIDIA NIM", "OpenRouter": "OpenRouter", "Moonshot / Kimi": "Moonshot / Kimi", "Shengsuan Cloud": "Shengsuan Cloud", "Google Gemini": "Google Gemini", "DeepSeek": "DeepSeek", "Alibaba Qwen / DashScope": "Alibaba Qwen / DashScope", "Mistral": "Mistral", "Groq": "Groq", "xAI Grok": "xAI Grok", "MiniMax": "MiniMax", "Xiaomi MiMo": "Xiaomi MiMo", "Cloudflare Workers AI": "Cloudflare Workers AI", "ModelScope": "ModelScope", "AIHubMix": "AIHubMix", "AIML API": "AIML API", "EvoLink": "EvoLink", "Ollama": "Ollama", "LM Studio": "LM Studio", "llama.cpp": "llama.cpp", "OneAPI": "OneAPI", "LiteLLM Proxy": "Proxy LiteLLM", "Pollinations AI": "Pollinations AI", "Together AI": "Together AI", "Fireworks AI": "Fireworks AI", "SiliconFlow": "SiliconFlow", "Cohere": "Cohere", "Hugging Face": "Hugging Face", "GitHub Models": "GitHub Models", "Cerebras": "Cerebras", "SambaNova": "SambaNova", "Perplexity": "Perplexity", "OpenAI-compatible personalizado": "OpenAI-compatible tùy chỉnh",
+    },
+    "tr": {
+        "LLM — providers e modelos": "LLM — sağlayıcılar ve modeller", "Adicionar provider LLM": "LLM sağlayıcısı ekle", "Provider LLM": "LLM sağlayıcısı", "Configurar Novo Provedor LLM": "Yeni LLM sağlayıcısını yapılandır", "API key": "API anahtarı", "Modelo": "Model", "Base URL": "Temel URL", "Modelo manual": "Manuel model", "Escrever modelo manualmente": "Modeli manuel yaz", "Provider activo": "Sağlayıcı etkin", "LLM Telegram": "LLM Telegram", "Testar chamada API": "API çağrısını test et", "Consultar modelos": "Modelleri getir", "Salvar": "Kaydet", "Remover cartão": "Kartı kaldır", "Último teste:": "Son test:", "Teste API:": "API testi:", "Missing key": "Anahtar eksik", "Missing configuration": "Yapılandırma eksik", "Configured": "Yapılandırıldı", "Local / sem API key": "Yerel / API anahtarı gerekmez", "Este provider não exige API key.": "Bu sağlayıcı API anahtarı gerektirmez.", "OpenAI / NVIDIA NIM": "OpenAI / NVIDIA NIM", "OpenRouter": "OpenRouter", "Moonshot / Kimi": "Moonshot / Kimi", "Shengsuan Cloud": "Shengsuan Cloud", "Google Gemini": "Google Gemini", "DeepSeek": "DeepSeek", "Alibaba Qwen / DashScope": "Alibaba Qwen / DashScope", "Mistral": "Mistral", "Groq": "Groq", "xAI Grok": "xAI Grok", "MiniMax": "MiniMax", "Xiaomi MiMo": "Xiaomi MiMo", "Cloudflare Workers AI": "Cloudflare Workers AI", "ModelScope": "ModelScope", "AIHubMix": "AIHubMix", "AIML API": "AIML API", "EvoLink": "EvoLink", "Ollama": "Ollama", "LM Studio": "LM Studio", "llama.cpp": "llama.cpp", "OneAPI": "OneAPI", "LiteLLM Proxy": "LiteLLM Proxy", "Pollinations AI": "Pollinations AI", "Together AI": "Together AI", "Fireworks AI": "Fireworks AI", "SiliconFlow": "SiliconFlow", "Cohere": "Cohere", "Hugging Face": "Hugging Face", "GitHub Models": "GitHub Models", "Cerebras": "Cerebras", "SambaNova": "SambaNova", "Perplexity": "Perplexity", "OpenAI-compatible personalizado": "Özel OpenAI uyumlu",
+    },
+    "ru": {
+        "LLM — providers e modelos": "LLM — провайдеры и модели", "Adicionar provider LLM": "Добавить провайдер LLM", "Provider LLM": "Провайдер LLM", "Configurar Novo Provedor LLM": "Настроить нового провайдера LLM", "API key": "API-ключ", "Modelo": "Модель", "Base URL": "Базовый URL", "Modelo manual": "Модель вручную", "Escrever modelo manualmente": "Ввести модель вручную", "Provider activo": "Провайдер активен", "LLM Telegram": "LLM Telegram", "Testar chamada API": "Проверить вызов API", "Consultar modelos": "Получить модели", "Salvar": "Сохранить", "Remover cartão": "Удалить карточку", "Último teste:": "Последняя проверка:", "Teste API:": "Проверка API:", "Missing key": "Нет ключа", "Missing configuration": "Нет конфигурации", "Configured": "Настроено", "Local / sem API key": "Локальный / ключ API не нужен", "Este provider não exige API key.": "Этому провайдеру не нужен API-ключ.", "OpenAI / NVIDIA NIM": "OpenAI / NVIDIA NIM", "OpenRouter": "OpenRouter", "Moonshot / Kimi": "Moonshot / Kimi", "Shengsuan Cloud": "Shengsuan Cloud", "Google Gemini": "Google Gemini", "DeepSeek": "DeepSeek", "Alibaba Qwen / DashScope": "Alibaba Qwen / DashScope", "Mistral": "Mistral", "Groq": "Groq", "xAI Grok": "xAI Grok", "MiniMax": "MiniMax", "Xiaomi MiMo": "Xiaomi MiMo", "Cloudflare Workers AI": "Cloudflare Workers AI", "ModelScope": "ModelScope", "AIHubMix": "AIHubMix", "AIML API": "AIML API", "EvoLink": "EvoLink", "Ollama": "Ollama", "LM Studio": "LM Studio", "llama.cpp": "llama.cpp", "OneAPI": "OneAPI", "LiteLLM Proxy": "Прокси LiteLLM", "Pollinations AI": "Pollinations AI", "Together AI": "Together AI", "Fireworks AI": "Fireworks AI", "SiliconFlow": "SiliconFlow", "Cohere": "Cohere", "Hugging Face": "Hugging Face", "GitHub Models": "Модели GitHub", "Cerebras": "Cerebras", "SambaNova": "SambaNova", "Perplexity": "Perplexity", "OpenAI-compatible personalizado": "Пользовательский OpenAI-совместимый",
+    },
+    "es": {
+        "LLM — providers e modelos": "LLM — proveedores y modelos", "Adicionar provider LLM": "Añadir proveedor LLM", "Provider LLM": "Proveedor LLM", "Configurar Novo Provedor LLM": "Configurar nuevo proveedor LLM", "API key": "Clave API", "Modelo": "Modelo", "Base URL": "URL base", "Modelo manual": "Modelo manual", "Escrever modelo manualmente": "Escribir modelo manualmente", "Provider activo": "Proveedor activo", "LLM Telegram": "LLM Telegram", "Testar chamada API": "Probar llamada API", "Consultar modelos": "Consultar modelos", "Salvar": "Guardar", "Remover cartão": "Eliminar tarjeta", "Último teste:": "Última prueba:", "Teste API:": "Prueba API:", "Missing key": "Falta la clave", "Missing configuration": "Falta configuración", "Configured": "Configurado", "Local / sem API key": "Local / sin clave API", "Este provider não exige API key.": "Este proveedor no requiere clave API.", "OpenAI / NVIDIA NIM": "OpenAI / NVIDIA NIM", "OpenRouter": "OpenRouter", "Moonshot / Kimi": "Moonshot / Kimi", "Shengsuan Cloud": "Shengsuan Cloud", "Google Gemini": "Google Gemini", "DeepSeek": "DeepSeek", "Alibaba Qwen / DashScope": "Alibaba Qwen / DashScope", "Mistral": "Mistral", "Groq": "Groq", "xAI Grok": "xAI Grok", "MiniMax": "MiniMax", "Xiaomi MiMo": "Xiaomi MiMo", "Cloudflare Workers AI": "Cloudflare Workers AI", "ModelScope": "ModelScope", "AIHubMix": "AIHubMix", "AIML API": "AIML API", "EvoLink": "EvoLink", "Ollama": "Ollama", "LM Studio": "LM Studio", "llama.cpp": "llama.cpp", "OneAPI": "OneAPI", "LiteLLM Proxy": "Proxy LiteLLM", "Pollinations AI": "Pollinations AI", "Together AI": "Together AI", "Fireworks AI": "Fireworks AI", "SiliconFlow": "SiliconFlow", "Cohere": "Cohere", "Hugging Face": "Hugging Face", "GitHub Models": "Modelos de GitHub", "Cerebras": "Cerebras", "SambaNova": "SambaNova", "Perplexity": "Perplexity", "OpenAI-compatible personalizado": "OpenAI compatible personalizado",
+    },
+    "id": {
+        "LLM — providers e modelos": "LLM — penyedia dan model", "Adicionar provider LLM": "Tambah penyedia LLM", "Provider LLM": "Penyedia LLM", "Configurar Novo Provedor LLM": "Konfigurasikan Penyedia LLM Baru", "API key": "Kunci API", "Modelo": "Model", "Base URL": "URL dasar", "Modelo manual": "Model manual", "Escrever modelo manualmente": "Tulis model secara manual", "Provider activo": "Penyedia aktif", "LLM Telegram": "LLM Telegram", "Testar chamada API": "Uji panggilan API", "Consultar modelos": "Ambil model", "Salvar": "Simpan", "Remover cartão": "Hapus kartu", "Último teste:": "Tes terakhir:", "Teste API:": "Tes API:", "Missing key": "Kunci tidak ada", "Missing configuration": "Konfigurasi tidak ada", "Configured": "Dikonfigurasi", "Local / sem API key": "Lokal / tanpa kunci API", "Este provider não exige API key.": "Penyedia ini tidak memerlukan kunci API.", "OpenAI / NVIDIA NIM": "OpenAI / NVIDIA NIM", "OpenRouter": "OpenRouter", "Moonshot / Kimi": "Moonshot / Kimi", "Shengsuan Cloud": "Shengsuan Cloud", "Google Gemini": "Google Gemini", "DeepSeek": "DeepSeek", "Alibaba Qwen / DashScope": "Alibaba Qwen / DashScope", "Mistral": "Mistral", "Groq": "Groq", "xAI Grok": "xAI Grok", "MiniMax": "MiniMax", "Xiaomi MiMo": "Xiaomi MiMo", "Cloudflare Workers AI": "Cloudflare Workers AI", "ModelScope": "ModelScope", "AIHubMix": "AIHubMix", "AIML API": "AIML API", "EvoLink": "EvoLink", "Ollama": "Ollama", "LM Studio": "LM Studio", "llama.cpp": "llama.cpp", "OneAPI": "OneAPI", "LiteLLM Proxy": "Proxy LiteLLM", "Pollinations AI": "Pollinations AI", "Together AI": "Together AI", "Fireworks AI": "Fireworks AI", "SiliconFlow": "SiliconFlow", "Cohere": "Cohere", "Hugging Face": "Hugging Face", "GitHub Models": "Model GitHub", "Cerebras": "Cerebras", "SambaNova": "SambaNova", "Perplexity": "Perplexity", "OpenAI-compatible personalizado": "OpenAI-compatible khusus",
+    },
+    "it": {
+        "LLM — providers e modelos": "LLM — provider e modelli", "Adicionar provider LLM": "Aggiungi provider LLM", "Provider LLM": "Provider LLM", "Configurar Novo Provedor LLM": "Configura nuovo provider LLM", "API key": "Chiave API", "Modelo": "Modello", "Base URL": "URL base", "Modelo manual": "Modello manuale", "Escrever modelo manualmente": "Inserisci modello manualmente", "Provider activo": "Provider attivo", "LLM Telegram": "LLM Telegram", "Testar chamada API": "Testa chiamata API", "Consultar modelos": "Recupera modelli", "Salvar": "Salva", "Remover cartão": "Rimuovi scheda", "Último teste:": "Ultimo test:", "Teste API:": "Test API:", "Missing key": "Chiave mancante", "Missing configuration": "Configurazione mancante", "Configured": "Configurato", "Local / sem API key": "Locale / nessuna chiave API", "Este provider não exige API key.": "Questo provider non richiede una chiave API.", "OpenAI / NVIDIA NIM": "OpenAI / NVIDIA NIM", "OpenRouter": "OpenRouter", "Moonshot / Kimi": "Moonshot / Kimi", "Shengsuan Cloud": "Shengsuan Cloud", "Google Gemini": "Google Gemini", "DeepSeek": "DeepSeek", "Alibaba Qwen / DashScope": "Alibaba Qwen / DashScope", "Mistral": "Mistral", "Groq": "Groq", "xAI Grok": "xAI Grok", "MiniMax": "MiniMax", "Xiaomi MiMo": "Xiaomi MiMo", "Cloudflare Workers AI": "Cloudflare Workers AI", "ModelScope": "ModelScope", "AIHubMix": "AIHubMix", "AIML API": "AIML API", "EvoLink": "EvoLink", "Ollama": "Ollama", "LM Studio": "LM Studio", "llama.cpp": "llama.cpp", "OneAPI": "OneAPI", "LiteLLM Proxy": "Proxy LiteLLM", "Pollinations AI": "Pollinations AI", "Together AI": "Together AI", "Fireworks AI": "Fireworks AI", "SiliconFlow": "SiliconFlow", "Cohere": "Cohere", "Hugging Face": "Hugging Face", "GitHub Models": "Modelli GitHub", "Cerebras": "Cerebras", "SambaNova": "SambaNova", "Perplexity": "Perplexity", "OpenAI-compatible personalizado": "OpenAI compatibile personalizzato",
+    },
+}
+for _language_code, _llm_values in _LLM_TRANSLATIONS.items():
+    UI_TRANSLATIONS[_language_code].update(_llm_values)
+
+_LLM_EXTRA_PROVIDER_TRANSLATIONS = {
+    "pt": {"Azure OpenAI": "Azure OpenAI", "VolcEngine Ark": "VolcEngine Ark"},
+    "en": {"Azure OpenAI": "Azure OpenAI", "VolcEngine Ark": "VolcEngine Ark"},
+    "zh": {"Azure OpenAI": "Azure OpenAI", "VolcEngine Ark": "VolcEngine Ark"},
+    "de": {"Azure OpenAI": "Azure OpenAI", "VolcEngine Ark": "VolcEngine Ark"},
+    "vi": {"Azure OpenAI": "Azure OpenAI", "VolcEngine Ark": "VolcEngine Ark"},
+    "tr": {"Azure OpenAI": "Azure OpenAI", "VolcEngine Ark": "VolcEngine Ark"},
+    "ru": {"Azure OpenAI": "Azure OpenAI", "VolcEngine Ark": "VolcEngine Ark"},
+    "es": {"Azure OpenAI": "Azure OpenAI", "VolcEngine Ark": "VolcEngine Ark"},
+    "id": {"Azure OpenAI": "Azure OpenAI", "VolcEngine Ark": "VolcEngine Ark"},
+    "it": {"Azure OpenAI": "Azure OpenAI", "VolcEngine Ark": "VolcEngine Ark"},
+}
+for _language_code, _llm_extra_values in _LLM_EXTRA_PROVIDER_TRANSLATIONS.items():
+    UI_TRANSLATIONS[_language_code].update(_llm_extra_values)
+
+_LLM_CONTROL_TRANSLATIONS = {
+    "pt": {"LLM principal": "LLM principal", "Usar este cartão como provider principal para geração de temas, roteiros, títulos e keywords.": "Usar este cartão como provider principal para geração de temas, roteiros, títulos e keywords.", "Usar este cartão exclusivamente para o roteamento de notificações Telegram. Apenas um cartão pode ficar seleccionado.": "Usar este cartão exclusivamente para o roteamento de notificações Telegram. Apenas um cartão pode ficar seleccionado.", "Account Id": "Account ID", "Gateway Id": "Gateway ID", "Api Version": "Versão da API", "Endpoint gerido pelo provider: ": "Endpoint gerido pelo provider: ", "Endpoint OpenAI-compatible deste provider; só aparece quando é configurável.": "Endpoint OpenAI-compatible deste provider; só aparece quando é configurável.", "ID do modelo usado pelo endpoint Chat Completions.": "ID do modelo usado pelo endpoint Chat Completions.", "Configure cada provider num cartão independente. Pode repetir o mesmo provider para manter várias API keys; o cartão activo é usado pela geração de conteúdo.": "Configure cada provider num cartão independente. Pode repetir o mesmo provider para manter várias API keys; o cartão activo é usado pela geração de conteúdo."},
+    "en": {"LLM principal": "Primary LLM", "Usar este cartão como provider principal para geração de temas, roteiros, títulos e keywords.": "Use this card as the primary provider for topics, scripts, titles and keywords.", "Usar este cartão exclusivamente para o roteamento de notificações Telegram. Apenas um cartão pode ficar seleccionado.": "Use this card exclusively for Telegram notification routing. Only one card can be selected.", "Account Id": "Account ID", "Gateway Id": "Gateway ID", "Api Version": "API version", "Endpoint gerido pelo provider: ": "Provider-managed endpoint: ", "Endpoint OpenAI-compatible deste provider; só aparece quando é configurável.": "This field appears only for providers with a configurable OpenAI-compatible endpoint.", "ID do modelo usado pelo endpoint Chat Completions.": "Model ID used by the Chat Completions endpoint.", "Configure cada provider num cartão independente. Pode repetir o mesmo provider para manter várias API keys; o cartão activo é usado pela geração de conteúdo.": "Configure each provider in an independent card. You can repeat a provider for multiple API keys; the active card is used for content generation."},
+    "zh": {"LLM principal": "主要 LLM", "Usar este cartão como provider principal para geração de temas, roteiros, títulos e keywords.": "将此卡片用作主题、脚本、标题和关键词的主要提供商。", "Usar este cartão exclusivamente para o roteamento de notificações Telegram. Apenas um cartão pode ficar seleccionado.": "此卡片仅用于 Telegram 通知路由。只能选择一个卡片。", "Account Id": "账户 ID", "Gateway Id": "网关 ID", "Api Version": "API 版本", "Endpoint gerido pelo provider: ": "提供商管理的端点：", "Endpoint OpenAI-compatible deste provider; só aparece quando é configurável.": "仅在提供商支持自定义 OpenAI 兼容端点时显示。", "ID do modelo usado pelo endpoint Chat Completions.": "Chat Completions 端点使用的模型 ID。", "Configure cada provider num cartão independente. Pode repetir o mesmo provider para manter várias API keys; o cartão activo é usado pela geração de conteúdo.": "在独立卡片中配置每个提供商。可为同一提供商添加多个 API 密钥；内容生成使用活动卡片。"},
+    "de": {"LLM principal": "Primärer LLM", "Usar este cartão como provider principal para geração de temas, roteiros, títulos e keywords.": "Diese Karte als primären Anbieter für Themen, Skripte, Titel und Keywords verwenden.", "Usar este cartão exclusivamente para o roteamento de notificações Telegram. Apenas um cartão pode ficar seleccionado.": "Diese Karte ausschließlich für die Telegram-Benachrichtigungsweiterleitung verwenden. Nur eine Karte kann ausgewählt werden.", "Account Id": "Konto-ID", "Gateway Id": "Gateway-ID", "Api Version": "API-Version", "Endpoint gerido pelo provider: ": "Vom Anbieter verwalteter Endpunkt: ", "Endpoint OpenAI-compatible deste provider; só aparece quando é configurável.": "Dieses Feld erscheint nur bei Anbietern mit konfigurierbarem OpenAI-kompatiblem Endpunkt.", "ID do modelo usado pelo endpoint Chat Completions.": "Vom Chat-Completions-Endpunkt verwendete Modell-ID.", "Configure cada provider num cartão independente. Pode repetir o mesmo provider para manter várias API keys; o cartão activo é usado pela geração de conteúdo.": "Jeden Anbieter in einer eigenen Karte konfigurieren. Anbieter können für mehrere API-Schlüssel wiederholt werden; die aktive Karte wird für die Inhaltserstellung verwendet."},
+    "vi": {"LLM principal": "LLM chính", "Usar este cartão como provider principal para geração de temas, roteiros, títulos e keywords.": "Dùng thẻ này làm nhà cung cấp chính cho chủ đề, kịch bản, tiêu đề và từ khóa.", "Usar este cartão exclusivamente para o roteamento de notificações Telegram. Apenas um cartão pode ficar seleccionado.": "Chỉ dùng thẻ này để định tuyến thông báo Telegram. Chỉ được chọn một thẻ.", "Account Id": "ID tài khoản", "Gateway Id": "ID cổng", "Api Version": "Phiên bản API", "Endpoint gerido pelo provider: ": "Endpoint do nhà cung cấp quản lý: ", "Endpoint OpenAI-compatible deste provider; só aparece quando é configurável.": "Chỉ hiển thị trường này với nhà cung cấp có endpoint OpenAI tương thích tùy chỉnh.", "ID do modelo usado pelo endpoint Chat Completions.": "ID mô hình được endpoint Chat Completions sử dụng.", "Configure cada provider num cartão independente. Pode repetir o mesmo provider para manter várias API keys; o cartão activo é usado pela geração de conteúdo.": "Định cấu hình từng nhà cung cấp trong thẻ riêng. Có thể lặp lại nhà cung cấp cho nhiều khóa API; thẻ đang hoạt động được dùng để tạo nội dung."},
+    "tr": {"LLM principal": "Birincil LLM", "Usar este cartão como provider principal para geração de temas, roteiros, títulos e keywords.": "Konu, senaryo, başlık ve anahtar kelimeler için bu kartı birincil sağlayıcı olarak kullanın.", "Usar este cartão exclusivamente para o roteamento de notificações Telegram. Apenas um cartão pode ficar seleccionado.": "Bu kartı yalnızca Telegram bildirim yönlendirmesi için kullanın. Yalnızca bir kart seçilebilir.", "Account Id": "Hesap Kimliği", "Gateway Id": "Ağ Geçidi Kimliği", "Api Version": "API sürümü", "Endpoint gerido pelo provider: ": "Sağlayıcı tarafından yönetilen uç nokta: ", "Endpoint OpenAI-compatible deste provider; só aparece quando é configurável.": "Bu alan yalnızca yapılandırılabilir OpenAI uyumlu uç noktası olan sağlayıcılarda görünür.", "ID do modelo usado pelo endpoint Chat Completions.": "Chat Completions uç noktası tarafından kullanılan model kimliği.", "Configure cada provider num cartão independente. Pode repetir o mesmo provider para manter várias API keys; o cartão activo é usado pela geração de conteúdo.": "Her sağlayıcıyı bağımsız bir kartta yapılandırın. Bir sağlayıcı birden fazla API anahtarı için tekrarlanabilir; etkin kart içerik üretiminde kullanılır."},
+    "ru": {"LLM principal": "Основной LLM", "Usar este cartão como provider principal para geração de temas, roteiros, títulos e keywords.": "Использовать эту карточку как основной провайдер для тем, сценариев, заголовков и ключевых слов.", "Usar este cartão exclusivamente para o roteamento de notificações Telegram. Apenas um cartão pode ficar seleccionado.": "Использовать эту карточку только для маршрутизации уведомлений Telegram. Можно выбрать только одну карточку.", "Account Id": "ID аккаунта", "Gateway Id": "ID шлюза", "Api Version": "Версия API", "Endpoint gerido pelo provider: ": "Эндпоинт под управлением провайдера: ", "Endpoint OpenAI-compatible deste provider; só aparece quando é configurável.": "Поле отображается только для провайдеров с настраиваемым OpenAI-совместимым эндпоинтом.", "ID do modelo usado pelo endpoint Chat Completions.": "ID модели, используемый эндпоинтом Chat Completions.", "Configure cada provider num cartão independente. Pode repetir o mesmo provider para manter várias API keys; o cartão activo é usado pela geração de conteúdo.": "Настройте каждого провайдера в отдельной карточке. Провайдера можно повторить для нескольких API-ключей; активная карточка используется для генерации контента."},
+    "es": {"LLM principal": "LLM principal", "Usar este cartão como provider principal para geração de temas, roteiros, títulos e keywords.": "Usar esta tarjeta como proveedor principal para temas, guiones, títulos y palabras clave.", "Usar este cartão exclusivamente para o roteamento de notificações Telegram. Apenas um cartão pode ficar seleccionado.": "Usar esta tarjeta exclusivamente para enrutar notificaciones de Telegram. Solo se puede seleccionar una tarjeta.", "Account Id": "ID de cuenta", "Gateway Id": "ID de puerta de enlace", "Api Version": "Versión de API", "Endpoint gerido pelo provider: ": "Endpoint gestionado por el proveedor: ", "Endpoint OpenAI-compatible deste provider; só aparece quando é configurável.": "Este campo solo aparece para proveedores con un endpoint OpenAI compatible configurable.", "ID do modelo usado pelo endpoint Chat Completions.": "ID del modelo usado por el endpoint Chat Completions.", "Configure cada provider num cartão independente. Pode repetir o mesmo provider para manter várias API keys; o cartão activo é usado pela geração de conteúdo.": "Configura cada proveedor en una tarjeta independiente. Puedes repetir un proveedor para varias claves API; la tarjeta activa se usa para generar contenido."},
+    "id": {"LLM principal": "LLM utama", "Usar este cartão como provider principal para geração de temas, roteiros, títulos e keywords.": "Gunakan kartu ini sebagai penyedia utama untuk topik, skrip, judul, dan kata kunci.", "Usar este cartão exclusivamente para o roteamento de notificações Telegram. Apenas um cartão pode ficar seleccionado.": "Gunakan kartu ini khusus untuk perutean notifikasi Telegram. Hanya satu kartu yang dapat dipilih.", "Account Id": "ID akun", "Gateway Id": "ID gateway", "Api Version": "Versi API", "Endpoint gerido pelo provider: ": "Endpoint yang dikelola penyedia: ", "Endpoint OpenAI-compatible deste provider; só aparece quando é configurável.": "Bidang ini hanya tampil untuk penyedia dengan endpoint OpenAI-compatible yang dapat dikonfigurasi.", "ID do modelo usado pelo endpoint Chat Completions.": "ID model yang digunakan endpoint Chat Completions.", "Configure cada provider num cartão independente. Pode repetir o mesmo provider para manter várias API keys; o cartão activo é usado pela geração de conteúdo.": "Konfigurasikan setiap penyedia dalam kartu terpisah. Penyedia dapat diulang untuk beberapa kunci API; kartu aktif digunakan untuk pembuatan konten."},
+    "it": {"LLM principal": "LLM principale", "Usar este cartão como provider principal para geração de temas, roteiros, títulos e keywords.": "Usa questa scheda come provider principale per argomenti, copioni, titoli e parole chiave.", "Usar este cartão exclusivamente para o roteamento de notificações Telegram. Apenas um cartão pode ficar seleccionado.": "Usa questa scheda esclusivamente per il routing delle notifiche Telegram. È possibile selezionare una sola scheda.", "Account Id": "ID account", "Gateway Id": "ID gateway", "Api Version": "Versione API", "Endpoint gerido pelo provider: ": "Endpoint gestito dal provider: ", "Endpoint OpenAI-compatible deste provider; só aparece quando é configurável.": "Il campo appare solo per provider con endpoint OpenAI compatibile configurabile.", "ID do modelo usado pelo endpoint Chat Completions.": "ID del modello usato dall'endpoint Chat Completions.", "Configure cada provider num cartão independente. Pode repetir o mesmo provider para manter várias API keys; o cartão activo é usado pela geração de conteúdo.": "Configura ogni provider in una scheda indipendente. Puoi ripetere un provider per più chiavi API; la scheda attiva viene usata per generare contenuti."},
+}
+for _language_code, _llm_control_values in _LLM_CONTROL_TRANSLATIONS.items():
+    UI_TRANSLATIONS[_language_code].update(_llm_control_values)
+
+
 # Labels introduced by the reorganised sidebar. They are merged into the
 # existing UI translation index so every navigation control uses the same
 # translation path as the legacy pages.
@@ -191,6 +258,72 @@ for _language_code, _backlog_label in _BACKLOG_CANONICAL_LABELS.items():
     UI_TRANSLATIONS[_language_code]["Backlog Videos"] = _backlog_label
 
 
+_GLOBAL_INNERTUBE_TRANSLATIONS: dict[str, dict[str, str]] = {
+    "pt": {
+        "Esta é uma chave API global do YouTube: aplica-se a todas as contas Google/YouTube e a todo o sistema. Não é associada a uma conta específica, não faz parte dos documentos de cookies/credenciais e não é editada no separador API Keys.": "Esta é uma chave API global do YouTube: aplica-se a todas as contas Google/YouTube e a todo o sistema. Não é associada a uma conta específica, não faz parte dos documentos de cookies/credenciais e não é editada no separador API Keys.",
+        "Chave global usada pelo Upload directo para todas as contas Google/YouTube. Guarde-a na configuração global, separada dos documentos de cookies.": "Chave global usada pelo Upload directo para todas as contas Google/YouTube. Guarde-a na configuração global, separada dos documentos de cookies.",
+        "Guardar INNERTUBE_API_KEY global": "Guardar INNERTUBE_API_KEY global",
+        "INNERTUBE_API_KEY global guardada para todas as contas Google/YouTube e para todo o sistema.": "INNERTUBE_API_KEY global guardada para todas as contas Google/YouTube e para todo o sistema.",
+    },
+    "en": {
+        "Esta é uma chave API global do YouTube: aplica-se a todas as contas Google/YouTube e a todo o sistema. Não é associada a uma conta específica, não faz parte dos documentos de cookies/credenciais e não é editada no separador API Keys.": "This is a global YouTube API key: it applies to every Google/YouTube account and the entire system. It is not associated with a specific account, is not part of cookie/credential documents, and is not edited in the API Keys tab.",
+        "Chave global usada pelo Upload directo para todas as contas Google/YouTube. Guarde-a na configuração global, separada dos documentos de cookies.": "Global key used by direct upload for all Google/YouTube accounts. Save it in the global configuration, separately from cookie documents.",
+        "Guardar INNERTUBE_API_KEY global": "Save global INNERTUBE_API_KEY",
+        "INNERTUBE_API_KEY global guardada para todas as contas Google/YouTube e para todo o sistema.": "Global INNERTUBE_API_KEY saved for all Google/YouTube accounts and the entire system.",
+    },
+    "zh": {
+        "Esta é uma chave API global do YouTube: aplica-se a todas as contas Google/YouTube e a todo o sistema. Não é associada a uma conta específica, não faz parte dos documentos de cookies/credenciais e não é editada no separador API Keys.": "这是 YouTube 的全局 API 密钥：适用于所有 Google/YouTube 账户和整个系统。它不关联特定账户，不属于 Cookie/凭证文档，也不在 API 密钥选项卡中编辑。",
+        "Chave global usada pelo Upload directo para todas as contas Google/YouTube. Guarde-a na configuração global, separada dos documentos de cookies.": "直接上传为所有 Google/YouTube 账户使用的全局密钥。请将其保存在全局配置中，与 Cookie 文档分开。",
+        "Guardar INNERTUBE_API_KEY global": "保存全局 INNERTUBE_API_KEY",
+        "INNERTUBE_API_KEY global guardada para todas as contas Google/YouTube e para todo o sistema.": "全局 INNERTUBE_API_KEY 已为所有 Google/YouTube 账户和整个系统保存。",
+    },
+    "de": {
+        "Esta é uma chave API global do YouTube: aplica-se a todas as contas Google/YouTube e a todo o sistema. Não é associada a uma conta específica, não faz parte dos documentos de cookies/credenciais e não é editada no separador API Keys.": "Dies ist ein globaler YouTube-API-Schlüssel: Er gilt für alle Google/YouTube-Konten und das gesamte System. Er ist keinem bestimmten Konto zugeordnet, gehört nicht zu Cookie-/Anmeldedokumenten und wird nicht im Tab API-Schlüssel bearbeitet.",
+        "Chave global usada pelo Upload directo para todas as contas Google/YouTube. Guarde-a na configuração global, separada dos documentos de cookies.": "Globaler Schlüssel für den direkten Upload mit allen Google/YouTube-Konten. Speichern Sie ihn in der globalen Konfiguration getrennt von den Cookie-Dokumenten.",
+        "Guardar INNERTUBE_API_KEY global": "Globale INNERTUBE_API_KEY speichern",
+        "INNERTUBE_API_KEY global guardada para todas as contas Google/YouTube e para todo o sistema.": "Globale INNERTUBE_API_KEY für alle Google/YouTube-Konten und das gesamte System gespeichert.",
+    },
+    "vi": {
+        "Esta é uma chave API global do YouTube: aplica-se a todas as contas Google/YouTube e a todo o sistema. Não é associada a uma conta específica, não faz parte dos documentos de cookies/credenciais e não é editada no separador API Keys.": "Đây là khóa API YouTube toàn cục: áp dụng cho mọi tài khoản Google/YouTube và toàn bộ hệ thống. Khóa không gắn với tài khoản cụ thể, không thuộc tài liệu cookie/thông tin xác thực và không được chỉnh sửa trong tab API Keys.",
+        "Chave global usada pelo Upload directo para todas as contas Google/YouTube. Guarde-a na configuração global, separada dos documentos de cookies.": "Khóa toàn cục dùng cho tải lên trực tiếp với mọi tài khoản Google/YouTube. Lưu khóa trong cấu hình toàn cục, tách khỏi tài liệu cookie.",
+        "Guardar INNERTUBE_API_KEY global": "Lưu INNERTUBE_API_KEY toàn cục",
+        "INNERTUBE_API_KEY global guardada para todas as contas Google/YouTube e para todo o sistema.": "Đã lưu INNERTUBE_API_KEY toàn cục cho mọi tài khoản Google/YouTube và toàn hệ thống.",
+    },
+    "tr": {
+        "Esta é uma chave API global do YouTube: aplica-se a todas as contas Google/YouTube e a todo o sistema. Não é associada a uma conta específica, não faz parte dos documentos de cookies/credenciais e não é editada no separador API Keys.": "Bu, tüm Google/YouTube hesapları ve sistemin tamamı için geçerli global bir YouTube API anahtarıdır. Belirli bir hesaba bağlı değildir, çerez/kimlik bilgisi belgelerinin parçası değildir ve API Anahtarları sekmesinde düzenlenmez.",
+        "Chave global usada pelo Upload directo para todas as contas Google/YouTube. Guarde-a na configuração global, separada dos documentos de cookies.": "Doğrudan yüklemede tüm Google/YouTube hesapları için kullanılan global anahtar. Çerez belgelerinden ayrı olarak global yapılandırmaya kaydedin.",
+        "Guardar INNERTUBE_API_KEY global": "Global INNERTUBE_API_KEY kaydet",
+        "INNERTUBE_API_KEY global guardada para todas as contas Google/YouTube e para todo o sistema.": "Global INNERTUBE_API_KEY tüm Google/YouTube hesapları ve sistem için kaydedildi.",
+    },
+    "ru": {
+        "Esta é uma chave API global do YouTube: aplica-se a todas as contas Google/YouTube e a todo o sistema. Não é associada a uma conta específica, não faz parte dos documentos de cookies/credenciais e não é editada no separador API Keys.": "Это глобальный API-ключ YouTube: он применяется ко всем аккаунтам Google/YouTube и ко всей системе. Он не связан с конкретным аккаунтом, не входит в документы cookie/учётных данных и не редактируется на вкладке API-ключей.",
+        "Chave global usada pelo Upload directo para todas as contas Google/YouTube. Guarde-a na configuração global, separada dos documentos de cookies.": "Глобальный ключ для прямой загрузки со всех аккаунтов Google/YouTube. Сохраните его в глобальной конфигурации отдельно от документов cookie.",
+        "Guardar INNERTUBE_API_KEY global": "Сохранить глобальный INNERTUBE_API_KEY",
+        "INNERTUBE_API_KEY global guardada para todas as contas Google/YouTube e para todo o sistema.": "Глобальный INNERTUBE_API_KEY сохранён для всех аккаунтов Google/YouTube и всей системы.",
+    },
+    "es": {
+        "Esta é uma chave API global do YouTube: aplica-se a todas as contas Google/YouTube e a todo o sistema. Não é associada a uma conta específica, não faz parte dos documentos de cookies/credenciais e não é editada no separador API Keys.": "Esta es una clave API global de YouTube: se aplica a todas las cuentas de Google/YouTube y a todo el sistema. No está asociada a una cuenta concreta, no forma parte de los documentos de cookies/credenciales y no se edita en la pestaña Claves API.",
+        "Chave global usada pelo Upload directo para todas as contas Google/YouTube. Guarde-a na configuração global, separada dos documentos de cookies.": "Clave global utilizada por la carga directa para todas las cuentas de Google/YouTube. Guárdela en la configuración global, separada de los documentos de cookies.",
+        "Guardar INNERTUBE_API_KEY global": "Guardar INNERTUBE_API_KEY global",
+        "INNERTUBE_API_KEY global guardada para todas as contas Google/YouTube e para todo o sistema.": "INNERTUBE_API_KEY global guardada para todas las cuentas de Google/YouTube y todo el sistema.",
+    },
+    "id": {
+        "Esta é uma chave API global do YouTube: aplica-se a todas as contas Google/YouTube e a todo o sistema. Não é associada a uma conta específica, não faz parte dos documentos de cookies/credenciais e não é editada no separador API Keys.": "Ini adalah kunci API YouTube global: berlaku untuk semua akun Google/YouTube dan seluruh sistem. Kunci ini tidak terkait dengan akun tertentu, bukan bagian dari dokumen cookie/kredensial, dan tidak diedit di tab Kunci API.",
+        "Chave global usada pelo Upload directo para todas as contas Google/YouTube. Guarde-a na configuração global, separada dos documentos de cookies.": "Kunci global yang digunakan unggah langsung untuk semua akun Google/YouTube. Simpan di konfigurasi global, terpisah dari dokumen cookie.",
+        "Guardar INNERTUBE_API_KEY global": "Simpan INNERTUBE_API_KEY global",
+        "INNERTUBE_API_KEY global guardada para todas as contas Google/YouTube e para todo o sistema.": "INNERTUBE_API_KEY global disimpan untuk semua akun Google/YouTube dan seluruh sistem.",
+    },
+    "it": {
+        "Esta é uma chave API global do YouTube: aplica-se a todas as contas Google/YouTube e a todo o sistema. Não é associada a uma conta específica, não faz parte dos documentos de cookies/credenciais e não é editada no separador API Keys.": "Questa è una chiave API globale di YouTube: si applica a tutti gli account Google/YouTube e all'intero sistema. Non è associata a un account specifico, non fa parte dei documenti di cookie/credenziali e non viene modificata nella scheda Chiavi API.",
+        "Chave global usada pelo Upload directo para todas as contas Google/YouTube. Guarde-a na configuração global, separada dos documentos de cookies.": "Chiave globale usata dal caricamento diretto per tutti gli account Google/YouTube. Salvala nella configurazione globale, separata dai documenti cookie.",
+        "Guardar INNERTUBE_API_KEY global": "Salva INNERTUBE_API_KEY globale",
+        "INNERTUBE_API_KEY global guardada para todas as contas Google/YouTube e para todo o sistema.": "INNERTUBE_API_KEY globale salvata per tutti gli account Google/YouTube e per l'intero sistema.",
+    },
+}
+for _language_code, _global_innertube_translation in _GLOBAL_INNERTUBE_TRANSLATIONS.items():
+    UI_TRANSLATIONS[_language_code].update(_global_innertube_translation)
+
+
 VIDEO_GENERATION_TRANSLATIONS: dict[str, dict[str, str]] = {
     "pt": {
         "Gerar tópico, roteiro e palavras-chave com IA": "Gerar tópico, roteiro e palavras-chave com IA",

package/hermes_ui/llm_providers.py

@@ -0,0 +1,414 @@
+"""Catálogo e compatibilidade dos cartões de providers LLM do Thunderbolt.
+
+Este módulo não conhece Streamlit. Mantém o formato novo de cartões separado da UI,
+conserva os campos legados usados pelo pipeline e centraliza a validação do estado.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any, Mapping
+from urllib.parse import urlsplit, urlunsplit
+
+from integrations.openai_model_discovery import (
+    DEFAULT_NVIDIA_NIM_BASE_URL,
+    ModelDiscoveryError,
+    fetch_openai_compatible_models,
+)
+
+
+LLM_CARDS_KEY = "llm_provider_cards"
+LLM_ACTIVE_CARD_KEY = "llm_active_card_id"
+LLM_TELEGRAM_CARD_KEY = "llm_telegram_card_id"
+DEFAULT_LLM_PROVIDER = "openai"
+DEFAULT_LLM_CARD_ID = "llm-openai-default"
+
+
+@dataclass(frozen=True, slots=True)
+class LlmProviderDefinition:
+    code: str
+    label: str
+    requires_api_key: bool = True
+    show_base_url: bool = False
+    default_base_url: str = ""
+    local: bool = False
+    supports_model_discovery: bool = True
+    extra_fields: tuple[str, ...] = ()
+    description: str = ""
+
+
+# Só estão aqui providers que o adaptador OpenAI-compatible existente consegue
+# consumir, ou que são explicitamente apresentados como locais/customizáveis. A
+# lista é extensível sem alterar o schema dos cartões.
+LLM_PROVIDER_CATALOG: tuple[LlmProviderDefinition, ...] = (
+    LlmProviderDefinition(
+        "openai",
+        "OpenAI / NVIDIA NIM",
+        show_base_url=True,
+        default_base_url=DEFAULT_NVIDIA_NIM_BASE_URL,
+        description="OpenAI ou NVIDIA NIM através do protocolo OpenAI-compatible.",
+    ),
+    LlmProviderDefinition("openrouter", "OpenRouter", default_base_url="https://openrouter.ai/api/v1"),
+    LlmProviderDefinition("moonshot", "Moonshot / Kimi", default_base_url="https://api.moonshot.ai/v1"),
+    LlmProviderDefinition("shengsuanyun", "Shengsuan Cloud", show_base_url=True),
+    LlmProviderDefinition(
+        "gemini",
+        "Google Gemini",
+        default_base_url="https://generativelanguage.googleapis.com/v1beta/openai/",
+    ),
+    LlmProviderDefinition("deepseek", "DeepSeek", default_base_url="https://api.deepseek.com"),
+    LlmProviderDefinition("azure", "Azure OpenAI", show_base_url=True, extra_fields=("api_version",), description="Requer a Base URL do recurso Azure e a versão da API."),
+    LlmProviderDefinition(
+        "qwen",
+        "Alibaba Qwen / DashScope",
+        default_base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
+    ),
+    LlmProviderDefinition("mistral", "Mistral", default_base_url="https://api.mistral.ai/v1"),
+    LlmProviderDefinition("groq", "Groq", default_base_url="https://api.groq.com/openai/v1"),
+    LlmProviderDefinition("grok", "xAI Grok", default_base_url="https://api.x.ai/v1"),
+    LlmProviderDefinition("volcengine", "VolcEngine Ark", default_base_url="https://ark.cn-beijing.volces.com/api/v3"),
+    LlmProviderDefinition("minimax", "MiniMax", default_base_url="https://api.minimax.io/v1"),
+    LlmProviderDefinition("mimo", "Xiaomi MiMo", show_base_url=True),
+    LlmProviderDefinition(
+        "cloudflare",
+        "Cloudflare Workers AI",
+        show_base_url=False,
+        supports_model_discovery=False,
+        extra_fields=("account_id", "gateway_id"),
+        description="Requer Account ID; o endpoint é construído pelo adaptador Cloudflare.",
+    ),
+    LlmProviderDefinition("modelscope", "ModelScope", show_base_url=True),
+    LlmProviderDefinition("aihubmix", "AIHubMix", default_base_url="https://aihubmix.com/v1"),
+    LlmProviderDefinition("aimlapi", "AIML API", default_base_url="https://api.aimlapi.com/v1"),
+    LlmProviderDefinition("evolink", "EvoLink", default_base_url="https://api.evolink.ai/v1"),
+    LlmProviderDefinition(
+        "ollama",
+        "Ollama",
+        requires_api_key=False,
+        show_base_url=True,
+        default_base_url="http://127.0.0.1:11434/v1",
+        local=True,
+    ),
+    LlmProviderDefinition(
+        "lmstudio",
+        "LM Studio",
+        requires_api_key=False,
+        show_base_url=True,
+        default_base_url="http://127.0.0.1:1234/v1",
+        local=True,
+    ),
+    LlmProviderDefinition(
+        "llamacpp",
+        "llama.cpp",
+        requires_api_key=False,
+        show_base_url=True,
+        default_base_url="http://127.0.0.1:8080/v1",
+        local=True,
+    ),
+    LlmProviderDefinition("oneapi", "OneAPI", show_base_url=True),
+    LlmProviderDefinition("litellm", "LiteLLM Proxy", requires_api_key=False, show_base_url=True),
+    LlmProviderDefinition(
+        "pollinations",
+        "Pollinations AI",
+        requires_api_key=True,
+        default_base_url="https://gen.pollinations.ai/v1",
+    ),
+    LlmProviderDefinition("together", "Together AI", default_base_url="https://api.together.ai/v1"),
+    LlmProviderDefinition("fireworks", "Fireworks AI", default_base_url="https://api.fireworks.ai/inference/v1"),
+    LlmProviderDefinition("siliconflow", "SiliconFlow", default_base_url="https://api.siliconflow.com/v1"),
+    LlmProviderDefinition("cohere", "Cohere", default_base_url="https://api.cohere.ai/compatibility/v1"),
+    LlmProviderDefinition("huggingface", "Hugging Face", default_base_url="https://router.huggingface.co/v1"),
+    LlmProviderDefinition("github_models", "GitHub Models", default_base_url="https://models.github.ai/inference"),
+    LlmProviderDefinition("cerebras", "Cerebras", default_base_url="https://api.cerebras.ai/v1"),
+    LlmProviderDefinition("sambanova", "SambaNova", default_base_url="https://api.sambanova.ai/v1"),
+    LlmProviderDefinition("perplexity", "Perplexity", default_base_url="https://api.perplexity.ai"),
+    LlmProviderDefinition("openai_compatible", "OpenAI-compatible personalizado", show_base_url=True),
+)
+
+_PROVIDER_BY_CODE = {item.code: item for item in LLM_PROVIDER_CATALOG}
+_PROVIDER_ALIASES = {
+    "open_router": "openrouter",
+    "xai": "grok",
+    "google": "gemini",
+    "google_gemini": "gemini",
+    "azure_openai": "azure",
+    "custom": "openai_compatible",
+}
+_LEGACY_PREFIX = {
+    "openrouter": "openrouter",
+    "openai_compatible": "openai",
+    "github_models": "github_models",
+}
+
+
+def provider_definition(provider: Any) -> LlmProviderDefinition:
+    code = normalize_provider_code(provider)
+    return _PROVIDER_BY_CODE.get(code, _PROVIDER_BY_CODE["openai_compatible"])
+
+
+def normalize_provider_code(provider: Any) -> str:
+    value = str(provider or "").strip().lower().replace(" ", "_")
+    return _PROVIDER_ALIASES.get(value, value or DEFAULT_LLM_PROVIDER)
+
+
+def _legacy_prefix(provider: str) -> str:
+    return _LEGACY_PREFIX.get(provider, provider)
+
+
+def _legacy_value(settings: Mapping[str, Any], provider: str, suffix: str) -> str:
+    prefix = _legacy_prefix(provider)
+    return str(settings.get(f"{prefix}_{suffix}") or "").strip()
+
+
+def _legacy_card(settings: Mapping[str, Any], provider: str, card_id: str) -> dict[str, Any]:
+    definition = provider_definition(provider)
+    code = normalize_provider_code(provider)
+    base_url = _legacy_value(settings, code, "base_url") or definition.default_base_url
+    api_key = _legacy_value(settings, code, "api_key")
+    model = _legacy_value(settings, code, "model_name")
+    extra: dict[str, str] = {}
+    if code == "cloudflare":
+        extra = {
+            "account_id": str(settings.get("cloudflare_account_id") or "").strip(),
+            "gateway_id": str(settings.get("cloudflare_gateway_id") or "").strip(),
+        }
+    return {
+        "id": card_id,
+        "provider": code,
+        "api_key": api_key,
+        "model": model,
+        "base_url": base_url,
+        "enabled": True,
+        "telegram_llm": False,
+        **extra,
+    }
+
+
+def new_llm_card(provider: Any, *, card_id: str | None = None) -> dict[str, Any]:
+    code = normalize_provider_code(provider)
+    definition = provider_definition(code)
+    return {
+        "id": str(card_id or "llm-" + code),
+        "provider": code,
+        "api_key": "",
+        "model": "",
+        "base_url": definition.default_base_url,
+        "enabled": True,
+        "telegram_llm": False,
+        **{field: "" for field in definition.extra_fields},
+    }
+
+
+def _clean_test_result(value: Any) -> dict[str, Any]:
+    if not isinstance(value, Mapping):
+        return {}
+    status = str(value.get("status") or "").strip().lower()
+    if status not in {"success", "error"}:
+        return {}
+    return {
+        "status": status,
+        "message": str(value.get("message") or "")[:240],
+        "tested_at": str(value.get("tested_at") or "")[:64],
+    }
+
+
+def normalize_llm_card(card: Any, index: int = 0) -> dict[str, Any]:
+    source = dict(card) if isinstance(card, Mapping) else {}
+    code = normalize_provider_code(source.get("provider") or source.get("provider_code"))
+    definition = provider_definition(code)
+    raw_id = str(source.get("id") or "").strip()
+    card_id = raw_id or (DEFAULT_LLM_CARD_ID if code == "openai" and index == 0 else f"llm-{code}-{index + 1}")
+    result: dict[str, Any] = {
+        "id": card_id,
+        "provider": code,
+        "api_key": str(source.get("api_key") or source.get("key") or "").strip(),
+        "model": str(source.get("model") or source.get("model_name") or "").strip(),
+        "base_url": str(source.get("base_url") or "").strip() or definition.default_base_url,
+        "enabled": bool(source.get("enabled", True)),
+        "telegram_llm": bool(source.get("telegram_llm", source.get("llm_telegram", False))),
+    }
+    for field in definition.extra_fields:
+        result[field] = str(source.get(field) or "").strip()
+    test_result = _clean_test_result(source.get("test_result"))
+    if test_result:
+        result["test_result"] = test_result
+    return result
+
+
+def _card_has_legacy_configuration(settings: Mapping[str, Any], provider: str) -> bool:
+    definition = provider_definition(provider)
+    values = [_legacy_value(settings, provider, "api_key"), _legacy_value(settings, provider, "model_name")]
+    if definition.show_base_url:
+        values.append(_legacy_value(settings, provider, "base_url"))
+    values.extend(str(settings.get(f"{provider}_{field}") or "").strip() for field in definition.extra_fields)
+    return any(values)
+
+
+def ensure_llm_provider_cards(settings: Mapping[str, Any]) -> tuple[dict[str, Any], bool]:
+    """Return settings with a stable card collection and legacy values untouched."""
+    result = dict(settings) if isinstance(settings, Mapping) else {}
+    raw_cards = result.get(LLM_CARDS_KEY)
+    cards = [normalize_llm_card(item, index) for index, item in enumerate(raw_cards)] if isinstance(raw_cards, list) else []
+    changed = not isinstance(raw_cards, list)
+
+    # O primeiro card OpenAI/NVIDIA NIM é estrutural e nunca é removido pela migração.
+    if not any(card.get("provider") == DEFAULT_LLM_PROVIDER for card in cards):
+        cards.insert(0, _legacy_card(result, DEFAULT_LLM_PROVIDER, DEFAULT_LLM_CARD_ID))
+        changed = True
+    elif cards[0].get("provider") != DEFAULT_LLM_PROVIDER:
+        openai_card = next(card for card in cards if card.get("provider") == DEFAULT_LLM_PROVIDER)
+        cards.remove(openai_card)
+        cards.insert(0, openai_card)
+        changed = True
+
+    selected_provider = normalize_provider_code(result.get("llm_provider") or DEFAULT_LLM_PROVIDER)
+    if not str(result.get("llm_provider") or "").strip():
+        result["llm_provider"] = DEFAULT_LLM_PROVIDER
+        changed = True
+    # A migração preserva uma configuração explícita antiga que ainda não tinha card.
+    if selected_provider != DEFAULT_LLM_PROVIDER and _card_has_legacy_configuration(result, selected_provider):
+        if not any(card.get("provider") == selected_provider for card in cards):
+            cards.append(_legacy_card(result, selected_provider, f"llm-{selected_provider}-legacy"))
+            changed = True
+
+    serialized_before = raw_cards if isinstance(raw_cards, list) else None
+    if serialized_before != cards:
+        changed = True
+    result[LLM_CARDS_KEY] = cards
+
+    active_id = str(result.get(LLM_ACTIVE_CARD_KEY) or "").strip()
+    ids = {str(card.get("id")) for card in cards}
+    if active_id not in ids:
+        matching = next((card for card in cards if card.get("provider") == selected_provider), cards[0])
+        result[LLM_ACTIVE_CARD_KEY] = str(matching["id"])
+        changed = True
+    if not any(card.get("telegram_llm") for card in cards):
+        if result.get(LLM_TELEGRAM_CARD_KEY):
+            result[LLM_TELEGRAM_CARD_KEY] = ""
+            changed = True
+    else:
+        telegram_card = next(card for card in cards if card.get("telegram_llm"))
+        if result.get(LLM_TELEGRAM_CARD_KEY) != telegram_card["id"]:
+            result[LLM_TELEGRAM_CARD_KEY] = telegram_card["id"]
+            changed = True
+    return result, changed
+
+
+def llm_cards(settings: Mapping[str, Any]) -> list[dict[str, Any]]:
+    migrated, _ = ensure_llm_provider_cards(settings)
+    return [dict(card) for card in migrated.get(LLM_CARDS_KEY, [])]
+
+
+def active_llm_card(settings: Mapping[str, Any]) -> dict[str, Any]:
+    migrated, _ = ensure_llm_provider_cards(settings)
+    cards = migrated.get(LLM_CARDS_KEY, [])
+    active_id = str(migrated.get(LLM_ACTIVE_CARD_KEY) or "")
+    for card in cards:
+        if str(card.get("id")) == active_id and card.get("enabled", True):
+            return dict(card)
+    for card in cards:
+        if card.get("enabled", True):
+            return dict(card)
+    return new_llm_card(DEFAULT_LLM_PROVIDER, card_id=DEFAULT_LLM_CARD_ID)
+
+
+def telegram_llm_card(settings: Mapping[str, Any]) -> dict[str, Any] | None:
+    for card in llm_cards(settings):
+        if card.get("telegram_llm") and card.get("enabled", True):
+            return card
+    return None
+
+
+def apply_llm_cards_to_settings(
+    settings: Mapping[str, Any], cards: list[Mapping[str, Any]], active_card_id: str = ""
+) -> dict[str, Any]:
+    """Persist cards and mirror the active card to the legacy runtime contract."""
+    result = dict(settings)
+    normalized = [normalize_llm_card(item, index) for index, item in enumerate(cards)]
+    if not normalized or not any(card.get("provider") == DEFAULT_LLM_PROVIDER for card in normalized):
+        normalized.insert(0, _legacy_card(result, DEFAULT_LLM_PROVIDER, DEFAULT_LLM_CARD_ID))
+
+    # Checkbox Telegram é exclusivo: o último card marcado vence e todos os outros
+    # ficam desmarcados. O ID explícito torna o roteamento determinístico.
+    telegram = next((card for card in reversed(normalized) if card.get("telegram_llm")), None)
+    for card in normalized:
+        card["telegram_llm"] = bool(telegram and card["id"] == telegram["id"])
+
+    wanted_id = str(active_card_id or result.get(LLM_ACTIVE_CARD_KEY) or "").strip()
+    active = next((card for card in normalized if card["id"] == wanted_id), None)
+    if active is None or not active.get("enabled", True):
+        active = next((card for card in normalized if card.get("enabled", True)), normalized[0])
+    result[LLM_CARDS_KEY] = normalized
+    result[LLM_ACTIVE_CARD_KEY] = active["id"]
+    result[LLM_TELEGRAM_CARD_KEY] = telegram["id"] if telegram else ""
+    result["llm_provider"] = active["provider"]
+
+    prefix = _legacy_prefix(str(active["provider"]))
+    result[f"{prefix}_api_key"] = str(active.get("api_key") or "").strip()
+    result[f"{prefix}_model_name"] = str(active.get("model") or "").strip()
+    result[f"{prefix}_base_url"] = str(active.get("base_url") or "").strip()
+    definition = provider_definition(active["provider"])
+    for field in definition.extra_fields:
+        result[f"{prefix}_{field}"] = str(active.get(field) or "").strip()
+    if active.get("provider") == "cloudflare":
+        result["cloudflare_account_id"] = str(active.get("account_id") or "").strip()
+        result["cloudflare_gateway_id"] = str(active.get("gateway_id") or "").strip()
+    return result
+
+
+def _safe_url(value: str) -> str:
+    try:
+        parsed = urlsplit(str(value or ""))
+        return urlunsplit((parsed.scheme, parsed.netloc, parsed.path, "", ""))
+    except ValueError:
+        return "endpoint configurado"
+
+
+def _redact(text: Any, secrets: tuple[str, ...]) -> str:
+    message = str(text or "")
+    for secret in secrets:
+        if secret:
+            message = message.replace(secret, "[REDACTED]")
+    return message[:240]
+
+
+def test_llm_provider_card(card: Mapping[str, Any]) -> dict[str, Any]:
+    """Perform a bounded provider check without returning secrets or raw exceptions."""
+    normalized = normalize_llm_card(card)
+    definition = provider_definition(normalized["provider"])
+    api_key = str(normalized.get("api_key") or "").strip()
+    base_url = str(normalized.get("base_url") or "").strip()
+    secrets = (api_key,)
+    if definition.requires_api_key and not api_key:
+        return {"ok": False, "status": "error", "message": "Missing key — introduza a API key antes do teste."}
+    if definition.show_base_url and not base_url:
+        return {"ok": False, "status": "error", "message": "Missing configuration — introduza a Base URL antes do teste."}
+    if not base_url:
+        return {"ok": False, "status": "error", "message": "Missing configuration — este provider não tem endpoint configurado."}
+    if not definition.supports_model_discovery:
+        return {"ok": False, "status": "error", "message": "Teste automático não suportado para este protocolo; verifique os campos do provider."}
+    try:
+        models = fetch_openai_compatible_models(api_key, base_url)
+    except ModelDiscoveryError as exc:
+        return {
+            "ok": False,
+            "status": "error",
+            "message": _redact(str(exc), secrets),
+        }
+    except Exception:
+        return {"ok": False, "status": "error", "message": "A chamada de teste falhou de forma inesperada."}
+    return {
+        "ok": True,
+        "status": "success",
+        "message": f"API OK — {_safe_url(base_url)} respondeu com {len(models)} modelo(s).",
+    }
+
+
+def stamp_test_result(result: Mapping[str, Any]) -> dict[str, Any]:
+    status = "success" if result.get("ok") else "error"
+    return {
+        "status": status,
+        "message": str(result.get("message") or "")[:240],
+        "tested_at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+    }

package/hermes_ui/pipeline_worker.py

@@ -14,6 +14,7 @@ from hermes_ui.creative_generation import CreativeGenerationError, generate_crea
 from hermes_ui.script_documents import save_script_document
 from hermes_ui.script_generation import generate_script_document
 from hermes_ui.storage import STORAGE, ensure_storage, read_json, write_json
+from hermes_ui.llm_providers import active_llm_card, provider_definition
 from hermes_ui.thumbnail_generation import generate_thumbnail_image
 
 PIPELINE_LOCK_FILENAME = "pipeline_worker.lock"
@@ -120,12 +121,14 @@ def _run_video_helper(task: dict[str, Any]) -> Path:
         raise PipelineError("A etapa Vídeo não recebeu um tema válido.")
     settings = _settings()
     env = os.environ.copy()
-    provider = str(settings.get("llm_provider") or "openai").strip()
+    card = active_llm_card(settings)
+    provider = str(card.get("provider") or "openai").strip()
+    definition = provider_definition(provider)
     env_values = {
         "MPT_LLM_PROVIDER": provider,
-        "MPT_LLM_API_KEY": str(settings.get(f"{provider}_api_key") or "").strip(),
-        "MPT_LLM_BASE_URL": str(settings.get(f"{provider}_base_url") or "").strip(),
-        "MPT_LLM_MODEL_NAME": str(settings.get(f"{provider}_model_name") or "").strip(),
+        "MPT_LLM_API_KEY": str(card.get("api_key") or "").strip(),
+        "MPT_LLM_BASE_URL": str(card.get("base_url") or definition.default_base_url or "").strip(),
+        "MPT_LLM_MODEL_NAME": str(card.get("model") or "").strip(),
         "MPT_PEXELS_API_KEY": str(settings.get("pexels_api_key") or "").strip(),
     }
     for key, value in env_values.items():

package/hermes_ui/storage.py

@@ -128,6 +128,17 @@ DEFAULTS: dict[str, Any] = {
         "apify_poll_interval_seconds": 10,
         "apify_run_timeout_seconds": 900,
         "llm_provider": DEFAULT_LLM_PROVIDER,
+        "llm_provider_cards": [{
+            "id": "llm-openai-default",
+            "provider": "openai",
+            "api_key": "",
+            "model": "",
+            "base_url": "https://integrate.api.nvidia.com/v1",
+            "enabled": True,
+            "telegram_llm": False,
+        }],
+        "llm_active_card_id": "llm-openai-default",
+        "llm_telegram_card_id": "",
         "moonshot_api_key": "",
         "moonshot_base_url": "",
         "moonshot_model_name": "",
@@ -293,15 +304,27 @@ def seed_prompt_masters() -> None:
 
 
 def _migrate_settings(settings: Any) -> tuple[dict[str, Any], bool]:
-    """Keep the shipped OpenAI/NVIDIA NIM default across package upgrades."""
+    """Keep the OpenAI/NVIDIA NIM default and materialise the LLM card schema."""
     if not isinstance(settings, dict):
         return {"llm_provider": DEFAULT_LLM_PROVIDER}, True
 
-    provider = str(settings.get("llm_provider") or "").strip().lower()
-    if provider not in LEGACY_DEFAULT_LLM_PROVIDERS:
-        return settings, False
-
-    return {**settings, "llm_provider": DEFAULT_LLM_PROVIDER}, True
+    migrated = dict(settings)
+    provider = str(migrated.get("llm_provider") or "").strip().lower()
+    changed = False
+    if provider in LEGACY_DEFAULT_LLM_PROVIDERS:
+        migrated["llm_provider"] = DEFAULT_LLM_PROVIDER
+        changed = True
+
+    # Import localmente para evitar que o módulo de catálogo dependa do storage.
+    # Settings antigos com um provider explícito continuam a ser devolvidos sem
+    # alteração textual; os consumidores/UI fazem a materialização preguiçosa dos
+    # cartões, evitando alterar dados durante uma simples leitura de compatibilidade.
+    if "llm_provider_cards" not in migrated and provider not in LEGACY_DEFAULT_LLM_PROVIDERS:
+        return settings, changed
+    from hermes_ui.llm_providers import ensure_llm_provider_cards
+
+    migrated, cards_changed = ensure_llm_provider_cards(migrated)
+    return migrated, changed or cards_changed
 
 
 def ensure_storage() -> None:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.3.12",
+  "version": "0.3.14",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",