@danhachuel/thunderbolt 0.3.18 → 0.3.20

package/app/main.py

@@ -34,7 +34,7 @@ from hermes_ui.python_editor import AUDIO_EXTENSIONS, VIDEO_EXTENSIONS, PythonEd
 from hermes_ui.cuts import CutsError, download_direct_video_url, generate_clips, list_generated_videos as list_cut_generated_videos, list_runs as list_cut_runs, list_video_files as list_cut_video_files, manifest_bytes as cut_manifest_bytes, store_uploaded_video, zip_run as zip_cut_run
 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.material_sources import apply_material_source_cards_to_settings, ensure_material_source_cards, material_source_catalog, material_source_definition, new_material_card, normalize_material_card, selected_material_source
 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
@@ -3663,51 +3663,86 @@ def render_google_accounts():
         st.success("Configuração global do YouTube guardada em Contas Google.")
         st.rerun()
 
-def render_material_source_api_keys(settings: dict[str, Any]) -> None:
-    st.subheader("Fontes de materiais")
-    st.caption("Seleccione a fonte que será usada na pipeline e guarde uma ou mais API keys. Qualidade, endpoints e parâmetros internos são definidos pelo Thunderbolt.")
-    source_catalog = material_source_catalog()
-    source_codes = [item["code"] for item in source_catalog] + ["local"]
-    source_labels = {item["code"]: item["label"] for item in source_catalog} | {"local": "Ficheiros locais"}
-    source_help = {item["code"]: item["description"] for item in source_catalog} | {"local": "Usar materiais já existentes no storage local; não requer API key."}
-    selected_source = st.selectbox(
-        "Fonte de materiais",
-        source_codes,
-        index=source_codes.index(selected_material_source(settings)) if selected_material_source(settings) in source_codes else 0,
-        format_func=lambda value: source_labels.get(value, value),
-        key="material_source_selector",
-    )
-    st.caption(source_help.get(selected_source, ""))
-    current_keys = material_api_keys(settings, selected_source)
-    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
-            write_json("settings.json", settings)
-            st.success("Fonte de materiais guardada: ficheiros locais.")
+def _persist_material_source_cards(settings: dict[str, Any], cards: list[dict[str, Any]], active_card_id: str = "") -> dict[str, Any]:
+    updated = apply_material_source_cards_to_settings(settings, cards, active_card_id)
+    write_json("settings.json", updated)
+    return updated
+
+
+def _material_source_card_definition(provider: str) -> dict[str, str]:
+    definition = material_source_definition(provider)
+    if definition is not None:
+        return definition
+    return {
+        "code": "local",
+        "label": "Ficheiros locais",
+        "description": "Usar materiais já existentes no storage local; não requer API key.",
+        "legacy_key": "",
+    }
+
+
+def _render_material_source_card(settings: dict[str, Any], cards: list[dict[str, Any]], index: int) -> None:
+    card = normalize_material_card(cards[index], index)
+    cards[index] = card
+    card_id = str(card["id"])
+    provider = str(card.get("provider") or "pexels")
+    definition = _material_source_card_definition(provider)
+    is_local = provider == "local"
+    active_card_id = str(settings.get("material_active_card_id") or "")
+    with st.container(border=True):
+        header_cols = st.columns([3.2, 1.2])
+        with header_cols[0]:
+            st.subheader(definition["label"])
+            st.caption(definition["description"])
+        with header_cols[1]:
+            _render_credential_status("" if is_local else card.get("api_key"), local=is_local, required=not is_local)
+        with st.form(f"material_source_card_form_{card_id}"):
+            content_cols = st.columns(2)
+            with content_cols[0]:
+                if is_local:
+                    st.caption("Esta fonte não usa API key.")
+                    api_key = ""
+                else:
+                    api_key = st.text_input("API Key", value=str(card.get("api_key") or ""), type="password", key=f"material_card_{card_id}_api_key")
+            with content_cols[1]:
+                enabled = st.checkbox("Fonte activa", value=bool(card.get("enabled", True)), key=f"material_card_{card_id}_enabled")
+                selected = st.checkbox(
+                    "Usar esta fonte na pipeline",
+                    value=active_card_id == card_id,
+                    key=f"material_card_{card_id}_selected",
+                )
+            save_card = st.form_submit_button("Salvar", type="primary", use_container_width=True, key=f"material_card_{card_id}_save")
+        if save_card:
+            cards[index] = {**card, "api_key": str(api_key or "").strip(), "enabled": bool(enabled)}
+            selected_id = card_id if selected and enabled else active_card_id
+            _persist_material_source_cards(settings, cards, selected_id)
+            st.success(f"Fonte {definition['label']} guardada.")
             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):
