Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🧯 fix: Close Abandoned Download and Speech Streams and Cap Speech Input (#17270)
Marco Beretta698ee25fea6a
diff --git a/api/server/routes/files/files.js b/api/server/routes/files/files.jsindex 8e90bd15fc..07e402092b 100644--- a/api/server/routes/files/files.js+++ b/api/server/routes/files/files.js@@ -23,6 +23,7 @@ const {checkToolResourceUploadPermission,resolveAssistantToolPermissions,resolveDownloadPath,+ pipeToResponse,} = require('@librechat/api');const {isUUID,@@ -438,7 +439,9 @@ router.get('/code/download/:session_id/:fileId', async (req, res) => {res.setHeader('Content-Type', 'application/octet-stream');res.setHeader('X-Content-Type-Options', 'nosniff');res.setHeader('Cache-Control', 'private, no-store');- response.data.pipe(res);+ pipeToResponse(response.data, res, (error) =>+ logger.error('[CODE DOWNLOAD] Stream failed', getSafeErrorMetadata(error)),+ );} catch (error) {/* `logAxiosError` redacts buffer/stream response bodies — without* it, a stream-typed axios failure dumps the entire `Readable`'sdiff --git a/api/server/services/Files/Audio/TTSService.js b/api/server/services/Files/Audio/TTSService.jsindex 99b3cdb428..8f73e002a6 100644--- a/api/server/services/Files/Audio/TTSService.js+++ b/api/server/services/Files/Audio/TTSService.js@@ -6,6 +6,9 @@ const {applyAxiosProxyConfig,resolveConfigSecret,applySSRFSafeAgentIfDirect,+ pipeSegment,+ pipeToResponse,+ capSpeechInput,} = require('@librechat/api');const {TTSProviders,@@ -295,10 +298,6 @@ class TTSService {async processTextToSpeech(req, res) {const { input, voice: requestVoice } = req.body;- if (!input) {- return res.status(400).send('Missing text in request body');- }-const appConfig =req.config ??(await getAppConfig({@@ -306,6 +305,10 @@ class TTSService {userId: req.user?.id,tenantId: req.user?.tenantId,}));+ const text = capSpeechInput(input, appConfig?.speech?.tts);+ if (!text) {+ return res.status(400).send('Missing text in request body');+ }try {res.setHeader('Content-Type', 'audio/mpeg');const provider = this.getProvider(appConfig);@@ -313,18 +316,20 @@ class TTSService {const allowedAddresses = appConfig?.speech?.tts?.allowedAddresses;const voice = await this.getVoice(ttsSchema, requestVoice);- if (input.length < 4096) {+ if (text.length < 4096) {const response = await this.ttsRequest(provider,ttsSchema,- { input, voice },+ { input: text, voice },allowedAddresses,);- response.data.pipe(res);+ pipeToResponse(response.data, res, (error) =>+ logAxiosError({ message: '[TTS] Audio stream failed:', error }),+ );return;}- const textChunks = splitTextIntoChunks(input, 1000);+ const textChunks = splitTextIntoChunks(text, 1000);for (const chunk of textChunks) {try {@@ -340,10 +345,7 @@ class TTSService {);logger.debug(`[textToSpeech] user: ${req?.user?.id} | writing audio stream`);- await new Promise((resolve) => {- response.data.pipe(res, { end: chunk.isFinished });- response.data.on('end', resolve);- });+ await pipeSegment(response.data, res, { end: chunk.isFinished });if (chunk.isFinished) {break;@@ -399,7 +401,11 @@ class TTSService {shouldContinue = false;});- const processChunks = createChunkProcessor(req.user.id, req.body.messageId);+ const processChunks = createChunkProcessor(+ req.user.id,+ req.body.messageId,+ appConfig?.speech?.tts?.maxInputChars,+ );try {while (shouldContinue) {@@ -432,10 +438,7 @@ class TTSService {}logger.debug(`[streamAudio] user: ${req?.user?.id} | writing audio stream`);- await new Promise((resolve) => {- response.data.pipe(res, { end: update.isFinished });- response.data.on('end', resolve);- });+ await pipeSegment(response.data, res, { end: update.isFinished });if (update.isFinished) {shouldContinue = false;diff --git a/api/server/services/Files/Audio/TTSService.spec.js b/api/server/services/Files/Audio/TTSService.spec.jsindex 8273d8b4e5..efe0d84591 100644--- a/api/server/services/Files/Audio/TTSService.spec.js+++ b/api/server/services/Files/Audio/TTSService.spec.js@@ -5,8 +5,13 @@ jest.mock('@librechat/api', () => ({logAxiosError: jest.fn(),applyAxiosProxyConfig: jest.fn(),resolveConfigSecret: jest.fn(),+ capSpeechInput: jest.requireActual('@librechat/api').capSpeechInput,+ pipeSegment: jest.fn(),+ pipeToResponse: jest.fn(),}));jest.mock('librechat-data-provider', () => ({+ /** Real constants: `validateTTSInput` comes from the built `@librechat/api`, which reads them. */+ ...jest.requireActual('librechat-data-provider'),extractEnvVariable: jest.fn((value) => value),/* Real selection logic: these tests are about which provider a schema resolves to. */listConfiguredSpeechProviders:@@ -105,3 +110,44 @@ describe('TTSService getProvider detection', () => {).rejects.toThrow('Multiple providers are set');});});++describe('TTSService input cap', () => {+ it('sends a provider only the text up to the configured cap', async () => {+ const service = new TTSService();+ jest.spyOn(service, 'getVoice').mockResolvedValue('alloy');+ const ttsRequest = jest.spyOn(service, 'ttsRequest').mockResolvedValue({ data: {} });+ const res = { status: jest.fn().mockReturnThis(), send: jest.fn(), setHeader: jest.fn() };++ await service.processTextToSpeech(+ {+ body: { input: 'a'.repeat(11) },+ config: {+ speech: { tts: { maxInputChars: 10, openai: { apiKey: 'sk', model: 'tts-1' } } },+ },+ },+ res,+ );++ expect(ttsRequest).toHaveBeenCalledTimes(1);+ expect(ttsRequest.mock.calls[0][2]).toEqual({ input: 'a'.repeat(10), voice: 'alloy' });+ expect(res.status).not.toHaveBeenCalled();+ });++ it('refuses a non-text body before calling any provider', async () => {+ const service = new TTSService();+ const ttsRequest = jest.spyOn(service, 'ttsRequest');+ const res = { status: jest.fn().mockReturnThis(), send: jest.fn(), setHeader: jest.fn() };++ await service.processTextToSpeech(+ {+ body: { input: ['a'.repeat(30_000)] },+ config: { speech: { tts: { openai: { apiKey: 'sk', model: 'tts-1' } } } },+ },+ res,+ );++ expect(res.status).toHaveBeenCalledWith(400);+ expect(res.send).toHaveBeenCalledWith('Missing text in request body');+ expect(ttsRequest).not.toHaveBeenCalled();+ });+});diff --git a/api/server/services/Files/Audio/streamAudio.js b/api/server/services/Files/Audio/streamAudio.jsindex 8f674261f8..8376e5817f 100644--- a/api/server/services/Files/Audio/streamAudio.js+++ b/api/server/services/Files/Audio/streamAudio.js@@ -50,12 +50,13 @@ function getRandomVoiceId(voiceIds) {* @param {string} messageId* @returns {() => Promise<{ text: string, isFinished: boolean }[] | string>}*/-function createChunkProcessor(user, messageId) {+function createChunkProcessor(user, messageId, maxInputChars) {return createSpeechChunkProcessor({user,messageId,cache: getLogStores(CacheKeys.MESSAGES),getMessage,+ maxInputChars,});}diff --git a/e2e/setup/fake-code-server.js b/e2e/setup/fake-code-server.jsindex d441ac6fe1..428aa859e2 100644--- a/e2e/setup/fake-code-server.js+++ b/e2e/setup/fake-code-server.js@@ -226,6 +226,12 @@ async function handleExec(req, res) {sendJson(res, 200, { stdout: 'E2E code exec ok\n', stderr: '', files: [] });}+/** File ids set through `POST /__debug/slow-downloads` download as a long trickle, so a spec can+ * disconnect mid-stream. `GET /__debug/downloads?fileId=` reports how many of those bodies were+ * cut off by LibreChat closing the upstream. Keyed by file id so parallel projects stay apart. */+const slowDownloadFiles = new Set();+const closedSlowDownloads = new Map();+const server = http.createServer((req, res) => {const url = new URL(req.url, `http://${req.headers.host}`);const { pathname } = url;@@ -242,7 +248,23 @@ const server = http.createServer((req, res) => {return;}+ if (pathname === '/__debug/slow-downloads' && req.method === 'POST') {+ const { fileId, slow } = await readJson(req);+ if (slow === true) slowDownloadFiles.add(fileId);+ else slowDownloadFiles.delete(fileId);+ sendJson(res, 200, { ok: true });+ return;+ }++ if (pathname === '/__debug/downloads' && req.method === 'GET') {+ const fileId = url.searchParams.get('fileId');+ sendJson(res, 200, { closed: closedSlowDownloads.get(fileId) ?? 0 });+ return;+ }+if (pathname === '/__debug/reset' && req.method === 'POST') {+ slowDownloadFiles.clear();+ closedSlowDownloads.clear();sessions.clear();generated.clear();uploads.length = 0;@@ -267,6 +289,25 @@ const server = http.createServer((req, res) => {}const downloadMatch = pathname.match(/^\/v1\/download\/([^/]+)\/([^/]+)$/);+ const slowFileId = downloadMatch ? decodeURIComponent(downloadMatch[2]) : '';+ if (downloadMatch && req.method === 'GET' && slowDownloadFiles.has(slowFileId)) {+ res.writeHead(200, { 'Content-Type': 'text/csv' });+ let sent = 0;+ const timer = setInterval(() => {+ res.write(Buffer.alloc(16 * 1024, 'a'));+ if (++sent >= 600) {+ clearInterval(timer);+ res.end();+ }+ }, 50);+ res.on('close', () => {+ clearInterval(timer);+ if (!res.writableFinished) {+ closedSlowDownloads.set(slowFileId, (closedSlowDownloads.get(slowFileId) ?? 0) + 1);+ }+ });+ return;+ }if (downloadMatch && req.method === 'GET') {const key = `${decodeURIComponent(downloadMatch[1])}/${decodeURIComponent(downloadMatch[2])}`;const file = generated.get(key);diff --git a/e2e/specs/mock/scenarios/code-download-stream.spec.ts b/e2e/specs/mock/scenarios/code-download-stream.spec.tsnew file mode 100644index 0000000000..b41e1192da--- /dev/null+++ b/e2e/specs/mock/scenarios/code-download-stream.spec.ts@@ -0,0 +1,80 @@+import http from 'node:http';+import { randomBytes } from 'node:crypto';+import { expect, test } from '@playwright/test';+import { getE2EUser } from '../../../setup/user';+import { CODE_API_BASE } from '../helpers';++/** The route accepts 21-character ids; a fresh file id keeps parallel projects apart. */+const SESSION_ID = 'e2esessionstream00001';+const newFileId = (): string => randomBytes(16).toString('hex').slice(0, 21);+const BROWSER_UA =+ 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';++/** Starts a download and drops the connection as soon as the first bytes arrive. */+function downloadAndDisconnect(url: string, token: string): Promise<void> {+ return new Promise((resolve, reject) => {+ /** The API rejects requests without a browser user agent before any route runs. */+ const headers = {+ Authorization: `Bearer ${token}`,+ 'User-Agent': BROWSER_UA,+ };+ const req = http.get(url, { headers }, (res) => {+ if (res.statusCode !== 200) {+ reject(new Error(`download answered ${res.statusCode}`));+ return;+ }+ res.once('data', () => {+ req.destroy();+ resolve();+ });+ });+ req.on('error', () => undefined);+ });+}++test.describe('code output downloads', () => {+ /* The fake code API trickles a long body. Once the browser side leaves, LibreChat must close+ its upstream download too instead of holding the connection open, paused, until a timeout. */+ test('leaving a download closes the upstream code download @scenario:abandoned-code-download-closes-upstream', async ({+ playwright,+ baseURL,+ request,+ }) => {+ const client = await playwright.request.newContext({ baseURL });+ try {+ const { email, password } = getE2EUser();+ const login = await client.post('/api/auth/login', { data: { email, password } });+ expect(login.ok()).toBeTruthy();+ const { token } = (await login.json()) as { token: string };++ const fileId = newFileId();+ const slow = await request.post(`${CODE_API_BASE}/__debug/slow-downloads`, {+ data: { fileId, slow: true },+ });+ expect(slow.ok()).toBeTruthy();++ await downloadAndDisconnect(+ new URL(`/api/files/code/download/${SESSION_ID}/${fileId}`, baseURL).toString(),+ token,+ );++ await expect+ .poll(+ async () => {+ const response = await request.get(+ `${CODE_API_BASE}/__debug/downloads?fileId=${fileId}`,+ );+ return ((await response.json()) as { closed: number }).closed;+ },+ { timeout: 5_000, intervals: [250] },+ )+ .toBe(1);+ expect((await client.get('/health')).status()).toBe(200);+ await request.post(`${CODE_API_BASE}/__debug/slow-downloads`, {+ data: { fileId, slow: false },+ });+ } finally {+ await client.dispose();+ }+ });+});diff --git a/librechat.example.yaml b/librechat.example.yamlindex 0a9b555085..a0ca0e585c 100644--- a/librechat.example.yaml+++ b/librechat.example.yaml@@ -503,6 +503,7 @@ registration:# connect-time guard only covers direct, non-proxied connections.# speech:# tts:+# maxInputChars: 20000 # longest text one request may synthesize (each 1,000 chars is a provider call)# openai:# url: ''# apiKey: '${TTS_API_KEY}'diff --git a/packages/api/src/files/speech.spec.ts b/packages/api/src/files/speech.spec.tsindex b939bac4da..66c991b18a 100644--- a/packages/api/src/files/speech.spec.ts+++ b/packages/api/src/files/speech.spec.ts@@ -1,11 +1,11 @@import { ContentTypes } from 'librechat-data-provider';import type { TMessage } from 'librechat-data-provider';import type { SpeechMessageCache } from './speech';-import { createSpeechChunkProcessor } from './speech';+import { capSpeechInput, createSpeechChunkProcessor, DEFAULT_TTS_MAX_INPUT_CHARS } from './speech';const messageId = 'message-id';-function setup(stored: TMessage | null = null) {+function setup(stored: TMessage | null = null, maxInputChars?: number) {const entries = new Map<string, Parameters<SpeechMessageCache['set']>[1]>();const cache = {get: jest.fn(async (key: string) => entries.get(key)),@@ -19,6 +19,7 @@ function setup(stored: TMessage | null = null) {messageId,cache,getMessage,+ maxInputChars,});return { cache, getMessage, processChunks };}@@ -64,6 +65,20 @@ describe('createSpeechChunkProcessor', () => {]);});+ it('finishes a message that reaches the cap exactly', async () => {+ const { cache, processChunks } = setup(null, 10);+ cache.get.mockResolvedValueOnce({ text: 'Ten chars.', complete: false });++ expect(await processChunks()).toEqual([{ text: 'Ten chars.', isFinished: true }]);+ });++ it('stops a message longer than the cap at the cap', async () => {+ const { cache, processChunks } = setup(null, 10);+ cache.get.mockResolvedValueOnce({ text: 'Twelve chars and then some more', complete: false });++ expect(await processChunks()).toEqual([{ text: 'Twelve cha', isFinished: true }]);+ });+it('sends an incomplete message without separators whole', async () => {const text = 'This is a long message without separators hello there my friend';const { cache, processChunks } = setup();@@ -114,3 +129,21 @@ describe('createSpeechChunkProcessor', () => {expect(await processChunks()).toEqual([{ text: 'The answer is 4.', isFinished: true }]);});});++describe('capSpeechInput', () => {+ it('keeps text within the default cap whole', () => {+ const text = 'a'.repeat(DEFAULT_TTS_MAX_INPUT_CHARS);+ expect(capSpeechInput(text)).toBe(text);+ });++ it.each([['a', 'b'], { length: 5 }, 42, undefined])(+ 'treats a non-text body (%j) as empty',+ (input) => {+ expect(capSpeechInput(input)).toBe('');+ },+ );++ it('reads text over the configured cap only up to the cap', () => {+ expect(capSpeechInput('a'.repeat(11), { maxInputChars: 10 })).toBe('a'.repeat(10));+ });+});diff --git a/packages/api/src/files/speech.ts b/packages/api/src/files/speech.tsindex 4b414be1e9..9b215ea2d0 100644--- a/packages/api/src/files/speech.ts+++ b/packages/api/src/files/speech.ts@@ -14,6 +14,9 @@ export interface SpeechMessageCache {set(key: string, value: CachedSpeech, ttl?: number): unknown;}+/** Default cap on the text one text-to-speech request may synthesize. */+export const DEFAULT_TTS_MAX_INPUT_CHARS = 20_000;+/*** Polls a message for the next text to stream as speech. Each call returns the chunks* finalized since the previous one, or an error string once the message stays missing or@@ -25,11 +28,14 @@ export function createSpeechChunkProcessor({messageId,cache,getMessage,+ maxInputChars = DEFAULT_TTS_MAX_INPUT_CHARS,}: {user: string;messageId?: string;cache: SpeechMessageCache;getMessage: (filter: { user: string; messageId: string }) => Promise<TMessage | null>;+ /** Speech stops here: text past the cap is never sent to the provider. */+ maxInputChars?: number;}): () => Promise<SpeechChunk[] | string> {if (!messageId) {throw new Error('Message ID is required');@@ -57,10 +63,14 @@ export function createSpeechChunkProcessor({return [];}- const text = typeof message === 'string' ? message : getSpeechText(message);- cache.set(cacheKey, { text, complete: true }, Time.FIVE_MINUTES);+ const fullText = typeof message === 'string' ? message : getSpeechText(message);+ cache.set(cacheKey, { text: fullText, complete: true }, Time.FIVE_MINUTES);+ /** A message longer than the cap is read up to the cap, as if it ended there. */+ const capped = fullText.length >= maxInputChars;+ const text = capped ? fullText.slice(0, maxInputChars) : fullText;const complete =- typeof message !== 'string' && (!('complete' in message) || message.complete !== false);+ capped ||+ (typeof message !== 'string' && (!('complete' in message) || message.complete !== false));if (text === processedText) {noChangeCount++;@@ -87,3 +97,17 @@ export function createSpeechChunkProcessor({return chunks;};}++/**+ * The part of `input` one text-to-speech request may synthesize: the text up to the cap, so+ * one request cannot fan out into an unbounded number of paid provider calls. Longer text is+ * read up to the cap, the same as automatic playback of a long message.+ */+export function capSpeechInput(input: unknown, ttsConfig?: { maxInputChars?: number }): string {+ /** A request body can carry any JSON; only text is spoken, so the cap always counts characters. */+ if (typeof input !== 'string') {+ return '';+ }+ const maxInputChars = ttsConfig?.maxInputChars ?? DEFAULT_TTS_MAX_INPUT_CHARS;+ return input.length > maxInputChars ? input.slice(0, maxInputChars) : input;+}diff --git a/packages/api/src/utils/index.ts b/packages/api/src/utils/index.tsindex f54f2efe18..12f1db8286 100644--- a/packages/api/src/utils/index.ts+++ b/packages/api/src/utils/index.ts@@ -1,4 +1,5 @@export * from './axios';+export * from './streams';export * from './azure';export * from './code';export * from './common';diff --git a/packages/api/src/utils/streams.spec.ts b/packages/api/src/utils/streams.spec.tsnew file mode 100644index 0000000000..836b4e3b1b--- /dev/null+++ b/packages/api/src/utils/streams.spec.ts@@ -0,0 +1,109 @@+import { PassThrough, Readable } from 'node:stream';+import { pipeSegment, pipeToResponse } from './streams';++function failingSource(): Readable {+ return new Readable({+ read() {+ this.push(Buffer.from('partial'));+ this.destroy(new Error('socket reset'));+ },+ });+}++describe('pipeToResponse', () => {+ it('reports a mid-stream failure and tears the response down', async () => {+ const res = new PassThrough();+ res.resume();+ const onError = jest.fn();++ pipeToResponse(failingSource(), res, onError);+ await new Promise((resolve) => res.on('close', resolve));++ expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'socket reset' }));+ expect(res.destroyed).toBe(true);+ });++ it('destroys the upstream when the client disconnects', async () => {+ const source = new PassThrough();+ const res = new PassThrough();++ pipeToResponse(source, res);+ res.destroy();+ await new Promise((resolve) => source.on('close', resolve));++ expect(source.destroyed).toBe(true);+ });+});++describe('pipeSegment', () => {+ it('resolves when the segment ends and leaves the response open', async () => {+ const res = new PassThrough();+ res.resume();++ await pipeSegment(Readable.from([Buffer.from('audio')]), res, { end: false });++ expect(res.writableEnded).toBe(false);+ });++ it('rejects when the segment fails', async () => {+ const res = new PassThrough();+ res.resume();++ await expect(pipeSegment(failingSource(), res, { end: false })).rejects.toThrow('socket reset');+ });++ it('rejects and stops the upstream when the client disconnects', async () => {+ const source = new PassThrough();+ const res = new PassThrough();+ const pending = pipeSegment(source, res, { end: false });++ res.destroy();++ await expect(pending).rejects.toThrow('Client disconnected');+ expect(source.destroyed).toBe(true);+ });++ it('rejects at once when the client left before the segment started', async () => {+ const source = new PassThrough();+ const res = new PassThrough();+ res.destroy();++ await expect(pipeSegment(source, res, { end: false })).rejects.toThrow('Client disconnected');+ expect(source.destroyed).toBe(true);+ });++ it('tears the response down when the segment fails mid-write', async () => {+ const res = new PassThrough();+ res.resume();++ await expect(pipeSegment(failingSource(), res, { end: false })).rejects.toThrow('socket reset');+ expect(res.destroyed).toBe(true);+ });++ it('rejects on a response-side error instead of leaving it unhandled', async () => {+ const source = new PassThrough();+ const res = new PassThrough();+ const pending = pipeSegment(source, res, { end: false });++ res.emit('error', new Error('write EPIPE'));++ await expect(pending).rejects.toThrow('write EPIPE');+ expect(source.destroyed).toBe(true);+ });++ it('keeps a response write error after a segment from going unhandled', async () => {+ const res = new PassThrough();+ res.resume();+ await pipeSegment(Readable.from([Buffer.from('audio')]), res, { end: false });++ expect(() => res.emit('error', new Error('write EPIPE'))).not.toThrow();+ });++ it('leaves a response with no audio sent yet open for an HTTP error', async () => {+ const res = Object.assign(new PassThrough(), { headersSent: false });+ res.resume();++ await expect(pipeSegment(failingSource(), res, { end: false })).rejects.toThrow('socket reset');+ expect(res.destroyed).toBe(false);+ });+});diff --git a/packages/api/src/utils/streams.ts b/packages/api/src/utils/streams.tsnew file mode 100644index 0000000000..59365cfb68--- /dev/null+++ b/packages/api/src/utils/streams.ts@@ -0,0 +1,83 @@+import { pipeline } from 'node:stream';+import type { Readable, Writable } from 'node:stream';++/**+ * Streams `source` into `res` and ends it. An upstream failure tears the response down instead+ * of surfacing as an uncaught stream error, and a client disconnect destroys the upstream.+ */+export function pipeToResponse(+ source: Readable,+ res: Writable,+ onError?: (error: Error) => void,+): void {+ pipeline(source, res, (error) => {+ if (error) {+ onError?.(error);+ }+ });+}++const guardedResponses = new WeakSet<Writable>();++/**+ * A response that outlives one segment can still fail a buffered write after that segment's+ * listeners are gone. A lasting listener keeps that from becoming an uncaught error; the+ * failure still destroys the response, which the next segment sees as a closed client.+ */+function guardResponse(res: Writable): void {+ if (guardedResponses.has(res)) {+ return;+ }+ guardedResponses.add(res);+ res.on('error', () => undefined);+}++/**+ * Writes one `source` segment into `res`, ending `res` only when `end` is set. Resolves when the+ * segment ends; rejects, destroying `source`, when it fails or the client disconnects first.+ */+export function pipeSegment(+ source: Readable,+ res: Writable,+ { end }: { end: boolean },+): Promise<void> {+ guardResponse(res);+ return new Promise((resolve, reject) => {+ /** A client that left while the previous segment was being fetched already emitted close. */+ if (res.destroyed || res.writableEnded) {+ source.destroy();+ reject(new Error('Client disconnected'));+ return;+ }+ const cleanup = (): void => {+ source.off('end', onEnd);+ source.off('error', onError);+ res.off('close', onClose);+ res.off('error', onError);+ };+ const onEnd = (): void => {+ cleanup();+ resolve();+ };+ /** Either side failing ends both: a half-written response would otherwise hang the client. */+ const onError = (error: Error): void => {+ cleanup();+ source.destroy();+ /** Before any audio went out the caller can still answer with an HTTP error. */+ if (!('headersSent' in res) || res.headersSent) {+ res.destroy();+ }+ reject(error);+ };+ const onClose = (): void => {+ cleanup();+ source.destroy();+ reject(new Error('Client disconnected'));+ };+ source.on('end', onEnd);+ source.on('error', onError);+ res.on('error', onError);+ res.on('close', onClose);+ source.pipe(res, { end });+ });+}diff --git a/packages/data-provider/src/config.ts b/packages/data-provider/src/config.tsindex 19d8fd0cc7..d549ca30fb 100644--- a/packages/data-provider/src/config.ts+++ b/packages/data-provider/src/config.ts@@ -2385,6 +2385,8 @@ const ttsLocalaiSchema = z.object({const ttsSchema = z.object({allowedAddresses: allowedAddressesSchema,+ /** Longest text one request may synthesize; each 1,000 characters is a separate paid call. */+ maxInputChars: z.number().int().positive().optional(),openai: ttsOpenaiSchema.optional(),azureOpenAI: ttsAzureOpenAISchema.optional(),elevenlabs: ttsElevenLabsSchema.optional(),