System
+
+ {/* Media Providers accordion */}
+
+ {mediaOpen && (
+
+ {MEDIA_PROVIDER_KINDS.filter((k) => VISIBLE_MEDIA_KINDS.includes(k.id)).map((kind) => (
+
+ {kind.icon}
+ {kind.label}
+
+ ))}
+
+ )}
+
{systemItems.map((item) => (
{
export function getProvidersByKind(kind) {
return Object.values(AI_PROVIDERS).filter((p) => {
const kinds = p.serviceKinds ?? ["llm"];
- return kinds.includes(kind);
+ if (!kinds.includes(kind)) return false;
+ if (p.hidden) return false; // globally hidden
+ if (p.hiddenKinds?.includes(kind)) return false; // hidden for specific kind
+ return true;
});
}
diff --git a/src/shared/constants/ttsProviders.js b/src/shared/constants/ttsProviders.js
new file mode 100644
index 00000000..0117febb
--- /dev/null
+++ b/src/shared/constants/ttsProviders.js
@@ -0,0 +1,41 @@
+/**
+ * TTS Provider Configuration
+ * Centralized config for TTS provider UI behavior
+ */
+export const TTS_PROVIDER_CONFIG = {
+ "google-tts": {
+ hasLanguageDropdown: true,
+ hasModelSelector: false,
+ hasBrowseButton: false,
+ voiceSource: "hardcoded", // from providerModels
+ },
+ "openai": {
+ hasLanguageDropdown: false,
+ hasModelSelector: true,
+ hasBrowseButton: false,
+ voiceSource: "hardcoded", // from providerModels
+ modelKey: "openai-tts-models",
+ voiceKey: "openai-tts-voices",
+ },
+ "elevenlabs": {
+ hasLanguageDropdown: false,
+ hasModelSelector: true,
+ hasBrowseButton: true,
+ hasVoiceIdInput: true, // allow manual voice id entry
+ voiceSource: "api-language", // grouped by language from backend
+ modelKey: "elevenlabs-tts-models",
+ apiEndpoint: "/api/media-providers/tts/elevenlabs/voices",
+ },
+ "edge-tts": {
+ hasLanguageDropdown: false,
+ hasModelSelector: false,
+ hasBrowseButton: true,
+ voiceSource: "api-language", // from API with language picker
+ },
+ "local-device": {
+ hasLanguageDropdown: false,
+ hasModelSelector: false,
+ hasBrowseButton: true,
+ voiceSource: "api-language", // from API with language picker
+ },
+};
diff --git a/src/sse/handlers/tts.js b/src/sse/handlers/tts.js
new file mode 100644
index 00000000..18ac5bee
--- /dev/null
+++ b/src/sse/handlers/tts.js
@@ -0,0 +1,85 @@
+import {
+ extractApiKey, isValidApiKey,
+ getProviderCredentials, markAccountUnavailable,
+} from "../services/auth.js";
+import { getSettings } from "@/lib/localDb";
+import { getModelInfo } from "../services/model.js";
+import { handleTtsCore } from "open-sse/handlers/ttsCore.js";
+import { errorResponse, unavailableResponse } from "open-sse/utils/error.js";
+import { HTTP_STATUS } from "open-sse/config/runtimeConfig.js";
+import * as log from "../utils/logger.js";
+
+// Providers that require stored credentials (not noAuth)
+const CREDENTIALED_PROVIDERS = new Set(["openai", "elevenlabs"]);
+
+export async function handleTts(request) {
+ let body;
+ try {
+ body = await request.json();
+ } catch {
+ return errorResponse(HTTP_STATUS.BAD_REQUEST, "Invalid JSON body");
+ }
+
+ const url = new URL(request.url);
+ const modelStr = body.model;
+ const responseFormat = url.searchParams.get("response_format") || "mp3"; // mp3 (default) | json
+ log.request("POST", `${url.pathname} | ${modelStr} | format=${responseFormat}`);
+
+ const settings = await getSettings();
+ if (settings.requireApiKey) {
+ const apiKey = extractApiKey(request);
+ if (!apiKey) return errorResponse(HTTP_STATUS.UNAUTHORIZED, "Missing API key");
+ const valid = await isValidApiKey(apiKey);
+ if (!valid) return errorResponse(HTTP_STATUS.UNAUTHORIZED, "Invalid API key");
+ }
+
+ if (!modelStr) return errorResponse(HTTP_STATUS.BAD_REQUEST, "Missing model");
+ if (!body.input) return errorResponse(HTTP_STATUS.BAD_REQUEST, "Missing required field: input");
+
+ const modelInfo = await getModelInfo(modelStr);
+ if (!modelInfo.provider) return errorResponse(HTTP_STATUS.BAD_REQUEST, "Invalid model format");
+
+ const { provider, model } = modelInfo;
+ log.info("ROUTING", `Provider: ${provider}, Voice: ${model}`);
+
+ // noAuth providers — no credential needed
+ if (!CREDENTIALED_PROVIDERS.has(provider)) {
+ const result = await handleTtsCore({ provider, model, input: body.input, responseFormat });
+ if (result.success) return result.response;
+ return errorResponse(result.status || HTTP_STATUS.BAD_GATEWAY, result.error || "TTS failed");
+ }
+
+ // Credentialed providers — fallback loop (same pattern as embeddings)
+ const excludeConnectionIds = new Set();
+ let lastError = null;
+ let lastStatus = null;
+
+ while (true) {
+ const credentials = await getProviderCredentials(provider, excludeConnectionIds, model);
+
+ if (!credentials || credentials.allRateLimited) {
+ if (credentials?.allRateLimited) {
+ const msg = lastError || credentials.lastError || "Unavailable";
+ const status = lastStatus || Number(credentials.lastErrorCode) || HTTP_STATUS.SERVICE_UNAVAILABLE;
+ return unavailableResponse(status, `[${provider}/${model}] ${msg}`, credentials.retryAfter, credentials.retryAfterHuman);
+ }
+ if (excludeConnectionIds.size === 0) return errorResponse(HTTP_STATUS.BAD_REQUEST, `No credentials for provider: ${provider}`);
+ return errorResponse(lastStatus || HTTP_STATUS.SERVICE_UNAVAILABLE, lastError || "All accounts unavailable");
+ }
+
+ log.info("AUTH", `\x1b[32mUsing ${provider} account: ${credentials.connectionName}\x1b[0m`);
+
+ const result = await handleTtsCore({ provider, model, input: body.input, credentials, responseFormat });
+
+ if (result.success) return result.response;
+
+ const { shouldFallback } = await markAccountUnavailable(credentials.connectionId, result.status, result.error, provider, model);
+ if (shouldFallback) {
+ excludeConnectionIds.add(credentials.connectionId);
+ lastError = result.error;
+ lastStatus = result.status;
+ continue;
+ }
+ return result.response || errorResponse(result.status, result.error);
+ }
+}