-            key_values.append(st.text_input(f"API Key {index + 1}", value=current_keys[index] if index < len(current_keys) else "", type="password", key=f"material_api_key_{selected_source}_{index}"))
-        save_keys = st.form_submit_button("Guardar fonte e chaves", type="primary", use_container_width=True)
-        add_key = st.form_submit_button("Adicionar outra chave", use_container_width=True)
-    if add_key:
-        st.session_state[row_key] = row_count + 1
-        st.rerun()
-    if save_keys:
-        update_material_api_keys(settings, selected_source, key_values)
-        settings["video_source"] = selected_source
+
+
+def render_material_source_api_keys(settings: dict[str, Any]) -> None:
+    st.subheader("Fontes de Materiais")
+    st.caption("Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.")
+    migrated, changed = ensure_material_source_cards(settings)
+    cards = [dict(item) for item in migrated.get("material_source_cards", [])]
+    if changed:
         write_json("settings.json", settings)
-        st.session_state[row_key] = max(1, len(material_api_keys(settings, selected_source)))
-        st.success(f"Fonte {source_labels.get(selected_source, selected_source)} guardada com {len(material_api_keys(settings, selected_source))} chave(s).")
+    for index in range(len(cards)):
+        _render_material_source_card(settings, cards, index)
+
+    st.divider()
+    st.markdown("**Adicionar fonte de materiais**")
+    provider_codes = [item["code"] for item in material_source_catalog()] + ["local"]
+    provider_to_add = st.selectbox(
+        "Provedor de materiais",
+        provider_codes,
+        format_func=lambda value: _material_source_card_definition(value)["label"],
+        key="material_new_provider_choice",
+    )
+    if st.button("Configurar Nova Fonte de Materiais", type="primary", use_container_width=True, key="add_material_source_card"):
+        cards.append(new_material_card(provider_to_add, card_id=f"material-{provider_to_add}-{uuid.uuid4().hex[:8]}"))
+        _persist_material_source_cards(settings, cards, str(settings.get("material_active_card_id") or ""))
         st.rerun()
-    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:
@@ -3853,10 +3888,6 @@ def _render_llm_card(settings: dict[str, Any], cards: list[dict[str, Any]], inde
             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
@@ -3880,7 +3911,7 @@ def _render_llm_card(settings: dict[str, Any], cards: list[dict[str, Any]], inde
         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']}")
+                st.success("Último teste: API Key OK")
             else:
                 st.error(f"Último teste: {saved_test['message']}")
 
@@ -3931,7 +3962,7 @@ def render_settings():
             key=f"settings_{key}",
         )
 
-    api_keys_tab, material_sources_tab, voice_test_tab = render_localized_tabs(["API Keys", "Fontes de Materiais", "Teste de Voz"])
+    api_keys_tab, google_accounts_tab, material_sources_tab, voice_test_tab = render_localized_tabs(["API Keys", "Contas Google", "Fontes de Materiais", "Teste de Voz"])
 
     with api_keys_tab:
         with st.container(border=True):
@@ -4066,8 +4097,11 @@ 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}")
-        with material_sources_tab:
-            render_material_source_api_keys(settings)
+    with google_accounts_tab:
+        render_google_accounts()
+
+    with material_sources_tab:
+        render_material_source_api_keys(settings)
 
     with voice_test_tab:
         st.subheader("Teste de Voz")
@@ -4531,7 +4565,6 @@ def main():
     ]
     settings_items = [
         ("MCP", ":material/hub:", "MCP"),
-        ("Contas Google", ":material/account_circle:", "Contas Google"),
         ("Notificações", ":material/notifications:", "Notificações"),
         ("Configuração API", ":material/settings:", "Configuração API"),
     ]
