248 lines
8.8 KiB
TypeScript
248 lines
8.8 KiB
TypeScript
import type { IncomingMessage, ServerResponse } from "node:http";
|
|
import { EdgeTTS } from "node-edge-tts";
|
|
import { speechVoiceIdSchema, type SpeechVoice } from "../src/shared/tts/voices";
|
|
import { createEdgeTtsVoiceCatalog } from "./edge-tts-voices";
|
|
|
|
const EDGE_TTS_PATH = "/api/tts/edge";
|
|
const EDGE_TTS_VOICES_PATH = `${EDGE_TTS_PATH}/voices`;
|
|
const DEFAULT_VOICE = "zh-CN-XiaoxiaoNeural";
|
|
const MAX_REQUEST_BYTES = 8 * 1024;
|
|
const MAX_TEXT_LENGTH = 520;
|
|
const MAX_AUDIO_BYTES = 5 * 1024 * 1024;
|
|
const DEFAULT_MAX_CONCURRENT = 8;
|
|
const DEFAULT_RATE_LIMIT = 60;
|
|
const DEFAULT_RATE_WINDOW_MS = 60_000;
|
|
const DEFAULT_TIMEOUT_MS = 30_000;
|
|
|
|
interface EdgeTtsPayload {
|
|
text?: unknown;
|
|
voice?: unknown;
|
|
}
|
|
|
|
interface RateBucket {
|
|
count: number;
|
|
startedAt: number;
|
|
}
|
|
|
|
export type EdgeTtsSynthesizer = (text: string, voice: string) => Promise<Uint8Array>;
|
|
|
|
export type EdgeTtsMiddlewareOptions = {
|
|
defaultVoice?: string;
|
|
maxConcurrent?: number;
|
|
maxRequestsPerWindow?: number;
|
|
now?: () => number;
|
|
rateWindowMs?: number;
|
|
synthesize?: EdgeTtsSynthesizer;
|
|
timeoutMs?: number;
|
|
trustProxy?: boolean;
|
|
listVoices?: () => Promise<SpeechVoice[]>;
|
|
};
|
|
|
|
function sendJson(response: ServerResponse, status: number, message: string) {
|
|
response.statusCode = status;
|
|
response.setHeader("Content-Type", "application/json; charset=utf-8");
|
|
response.setHeader("Cache-Control", "no-store");
|
|
response.end(JSON.stringify({ error: message }));
|
|
}
|
|
|
|
async function readJson(request: IncomingMessage): Promise<EdgeTtsPayload> {
|
|
const chunks: Buffer[] = [];
|
|
let byteLength = 0;
|
|
|
|
for await (const chunk of request) {
|
|
const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
|
|
byteLength += buffer.byteLength;
|
|
if (byteLength > MAX_REQUEST_BYTES) {
|
|
throw new RangeError("请求内容过大");
|
|
}
|
|
chunks.push(buffer);
|
|
}
|
|
|
|
const payload = JSON.parse(Buffer.concat(chunks).toString("utf8")) as unknown;
|
|
if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
|
|
throw new SyntaxError("请求内容必须是 JSON 对象");
|
|
}
|
|
return payload as EdgeTtsPayload;
|
|
}
|
|
|
|
function isLoopback(address: string | undefined) {
|
|
return address === "127.0.0.1" || address === "::1" || address === "::ffff:127.0.0.1";
|
|
}
|
|
|
|
function getClientKey(request: IncomingMessage, trustProxy: boolean) {
|
|
const remoteAddress = request.socket.remoteAddress;
|
|
if (trustProxy && isLoopback(remoteAddress)) {
|
|
const forwardedFor = request.headers["x-forwarded-for"];
|
|
const firstAddress = Array.isArray(forwardedFor) ? forwardedFor[0] : forwardedFor?.split(",", 1)[0];
|
|
if (firstAddress?.trim()) return firstAddress.trim();
|
|
}
|
|
return remoteAddress || "unknown";
|
|
}
|
|
|
|
export async function synthesizeEdgeSpeech(text: string, voice: string): Promise<Uint8Array> {
|
|
const communicate = new EdgeTTS({ voice, timeout: DEFAULT_TIMEOUT_MS });
|
|
const chunks: Uint8Array[] = [];
|
|
let byteLength = 0;
|
|
|
|
for await (const chunk of communicate.streamAudio(text)) {
|
|
if (!Buffer.isBuffer(chunk)) continue;
|
|
chunks.push(chunk);
|
|
byteLength += chunk.byteLength;
|
|
if (byteLength > MAX_AUDIO_BYTES) throw new Error("语音服务返回的音频过大");
|
|
}
|
|
|
|
if (!byteLength) throw new Error("语音服务返回了空音频");
|
|
|
|
const audio = new Uint8Array(byteLength);
|
|
let offset = 0;
|
|
for (const chunk of chunks) {
|
|
audio.set(chunk, offset);
|
|
offset += chunk.byteLength;
|
|
}
|
|
return audio;
|
|
}
|
|
|
|
export function createEdgeTtsMiddleware(options: EdgeTtsMiddlewareOptions = {}) {
|
|
const synthesize = options.synthesize ?? synthesizeEdgeSpeech;
|
|
const configuredVoice = options.defaultVoice ?? process.env.EDGE_TTS_VOICE ?? DEFAULT_VOICE;
|
|
const defaultVoice = speechVoiceIdSchema.safeParse(configuredVoice).success ? configuredVoice : DEFAULT_VOICE;
|
|
const maxConcurrent = options.maxConcurrent ?? DEFAULT_MAX_CONCURRENT;
|
|
const maxRequestsPerWindow = options.maxRequestsPerWindow ?? DEFAULT_RATE_LIMIT;
|
|
const rateWindowMs = options.rateWindowMs ?? DEFAULT_RATE_WINDOW_MS;
|
|
const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
|
|
const trustProxy = options.trustProxy ?? false;
|
|
const now = options.now ?? Date.now;
|
|
const listVoices = createEdgeTtsVoiceCatalog(options.listVoices, now);
|
|
const rateBuckets = new Map<string, RateBucket>();
|
|
let activeRequests = 0;
|
|
|
|
return async (request: IncomingMessage, response: ServerResponse, next?: () => void) => {
|
|
const path = request.url?.split("?", 1)[0];
|
|
const voicesRequest = path === EDGE_TTS_VOICES_PATH;
|
|
if (path !== EDGE_TTS_PATH && !voicesRequest) {
|
|
next?.();
|
|
return;
|
|
}
|
|
const method = voicesRequest ? "GET" : "POST";
|
|
if (request.method !== method) {
|
|
response.setHeader("Allow", method);
|
|
sendJson(response, 405, `仅支持 ${method} 请求`);
|
|
return;
|
|
}
|
|
if (!voicesRequest && !request.headers["content-type"]?.toLowerCase().startsWith("application/json")) {
|
|
sendJson(response, 415, "请求必须使用 application/json");
|
|
return;
|
|
}
|
|
|
|
const currentTime = now();
|
|
const clientKey = getClientKey(request, trustProxy);
|
|
const existingBucket = rateBuckets.get(clientKey);
|
|
const bucket = !existingBucket || currentTime - existingBucket.startedAt >= rateWindowMs
|
|
? { count: 0, startedAt: currentTime }
|
|
: existingBucket;
|
|
bucket.count += 1;
|
|
rateBuckets.set(clientKey, bucket);
|
|
if (rateBuckets.size > 1_024) {
|
|
for (const [key, value] of rateBuckets) {
|
|
if (currentTime - value.startedAt >= rateWindowMs) rateBuckets.delete(key);
|
|
}
|
|
}
|
|
if (bucket.count > maxRequestsPerWindow) {
|
|
response.setHeader("Retry-After", String(Math.max(1, Math.ceil(rateWindowMs / 1_000))));
|
|
sendJson(response, 429, "语音请求过于频繁，请稍后重试");
|
|
return;
|
|
}
|
|
|
|
if (voicesRequest) {
|
|
try {
|
|
const voices = await listVoices();
|
|
response.statusCode = 200;
|
|
response.setHeader("Content-Type", "application/json; charset=utf-8");
|
|
response.setHeader("Cache-Control", "no-store");
|
|
response.end(JSON.stringify({ voices, defaultVoice }));
|
|
} catch {
|
|
sendJson(response, 503, "音色列表暂时不可用，请稍后重试");
|
|
}
|
|
return;
|
|
}
|
|
|
|
let payload: EdgeTtsPayload;
|
|
try {
|
|
payload = await readJson(request);
|
|
} catch (error) {
|
|
sendJson(response, error instanceof RangeError ? 413 : 400, "请求内容不是有效 JSON");
|
|
return;
|
|
}
|
|
|
|
const text = typeof payload.text === "string" ? payload.text.trim() : "";
|
|
if (!text) {
|
|
sendJson(response, 400, "缺少待朗读文本");
|
|
return;
|
|
}
|
|
if (text.length > MAX_TEXT_LENGTH) {
|
|
sendJson(response, 413, `单次文本不能超过 ${MAX_TEXT_LENGTH} 字`);
|
|
return;
|
|
}
|
|
let voice = defaultVoice;
|
|
if (Object.prototype.hasOwnProperty.call(payload, "voice")) {
|
|
const selectedVoice = speechVoiceIdSchema.safeParse(payload.voice);
|
|
if (!selectedVoice.success) {
|
|
sendJson(response, 400, "请选择有效音色");
|
|
return;
|
|
}
|
|
try {
|
|
if (!(await listVoices()).some((item) => item.id === selectedVoice.data)) {
|
|
sendJson(response, 400, "所选音色不可用，请重新选择");
|
|
return;
|
|
}
|
|
voice = selectedVoice.data;
|
|
} catch {
|
|
sendJson(response, 503, "无法确认音色是否可用，请稍后重试");
|
|
return;
|
|
}
|
|
}
|
|
if (activeRequests >= maxConcurrent) {
|
|
response.setHeader("Retry-After", "1");
|
|
sendJson(response, 429, "语音服务繁忙，请稍后重试");
|
|
return;
|
|
}
|
|
|
|
activeRequests += 1;
|
|
const synthesisTask = Promise.resolve().then(() => synthesize(text, voice));
|
|
void synthesisTask.finally(() => {
|
|
activeRequests -= 1;
|
|
}).catch(() => undefined);
|
|
|
|
let timeout: ReturnType<typeof setTimeout> | undefined;
|
|
try {
|
|
const audio = await Promise.race([
|
|
synthesisTask,
|
|
new Promise<never>((_, reject) => {
|
|
timeout = setTimeout(() => reject(new DOMException("语音服务响应超时", "TimeoutError")), timeoutMs);
|
|
})
|
|
]);
|
|
if (!audio.byteLength) {
|
|
sendJson(response, 502, "语音服务返回了空音频");
|
|
return;
|
|
}
|
|
if (audio.byteLength > MAX_AUDIO_BYTES) {
|
|
sendJson(response, 502, "语音服务返回的音频过大");
|
|
return;
|
|
}
|
|
response.statusCode = 200;
|
|
response.setHeader("Content-Type", "audio/mpeg");
|
|
response.setHeader("Cache-Control", "no-store");
|
|
response.end(Buffer.from(audio));
|
|
} catch (error) {
|
|
if (error instanceof DOMException && error.name === "TimeoutError") {
|
|
sendJson(response, 504, "语音服务响应超时");
|
|
return;
|
|
}
|
|
console.error("[Agent TTS] 语音生成失败", error);
|
|
sendJson(response, 502, "语音生成失败");
|
|
} finally {
|
|
if (timeout) clearTimeout(timeout);
|
|
}
|
|
};
|
|
}
|