@@ -4589,7 +4622,8 @@ def main():
         "Blueprints": "Blueprints Youtube",
         "Configurações Técnicas": "Configuração API",
         "Models AI": "AI Influencers",
-        "Contas Google/YouTube — canais em lote": "Contas Google",
+        "Contas Google/YouTube — canais em lote": "Configuração API",
+        "Contas Google": "Configuração API",
     }
     all_children = [item for items in groups.values() for item in items]
     valid_targets = {item[0] for item in top_pages + all_children}

package/hermes_ui/languages.py

@@ -922,3 +922,109 @@ __all__ = [
     "language_label", "ui_language_menu_label", "language_locale", "language_option_codes", "language_option_labels",
     "ui_text", "video_language_label", "video_language_options",
 ]
+
+
+_MATERIAL_SOURCE_TRANSLATIONS: dict[str, dict[str, str]] = {
+    "pt": {
+        "Fontes de Materiais": "Fontes de Materiais",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.",
+        "Adicionar fonte de materiais": "Adicionar fonte de materiais",
+        "Provedor de materiais": "Provedor de materiais",
+        "Configurar Nova Fonte de Materiais": "Configurar Nova Fonte de Materiais",
+        "Fonte activa": "Fonte activa",
+        "Usar esta fonte na pipeline": "Usar esta fonte na pipeline",
+        "Esta fonte não usa API key.": "Esta fonte não usa API key.",
+    },
+    "en": {
+        "Fontes de Materiais": "Media Sources",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Configure each provider in an independent card. You can repeat the same provider to store multiple API keys; the selected source will be used by the pipeline.",
+        "Adicionar fonte de materiais": "Add media source",
+        "Provedor de materiais": "Media provider",
+        "Configurar Nova Fonte de Materiais": "Configure New Media Source",
+        "Fonte activa": "Source active",
+        "Usar esta fonte na pipeline": "Use this source in the pipeline",
+        "Esta fonte não usa API key.": "This source does not use an API key.",
+    },
+    "zh": {
+        "Fontes de Materiais": "素材来源",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "在独立卡片中配置每个提供商。可以重复同一提供商以保存多个 API 密钥；所选来源将由流水线使用。",
+        "Adicionar fonte de materiais": "添加素材来源",
+        "Provedor de materiais": "素材提供商",
+        "Configurar Nova Fonte de Materiais": "配置新的素材来源",
+        "Fonte activa": "来源已启用",
+        "Usar esta fonte na pipeline": "在流水线中使用此来源",
+        "Esta fonte não usa API key.": "此来源不使用 API 密钥。",
+    },
+    "de": {
+        "Fontes de Materiais": "Medienquellen",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Konfigurieren Sie jeden Anbieter in einer eigenen Karte. Derselbe Anbieter kann für mehrere API-Schlüssel wiederholt werden; die ausgewählte Quelle wird von der Pipeline verwendet.",
+        "Adicionar fonte de materiais": "Medienquelle hinzufügen",
+        "Provedor de materiais": "Medienanbieter",
+        "Configurar Nova Fonte de Materiais": "Neue Medienquelle konfigurieren",
+        "Fonte activa": "Quelle aktiv",
+        "Usar esta fonte na pipeline": "Diese Quelle in der Pipeline verwenden",
+        "Esta fonte não usa API key.": "Diese Quelle verwendet keinen API-Schlüssel.",
+    },
+    "vi": {
+        "Fontes de Materiais": "Nguồn phương tiện",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Định cấu hình từng nhà cung cấp trong một thẻ riêng. Có thể lặp lại cùng nhà cung cấp để lưu nhiều API key; nguồn được chọn sẽ được quy trình sử dụng.",
+        "Adicionar fonte de materiais": "Thêm nguồn phương tiện",
+        "Provedor de materiais": "Nhà cung cấp phương tiện",
+        "Configurar Nova Fonte de Materiais": "Định cấu hình nguồn phương tiện mới",
+        "Fonte activa": "Nguồn đang hoạt động",
+        "Usar esta fonte na pipeline": "Dùng nguồn này trong quy trình",
+        "Esta fonte não usa API key.": "Nguồn này không dùng API key.",
+    },
+    "tr": {
+        "Fontes de Materiais": "Medya kaynakları",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Her sağlayıcıyı bağımsız bir kartta yapılandırın. Birden fazla API anahtarı saklamak için aynı sağlayıcıyı tekrarlayabilirsiniz; seçilen kaynak akış tarafından kullanılacaktır.",
+        "Adicionar fonte de materiais": "Medya kaynağı ekle",
+        "Provedor de materiais": "Medya sağlayıcısı",
+        "Configurar Nova Fonte de Materiais": "Yeni medya kaynağını yapılandır",
+        "Fonte activa": "Kaynak etkin",
+        "Usar esta fonte na pipeline": "Bu kaynağı akışta kullan",
+        "Esta fonte não usa API key.": "Bu kaynak API anahtarı kullanmaz.",
+    },
+    "ru": {
+        "Fontes de Materiais": "Источники материалов",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Настройте каждого провайдера в отдельной карточке. Один и тот же провайдер можно повторить для хранения нескольких API-ключей; выбранный источник будет использоваться конвейером.",
+        "Adicionar fonte de materiais": "Добавить источник материалов",
+        "Provedor de materiais": "Провайдер материалов",
+        "Configurar Nova Fonte de Materiais": "Настроить новый источник материалов",
+        "Fonte activa": "Источник активен",
+        "Usar esta fonte na pipeline": "Использовать этот источник в конвейере",
+        "Esta fonte não usa API key.": "Этот источник не использует API-ключ.",
+    },
+    "es": {
+        "Fontes de Materiais": "Fuentes de medios",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Configura cada proveedor en una tarjeta independiente. Puedes repetir el mismo proveedor para guardar varias claves API; la fuente seleccionada será utilizada por el flujo.",
+        "Adicionar fonte de materiais": "Añadir fuente de medios",
+        "Provedor de materiais": "Proveedor de medios",
+        "Configurar Nova Fonte de Materiais": "Configurar nueva fuente de medios",
+        "Fonte activa": "Fuente activa",
+        "Usar esta fonte na pipeline": "Usar esta fuente en el flujo",
+        "Esta fonte não usa API key.": "Esta fuente no utiliza una clave API.",
+    },
+    "id": {
+        "Fontes de Materiais": "Sumber media",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Konfigurasikan setiap penyedia dalam kartu terpisah. Penyedia yang sama dapat diulang untuk menyimpan beberapa kunci API; sumber yang dipilih akan digunakan oleh pipeline.",
+        "Adicionar fonte de materiais": "Tambah sumber media",
+        "Provedor de materiais": "Penyedia media",
+        "Configurar Nova Fonte de Materiais": "Konfigurasikan Sumber Media Baru",
+        "Fonte activa": "Sumber aktif",
+        "Usar esta fonte na pipeline": "Gunakan sumber ini di pipeline",
+        "Esta fonte não usa API key.": "Sumber ini tidak menggunakan kunci API.",
+    },
+    "it": {
+        "Fontes de Materiais": "Fonti multimediali",
+        "Configure cada provedor num cartão independente. Pode repetir o mesmo provedor para guardar várias API keys; a fonte seleccionada será usada pela pipeline.": "Configura ogni provider in una scheda indipendente. Puoi ripetere lo stesso provider per conservare più API key; la fonte selezionata sarà usata dalla pipeline.",
+        "Adicionar fonte de materiais": "Aggiungi fonte multimediale",
+        "Provedor de materiais": "Provider multimediale",
+        "Configurar Nova Fonte de Materiais": "Configura nuova fonte multimediale",
+        "Fonte activa": "Fonte attiva",
+        "Usar esta fonte na pipeline": "Usa questa fonte nella pipeline",
+        "Esta fonte não usa API key.": "Questa fonte non usa una API key.",
+    },
+}
+for _language_code, _material_source_translation in _MATERIAL_SOURCE_TRANSLATIONS.items():
+    UI_TRANSLATIONS[_language_code].update(_material_source_translation)

package/hermes_ui/llm_providers.py

@@ -9,12 +9,11 @@ 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,
+    OpenAICompatibleAPIError,
     fetch_openai_compatible_models,
+    validate_openai_compatible_api_key,
 )
 
 
@@ -357,14 +356,6 @@ def apply_llm_cards_to_settings(
     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:
@@ -386,11 +377,12 @@ def test_llm_provider_card(card: Mapping[str, Any]) -> dict[str, Any]:
         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."}
+    model = str(normalized.get("model") or "").strip()
+    if not model:
+        return {"ok": False, "status": "error", "message": "Missing configuration — introduza o modelo antes do teste."}
     try:
-        models = fetch_openai_compatible_models(api_key, base_url)
-    except ModelDiscoveryError as exc:
+        validate_openai_compatible_api_key(api_key, base_url, model)
+    except OpenAICompatibleAPIError as exc:
         return {
             "ok": False,
             "status": "error",
@@ -401,7 +393,7 @@ def test_llm_provider_card(card: Mapping[str, Any]) -> dict[str, Any]:
     return {
         "ok": True,
         "status": "success",
-        "message": f"API OK — {_safe_url(base_url)} respondeu com {len(models)} modelo(s).",
+        "message": "API Key OK",
     }
 
 

package/hermes_ui/material_sources.py

@@ -1,8 +1,12 @@
 from __future__ import annotations
 
 from typing import Any
+from uuid import uuid4
 
 
+MATERIAL_CARDS_KEY = "material_source_cards"
+MATERIAL_ACTIVE_CARD_KEY = "material_active_card_id"
+
 MATERIAL_SOURCE_CATALOG: tuple[dict[str, str], ...] = (
     {"code": "pexels", "label": "Pexels", "description": "Banco de vídeos e imagens para materiais da pipeline.", "legacy_key": "pexels_api_keys"},
     {"code": "pixabay", "label": "Pixabay", "description": "Banco de vídeos e imagens para materiais da pipeline.", "legacy_key": "pixabay_api_keys"},
@@ -13,6 +17,9 @@ MATERIAL_SOURCE_CATALOG: tuple[dict[str, str], ...] = (
 )
 
 
+_SOURCE_BY_CODE = {item["code"]: item for item in MATERIAL_SOURCE_CATALOG}
+
+
 def _as_key_list(value: Any) -> list[str]:
     if isinstance(value, list):
         values = value
@@ -32,12 +39,124 @@ def material_source_catalog() -> list[dict[str, str]]:
     return [dict(item) for item in MATERIAL_SOURCE_CATALOG]
 
 
-def material_api_keys(settings: dict[str, Any], source: str) -> list[str]:
+def material_source_definition(source: Any) -> dict[str, str] | None:
+    return _SOURCE_BY_CODE.get(str(source or "").strip().lower())
+
+
+def _new_card(provider: str, api_key: str = "", *, card_id: str | None = None) -> dict[str, Any]:
+    return {
+        "id": card_id or f"material-{provider}-{uuid4().hex[:8]}",
+        "provider": provider,
+        "api_key": str(api_key or "").strip(),
+        "enabled": True,
+    }
+
+
+def normalize_material_card(card: Any, index: int = 0) -> dict[str, Any]:
+    raw = card if isinstance(card, dict) else {}
+    provider = str(raw.get("provider") or raw.get("source") or "pexels").strip().lower()
+    if provider not in _SOURCE_BY_CODE and provider != "local":
+        provider = "pexels"
+    card_id = str(raw.get("id") or f"material-{provider}-{index}").strip()
+    return {
+        "id": card_id or f"material-{provider}-{index}",
+        "provider": provider,
+        "api_key": str(raw.get("api_key") or raw.get("key") or "").strip() if provider != "local" else "",
+        "enabled": bool(raw.get("enabled", True)),
+    }
+
+
+def _cards_key_mapping(cards: list[dict[str, Any]]) -> dict[str, list[str]]:
+    mapping = {item["code"]: [] for item in MATERIAL_SOURCE_CATALOG}
+    for index, raw_card in enumerate(cards):
+        card = normalize_material_card(raw_card, index)
+        provider = card["provider"]
+        api_key = str(card.get("api_key") or "").strip()
+        if card.get("enabled", True) and provider in mapping and api_key and api_key not in mapping[provider]:
+            mapping[provider].append(api_key)
+    return mapping
+
+
+def _sync_legacy_material_keys(settings: dict[str, Any], mapping: dict[str, list[str]]) -> None:
+    settings["material_api_keys"] = mapping
+    for item in MATERIAL_SOURCE_CATALOG:
+        settings[item["legacy_key"]] = list(mapping.get(item["code"], []))
+
+
+def ensure_material_source_cards(settings: dict[str, Any]) -> tuple[dict[str, Any], bool]:
+    """Migrate legacy per-source key lists into stable independent material cards."""
+    original = settings.get(MATERIAL_CARDS_KEY)
+    changed = False
+    if isinstance(original, list) and original:
+        cards = [normalize_material_card(item, index) for index, item in enumerate(original)]
+        changed = cards != original
+    else:
+        cards: list[dict[str, Any]] = []
+        for item in MATERIAL_SOURCE_CATALOG:
+            for key in material_api_keys(settings, item["code"], _ignore_cards=True):
+                cards.append(_new_card(item["code"], key, card_id=f"material-{item['code']}-{len(cards)}"))
+        if not cards:
+            selected = selected_material_source(settings)
+            cards.append(_new_card(selected if selected in _SOURCE_BY_CODE else "pexels", card_id="material-default-0"))
+        changed = True
+
+    settings[MATERIAL_CARDS_KEY] = cards
+    active_id = str(settings.get(MATERIAL_ACTIVE_CARD_KEY) or "").strip()
+    valid_ids = {str(card["id"]) for card in cards}
+    if active_id not in valid_ids:
+        selected_source = selected_material_source(settings)
+        matching = next((card for card in cards if card["provider"] == selected_source), None)
+        active_id = str(matching["id"]) if matching else str(cards[0]["id"])
+        settings[MATERIAL_ACTIVE_CARD_KEY] = active_id
+        changed = True
+
+    mapping = _cards_key_mapping(cards)
+    if settings.get("material_api_keys") != mapping:
+        _sync_legacy_material_keys(settings, mapping)
+        changed = True
+    return settings, changed
+
+
+def ensure_material_source_cards_for_ui(settings: dict[str, Any]) -> list[dict[str, Any]]:
+    migrated, _ = ensure_material_source_cards(settings)
+    return [dict(item) for item in migrated.get(MATERIAL_CARDS_KEY, [])]
+
+
+def new_material_card(provider: str, *, card_id: str | None = None) -> dict[str, Any]:
+    code = str(provider or "").strip().lower()
+    if code not in _SOURCE_BY_CODE:
+        raise ValueError("Fonte de materiais inválida.")
+    return _new_card(code, card_id=card_id)
+
+
+def apply_material_source_cards_to_settings(
+    settings: dict[str, Any],
+    cards: list[dict[str, Any]],
+    active_card_id: str = "",
+) -> dict[str, Any]:
+    normalized_cards = [normalize_material_card(item, index) for index, item in enumerate(cards)]
+    if not normalized_cards:
+        normalized_cards = [_new_card("pexels", card_id="material-default-0")]
+    settings[MATERIAL_CARDS_KEY] = normalized_cards
+    selected_card = next((card for card in normalized_cards if str(card["id"]) == str(active_card_id)), None)
+    if selected_card is None:
+        selected_card = next((card for card in normalized_cards if card.get("enabled", True)), normalized_cards[0])
+    settings[MATERIAL_ACTIVE_CARD_KEY] = str(selected_card["id"])
+    settings["video_source"] = str(selected_card["provider"])
+    _sync_legacy_material_keys(settings, _cards_key_mapping(normalized_cards))
+    return settings
+
+
+def material_api_keys(settings: dict[str, Any], source: str, _ignore_cards: bool = False) -> list[str]:
     code = str(source or "").strip().lower()
+    if not _ignore_cards:
+        cards = settings.get(MATERIAL_CARDS_KEY)
+        if isinstance(cards, list) and cards:
+            return _cards_key_mapping(cards).get(code, [])
     saved = settings.get("material_api_keys", {})
     if isinstance(saved, dict) and code in saved:
         return _as_key_list(saved.get(code))
-    legacy_key = next((item["legacy_key"] for item in MATERIAL_SOURCE_CATALOG if item["code"] == code), f"{code}_api_keys")
+    legacy_key = _SOURCE_BY_CODE.get(code, {}).get("legacy_key", f"{code}_api_keys")
     return _as_key_list(settings.get(legacy_key, ""))
 
 
@@ -47,18 +166,16 @@ def all_material_api_keys(settings: dict[str, Any]) -> dict[str, list[str]]:
 
 def update_material_api_keys(settings: dict[str, Any], source: str, keys: list[str]) -> dict[str, Any]:
     code = str(source or "").strip().lower()
-    if code not in {item["code"] for item in MATERIAL_SOURCE_CATALOG}:
+    if code not in _SOURCE_BY_CODE:
         raise ValueError("Fonte de materiais inválida.")
     cleaned = _as_key_list(keys)
     mapping = all_material_api_keys(settings)
     mapping[code] = cleaned
-    settings["material_api_keys"] = mapping
-    source_entry = next(item for item in MATERIAL_SOURCE_CATALOG if item["code"] == code)
-    settings[source_entry["legacy_key"]] = cleaned
+    _sync_legacy_material_keys(settings, mapping)
     return settings
 
 
 def selected_material_source(settings: dict[str, Any]) -> str:
     source = str(settings.get("video_source") or "pexels").strip().lower()
-    valid = {item["code"] for item in MATERIAL_SOURCE_CATALOG} | {"local"}
+    valid = set(_SOURCE_BY_CODE) | {"local"}
     return source if source in valid else "pexels"

package/integrations/openai_model_discovery.py

@@ -16,6 +16,10 @@ class ModelDiscoveryError(ValueError):
     """Raised when an OpenAI-compatible model list cannot be loaded safely."""
 
 
+class OpenAICompatibleAPIError(ValueError):
+    """Raised when an authenticated OpenAI-compatible API check fails."""
+
+
 def models_endpoint(base_url: str) -> str:
     """Return the ``/models`` endpoint for an OpenAI-compatible base URL."""
     value = str(base_url or "").strip().rstrip("/")
@@ -26,6 +30,56 @@ def models_endpoint(base_url: str) -> str:
     return f"{value}/models"
 
 
+def chat_completions_endpoint(base_url: str) -> str:
+    """Return the Chat Completions endpoint for an OpenAI-compatible base URL."""
+    value = str(base_url or "").strip().rstrip("/")
+    if not value:
+        raise OpenAICompatibleAPIError("Informe a Base URL antes do teste.")
+    if value.endswith("/chat/completions"):
+        return value
+    return f"{value}/chat/completions"
+
+
+def validate_openai_compatible_api_key(
+    api_key: str,
+    base_url: str,
+    model: str,
+    *,
+    timeout: float = DEFAULT_TIMEOUT_SECONDS,
+) -> None:
+    """Validate credentials with one minimal authenticated Chat Completions call."""
+    token = str(api_key or "").strip()
+    model_id = str(model or "").strip()
+    if not token:
+        raise OpenAICompatibleAPIError("Informe a API key antes do teste.")
+    if not model_id:
+        raise OpenAICompatibleAPIError("Informe o modelo antes do teste.")
+
+    endpoint = chat_completions_endpoint(base_url)
+    headers = {
+        "Accept": "application/json",
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json",
+    }
+    payload = {
+        "model": model_id,
+        "messages": [{"role": "user", "content": "Responda apenas OK."}],
+        "max_tokens": 1,
+        "temperature": 0,
+    }
+    try:
+        response = requests.post(endpoint, headers=headers, json=payload, timeout=timeout)
+    except requests.RequestException as exc:
+        raise OpenAICompatibleAPIError(f"Não foi possível testar {endpoint}: {exc}") from exc
+
+    if response.status_code >= 400:
+        if response.status_code in (401, 403):
+            raise OpenAICompatibleAPIError(
+                f"O endpoint recusou a API key (HTTP {response.status_code}). Verifique a API key."
+            )
+        raise OpenAICompatibleAPIError(f"O endpoint de teste devolveu HTTP {response.status_code}.")
+
+
 def normalize_model_ids(payload: Any) -> list[str]:
     """Extract unique model IDs from the standard OpenAI response shape."""
     if isinstance(payload, dict):

package/package.json

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