libre-webui 0.21.3 → 0.22.1

package/backend/dist/routes/media.js

@@ -5,27 +5,39 @@
  * Licensed under the Apache License, Version 2.0 (the "License");
  */
 import express from 'express';
-import rateLimit from 'express-rate-limit';
+import multer from 'multer';
+import rateLimit from '../middleware/sharedRateLimit.js';
 import { authenticate } from '../middleware/auth.js';
 import galleryService from '../services/galleryService.js';
 import mediaGenerationJobService from '../services/mediaGenerationJobService.js';
 import pluginService from '../services/pluginService.js';
+import { AudioGenerationConcurrencyError } from '../services/pluginAudioGenerationService.js';
+import { VideoCancellationUnsupportedError } from '../services/pluginVideoGenerationService.js';
+import voiceProfileService from '../services/voiceProfileService.js';
+import { TTSConcurrencyError, TTSProviderResponseError, } from '../services/pluginTTSService.js';
 import { createLogger } from '../utils/logger.js';
+import { parseTTSVoiceCloneUpload, reserveTTSVoiceCloneUpload, TTS_VOICE_CLONE_GLOBAL_MAX_AUDIO_BYTES, TTSVoiceCloneConcurrencyError, TTSVoiceCloneUploadError, validateTTSVoiceCloneAudio, } from '../utils/ttsVoiceCloneUpload.js';
+import { getDurableJobRuntime, VIDEO_RESUME_IDEMPOTENCY_SCOPE, VIDEO_SUBMIT_IDEMPOTENCY_SCOPE, } from '../platform/jobs/index.js';
+import { combineAbortSignals, SharedCapacityUnavailableError, } from '../platform/coordination/sharedAdmission.js';
 const logger = createLogger('routes:media');
 const router = express.Router();
+const videoJobLocks = new Map();
 const generationRateLimiter = rateLimit({
+    keyPrefix: 'media-generate',
     windowMs: 60000,
     max: 10,
     standardHeaders: true,
     legacyHeaders: false,
 });
 const pollingRateLimiter = rateLimit({
+    keyPrefix: 'media-poll',
     windowMs: 60000,
     max: 60,
     standardHeaders: true,
     legacyHeaders: false,
 });
 const galleryRateLimiter = rateLimit({
+    keyPrefix: 'media-gallery',
     windowMs: 60000,
     max: 120,
     standardHeaders: true,
@@ -33,6 +45,7 @@ const galleryRateLimiter = rateLimit({
 });
 // Umbrella limit ahead of authentication; per-route limiters below stay tighter.
 const routerRateLimiter = rateLimit({
+    keyPrefix: 'media-router',
     windowMs: 60000,
     max: 240,
     standardHeaders: true,
@@ -45,6 +58,34 @@ function userId(req) {
         throw new Error('Authenticated user context is required');
     return req.user.userId;
 }
+function requestAbortSignal(req, res) {
+    const controller = new AbortController();
+    const abort = () => {
+        if (!controller.signal.aborted) {
+            controller.abort(new Error('Media client disconnected'));
+        }
+    };
+    const abortOnResponseClose = () => {
+        if (!res.writableEnded)
+            abort();
+    };
+    req.once?.('aborted', abort);
+    res.once?.('close', abortOnResponseClose);
+    if (req.aborted || res.destroyed)
+        abort();
+    return {
+        signal: controller.signal,
+        cleanup: () => {
+            req.off?.('aborted', abort);
+            res.off?.('close', abortOnResponseClose);
+        },
+    };
+}
+const providerResponseStatus = (status) => status === 401 || status === 403
+    ? 502
+    : status >= 400 && status < 500
+        ? status
+        : 502;
 router.get('/models', async (req, res) => {
     try {
         const id = userId(req);
@@ -53,17 +94,18 @@ router.get('/models', async (req, res) => {
             pluginService.refreshStaleCapabilityModels('tts', id),
             pluginService.refreshStaleCapabilityModels('audio', id),
         ]);
+        const [videoModels, audioModels, ttsModels] = await Promise.all([
+            pluginService.getAvailableVideoGenModels(id),
+            pluginService.getAvailableAudioGenModels(id),
+            pluginService.getAvailableTTSModels(id),
+        ]);
         res.json({
             success: true,
             data: {
-                video: pluginService.getAvailableVideoGenModels(id),
+                video: videoModels,
                 audio: [
-                    ...pluginService
-                        .getAvailableAudioGenModels(id)
-                        .map(model => ({ ...model, mode: 'sound' })),
-                    ...pluginService
-                        .getAvailableTTSModels(id)
-                        .map(model => ({ ...model, mode: 'speech' })),
+                    ...audioModels.map(model => ({ ...model, mode: 'sound' })),
+                    ...ttsModels.map(model => ({ ...model, mode: 'speech' })),
                 ],
             },
         });
@@ -77,6 +119,7 @@ router.get('/models', async (req, res) => {
     }
 });
 router.post('/audio/generate', generationRateLimiter, async (req, res) => {
+    const requestAbort = requestAbortSignal(req, res);
     try {
         const { model, pluginId, input, voice, response_format, speed } = req.body;
         if (typeof model !== 'string' ||
@@ -90,17 +133,26 @@ router.post('/audio/generate', generationRateLimiter, async (req, res) => {
             return;
         }
         const id = userId(req);
-        const format = isAudioFormat(response_format) ? response_format : 'mp3';
+        const selectedPlugin = await pluginService.getPluginForTTS(model, pluginId, id);
+        const configuredFormat = selectedPlugin?.capabilities?.tts?.config?.default_format;
+        const format = isAudioFormat(response_format)
+            ? response_format
+            : isAudioFormat(configuredFormat)
+                ? configuredFormat
+                : 'mp3';
         const audio = await pluginService.executeTTSRequest(model, input.trim(), {
             pluginId,
             userId: id,
             ...(typeof voice === 'string' && voice ? { voice } : {}),
             ...(typeof speed === 'number' ? { speed } : {}),
             response_format: format,
+            signal: requestAbort.signal,
         });
+        if (requestAbort.signal.aborted)
+            return;
         const mimeType = audioMimeType(format);
         const mediaData = `data:${mimeType};base64,${audio.toString('base64')}`;
-        const saved = galleryService.saveMedia(id, {
+        const saved = await galleryService.saveMedia(id, {
             kind: 'audio',
             prompt: input.trim(),
             model,
@@ -114,14 +166,213 @@ router.post('/audio/generate', generationRateLimiter, async (req, res) => {
         res.json({ success: true, data: publicMedia(saved) });
     }
     catch (error) {
+        if (requestAbort.signal.aborted)
+            return;
+        if (error instanceof SharedCapacityUnavailableError) {
+            res.status(503).json({
+                success: false,
+                message: 'Media admission is temporarily unavailable',
+            });
+            return;
+        }
+        if (error instanceof TTSConcurrencyError) {
+            res.status(429).json({ success: false, message: error.message });
+            return;
+        }
+        if (error instanceof TTSProviderResponseError) {
+            logger.warn(`TTS provider returned status ${error.providerStatus} during gallery generation`);
+            res.status(providerResponseStatus(error.providerStatus)).json({
+                success: false,
+                message: error.message,
+            });
+            return;
+        }
         logger.error('Audio generation failed:', error);
-        res.status(500).json({
+        const message = error instanceof Error ? error.message : 'Audio generation failed';
+        res.status(/exceeds maximum length/i.test(message) ? 400 : 500).json({
             success: false,
-            message: error instanceof Error ? error.message : 'Audio generation failed',
+            message,
+        });
+    }
+    finally {
+        requestAbort.cleanup();
+    }
+});
+router.post('/audio/voice-clone', generationRateLimiter, async (req, res) => {
+    const requestAbort = requestAbortSignal(req, res);
+    let uploadSlot;
+    try {
+        const id = userId(req);
+        uploadSlot = await reserveTTSVoiceCloneUpload(id);
+        const operationSignal = combineAbortSignals(requestAbort.signal, uploadSlot.signal);
+        await parseTTSVoiceCloneUpload(req, res, operationSignal);
+        const { model, pluginId, input, reference_text, response_format, saveVoiceName, consentToStore, } = req.body || {};
+        if (typeof model !== 'string' ||
+            typeof pluginId !== 'string' ||
+            typeof input !== 'string' ||
+            input.trim().length === 0) {
+            res.status(400).json({
+                success: false,
+                message: 'model, pluginId, and input are required',
+            });
+            return;
+        }
+        if (reference_text !== undefined && typeof reference_text !== 'string') {
+            res.status(400).json({
+                success: false,
+                message: 'reference_text must be a string when provided',
+            });
+            return;
+        }
+        if (saveVoiceName !== undefined &&
+            (typeof saveVoiceName !== 'string' || saveVoiceName.trim().length === 0)) {
+            res.status(400).json({
+                success: false,
+                message: 'saveVoiceName must be a non-empty string when provided',
+            });
+            return;
+        }
+        if (saveVoiceName !== undefined && consentToStore !== 'true') {
+            res.status(400).json({
+                success: false,
+                message: 'Explicit consent is required to save a reusable voice',
+            });
+            return;
+        }
+        if (consentToStore === 'true' && saveVoiceName === undefined) {
+            res.status(400).json({
+                success: false,
+                message: 'A voice name is required when consentToStore is true',
+            });
+            return;
+        }
+        const selectedPlugin = await pluginService.getPluginForTTS(model, pluginId, id);
+        const config = selectedPlugin?.capabilities?.tts?.config;
+        if (!selectedPlugin || !config?.supports_voice_cloning) {
+            res.status(400).json({
+                success: false,
+                message: 'The selected TTS model does not support voice cloning',
+            });
+            return;
+        }
+        if (config.clone_requires_transcript && !reference_text?.trim()) {
+            res.status(400).json({
+                success: false,
+                message: 'An exact reference transcript is required',
+            });
+            return;
+        }
+        const format = isAudioFormat(response_format)
+            ? response_format
+            : isAudioFormat(config.default_format)
+                ? config.default_format
+                : 'wav';
+        const referenceAudio = validateTTSVoiceCloneAudio(req.file, config);
+        const profileInput = saveVoiceName !== undefined
+            ? {
+                name: saveVoiceName,
+                pluginId: selectedPlugin.id,
+                model,
+                routingFingerprint: await pluginService.getCredentialRoutingAuthFingerprint(selectedPlugin, id),
+                referenceAudio,
+                ...(reference_text?.trim()
+                    ? { referenceText: reference_text.trim() }
+                    : {}),
+            }
+            : null;
+        if (profileInput)
+            await voiceProfileService.validateCreate(id, profileInput);
+        const audio = await pluginService.executeVoiceCloneRequest(model, input.trim(), referenceAudio, {
+            pluginId,
+            userId: id,
+            referenceText: reference_text?.trim() || undefined,
+            response_format: format,
+            signal: operationSignal,
+        });
+        if (operationSignal.aborted)
+            return;
+        const mimeType = audioMimeType(format);
+        const saved = await galleryService.saveMedia(id, {
+            kind: 'audio',
+            prompt: input.trim(),
+            model,
+            pluginId,
+            mediaData: `data:${mimeType};base64,${audio.toString('base64')}`,
+            mimeType,
+            metadata: { mode: 'speech', voiceClone: true, format },
         });
+        if (!saved)
+            throw new Error('Failed to save generated audio');
+        // Persist only after successful provider and gallery generation. If the
+        // final atomic profile check loses a race, roll back the gallery item so
+        // the caller never receives a partial success.
+        if (profileInput) {
+            try {
+                await voiceProfileService.create(id, profileInput);
+            }
+            catch (error) {
+                await galleryService.deleteMedia(saved.id, id);
+                throw error;
+            }
+        }
+        res.json({ success: true, data: publicMedia(saved) });
+    }
+    catch (error) {
+        if (requestAbort.signal.aborted)
+            return;
+        if (error instanceof SharedCapacityUnavailableError) {
+            res.status(503).json({
+                success: false,
+                message: 'Media admission is temporarily unavailable',
+            });
+            return;
+        }
+        if (error instanceof TTSConcurrencyError) {
+            res.status(429).json({ success: false, message: error.message });
+            return;
+        }
+        if (error instanceof TTSVoiceCloneConcurrencyError) {
+            res.status(429).json({ success: false, message: error.message });
+            return;
+        }
+        if (error instanceof multer.MulterError) {
+            logger.warn(`Gallery voice-clone upload failed: ${error.code}`);
+            res.status(400).json({
+                success: false,
+                message: error.code === 'LIMIT_FILE_SIZE'
+                    ? `Reference audio exceeds the global maximum size of ${TTS_VOICE_CLONE_GLOBAL_MAX_AUDIO_BYTES / (1024 * 1024)} MiB`
+                    : `Invalid voice clone upload: ${error.message}`,
+            });
+            return;
+        }
+        if (error instanceof TTSVoiceCloneUploadError) {
+            logger.warn(`Gallery voice-clone upload failed: ${error.code}`);
+            res.status(400).json({ success: false, message: error.message });
+            return;
+        }
+        if (error instanceof TTSProviderResponseError) {
+            logger.warn(`TTS provider returned status ${error.providerStatus} during gallery voice cloning`);
+            res.status(providerResponseStatus(error.providerStatus)).json({
+                success: false,
+                message: error.message,
+            });
+            return;
+        }
+        logger.error('Voice-cloned audio generation failed:', error);
+        const message = error instanceof Error ? error.message : 'Voice cloning failed';
+        res
+            .status(/required|maximum|at most|limited to|already exists|unsupported|does not support|no voice clone endpoint/i.test(message)
+            ? 400
+            : 500)
+            .json({ success: false, message });
+    }
+    finally {
+        await uploadSlot?.release();
+        requestAbort.cleanup();
     }
 });
 router.post('/sound/generate', generationRateLimiter, async (req, res) => {
+    const requestAbort = requestAbortSignal(req, res);
     try {
         const { model, pluginId, prompt, voice, format } = req.body;
         if (typeof model !== 'string' ||
@@ -140,9 +391,12 @@ router.post('/sound/generate', generationRateLimiter, async (req, res) => {
             userId: id,
             ...(typeof voice === 'string' && voice ? { voice } : {}),
             ...(isGeneratedAudioFormat(format) ? { format } : {}),
+            signal: requestAbort.signal,
         });
+        if (requestAbort.signal.aborted)
+            return;
         const mediaData = `data:${generated.mimeType};base64,${generated.audio.toString('base64')}`;
-        const saved = galleryService.saveMedia(id, {
+        const saved = await galleryService.saveMedia(id, {
             kind: 'audio',
             prompt: prompt.trim(),
             model,
@@ -161,14 +415,31 @@ router.post('/sound/generate', generationRateLimiter, async (req, res) => {
         res.json({ success: true, data: publicMedia(saved) });
     }
     catch (error) {
+        if (requestAbort.signal.aborted)
+            return;
+        if (error instanceof SharedCapacityUnavailableError) {
+            res.status(503).json({
+                success: false,
+                message: 'Media admission is temporarily unavailable',
+            });
+            return;
+        }
+        if (error instanceof AudioGenerationConcurrencyError) {
+            res.status(429).json({ success: false, message: error.message });
+            return;
+        }
         logger.error('Audio generation failed:', error);
         res.status(500).json({
             success: false,
             message: error instanceof Error ? error.message : 'Audio generation failed',
         });
     }
+    finally {
+        requestAbort.cleanup();
+    }
 });
 router.post('/video/generate', generationRateLimiter, async (req, res) => {
+    const requestAbort = requestAbortSignal(req, res);
     try {
         const { model, pluginId, prompt, duration, resolution, aspect_ratio, generate_audio, } = req.body;
         if (typeof model !== 'string' ||
@@ -192,109 +463,266 @@ router.post('/video/generate', generationRateLimiter, async (req, res) => {
                 ? { generateAudio: generate_audio }
                 : {}),
         };
-        const submitted = await pluginService.submitVideoGenRequest(model, prompt.trim(), { pluginId, userId: id, ...options });
-        const job = mediaGenerationJobService.create(id, {
-            providerJobId: submitted.providerJobId,
+        // The prepared row and submission job are one transaction. Provider
+        // acceptance runs in the external worker with a stable idempotency key.
+        const job = await mediaGenerationJobService.queueVideoSubmission(id, {
             pluginId,
             model,
             prompt: prompt.trim(),
             options,
         });
-        res.status(202).json({ success: true, data: publicJob(job) });
+        if (requestAbort.signal.aborted)
+            return;
+        res.status(202).json({ success: true, data: await publicJob(job, id) });
     }
     catch (error) {
+        if (requestAbort.signal.aborted)
+            return;
         logger.error('Video generation submission failed:', error);
         res.status(500).json({
             success: false,
             message: error instanceof Error ? error.message : 'Video generation failed',
         });
     }
+    finally {
+        requestAbort.cleanup();
+    }
 });
-router.get('/video/jobs/:jobId', pollingRateLimiter, async (req, res) => {
+router.get('/video/jobs', pollingRateLimiter, async (req, res) => {
+    const id = userId(req);
+    const requestedLimit = Number(req.query.limit);
+    const jobs = await mediaGenerationJobService.list(id, {
+        limit: Number.isInteger(requestedLimit) ? requestedLimit : 20,
+        activeOnly: req.query.active === 'true',
+    });
+    res.json({
+        success: true,
+        data: { jobs: await Promise.all(jobs.map(job => publicJob(job, id))) },
+    });
+});
+async function resumeVideoJob(req, res) {
+    const requestAbort = requestAbortSignal(req, res);
+    let releaseJobLock;
     try {
         const id = userId(req);
         const jobId = Array.isArray(req.params.jobId)
             ? req.params.jobId[0]
             : req.params.jobId;
-        const job = mediaGenerationJobService.get(jobId, id);
+        releaseJobLock = await acquireVideoJobLock(`${id}:${jobId}`);
+        if (requestAbort.signal.aborted)
+            return;
+        // Reload only after acquiring the lock: another tab may have completed and
+        // persisted this job while this request waited.
+        const job = await mediaGenerationJobService.get(jobId, id);
         if (!job) {
-            res
-                .status(404)
-                .json({ success: false, message: 'Video job not found' });
+            res.status(404).json({ success: false, message: 'Video job not found' });
             return;
         }
         if (job.status === 'completed') {
             res.json({
                 success: true,
                 data: {
-                    ...publicJob(job),
-                    media: publicMedia(galleryService.getMediaItem(job.galleryId, id)),
+                    ...(await publicJob(job, id)),
+                    media: publicMedia(await galleryService.getMediaItem(job.galleryId, id)),
                 },
             });
             return;
         }
         if (job.status === 'failed') {
-            res.json({ success: true, data: publicJob(job) });
+            res.json({ success: true, data: await publicJob(job, id) });
+            return;
+        }
+        const durable = (await getDurableJobRuntime().service.getByIdempotency(id, VIDEO_RESUME_IDEMPOTENCY_SCOPE, job.id)) ||
+            (await getDurableJobRuntime().service.getByIdempotency(id, VIDEO_SUBMIT_IDEMPOTENCY_SCOPE, job.id));
+        if (durable?.state === 'queued' || durable?.state === 'running') {
+            res.json({
+                success: true,
+                data: {
+                    ...(await publicJob(job, id)),
+                    durable: {
+                        id: durable.id,
+                        state: durable.state,
+                        progressCurrent: durable.progressCurrent,
+                        progressTotal: durable.progressTotal,
+                        progressMessage: durable.progressMessage,
+                    },
+                },
+            });
+            return;
+        }
+        if (durable?.state === 'dead_letter') {
+            await mediaGenerationJobService.update(job.id, id, 'failed', {
+                error: durable.errorSummary || 'Video processing failed',
+            });
+            res.json({
+                success: true,
+                data: {
+                    ...(await publicJob(job, id)),
+                    status: 'failed',
+                    error: durable.errorSummary || 'Video processing failed',
+                },
+            });
+            return;
+        }
+        if (process.env.LIBRE_PLATFORM_MODE === 'team') {
+            // Team media work belongs exclusively to the external durable worker.
+            // A polling app replica must never become an unleased provider worker.
+            res.status(202).json({
+                success: true,
+                data: {
+                    ...(await publicJob(job, id)),
+                    durable: durable
+                        ? { id: durable.id, state: durable.state }
+                        : undefined,
+                },
+            });
             return;
         }
-        const status = await pluginService.pollVideoGenRequest(job.model, job.providerJobId, job.pluginId, id);
+        const status = await pluginService.pollVideoGenRequest(job.model, job.providerJobId, job.pluginId, id, requestAbort.signal);
+        if (requestAbort.signal.aborted)
+            return;
         if (status.status === 'failed') {
-            mediaGenerationJobService.update(job.id, id, 'failed', {
+            await mediaGenerationJobService.update(job.id, id, 'failed', {
                 error: status.error || 'Video provider reported failure',
             });
             res.json({
                 success: true,
-                data: { ...publicJob(job), status: 'failed', error: status.error },
+                data: {
+                    ...(await publicJob(job, id)),
+                    status: 'failed',
+                    error: status.error,
+                },
             });
             return;
         }
         if (status.status !== 'completed') {
-            mediaGenerationJobService.update(job.id, id, status.status);
+            await mediaGenerationJobService.update(job.id, id, status.status);
             res.json({
                 success: true,
-                data: { ...publicJob(job), status: status.status },
+                data: { ...(await publicJob(job, id)), status: status.status },
             });
             return;
         }
-        const downloaded = await pluginService.downloadVideoGenResult(job.model, job.providerJobId, job.pluginId, id);
-        const media = galleryService.saveMedia(id, {
-            kind: 'video',
-            prompt: job.prompt,
-            model: job.model,
-            pluginId: job.pluginId,
+        const downloaded = await pluginService.downloadVideoGenResult(job.model, job.providerJobId, job.pluginId, id, requestAbort.signal);
+        if (requestAbort.signal.aborted)
+            return;
+        const media = await mediaGenerationJobService.completeWithMedia(job.id, id, {
             mediaData: `data:${downloaded.mimeType};base64,${downloaded.video.toString('base64')}`,
             mimeType: downloaded.mimeType,
             metadata: { ...job.options, usage: status.usage || null },
         });
-        if (!media)
-            throw new Error('Failed to save generated video');
-        mediaGenerationJobService.update(job.id, id, 'completed', {
-            galleryId: media.id,
-        });
         res.json({
             success: true,
             data: {
-                ...publicJob(job),
+                ...(await publicJob(job, id)),
                 status: 'completed',
                 media: publicMedia(media),
             },
         });
     }
     catch (error) {
+        if (requestAbort.signal.aborted)
+            return;
         logger.error('Video generation polling failed:', error);
         res.status(500).json({
             success: false,
             message: error instanceof Error ? error.message : 'Video polling failed',
         });
     }
+    finally {
+        releaseJobLock?.();
+        requestAbort.cleanup();
+    }
+}
+router.get('/video/jobs/:jobId', pollingRateLimiter, resumeVideoJob);
+router.post('/video/jobs/:jobId/resume', pollingRateLimiter, resumeVideoJob);
+router.delete('/video/jobs/:jobId', generationRateLimiter, async (req, res) => {
+    const requestAbort = requestAbortSignal(req, res);
+    let releaseJobLock;
+    try {
+        const id = userId(req);
+        const jobId = Array.isArray(req.params.jobId)
+            ? req.params.jobId[0]
+            : req.params.jobId;
+        releaseJobLock = await acquireVideoJobLock(`${id}:${jobId}`);
+        if (requestAbort.signal.aborted)
+            return;
+        const job = await mediaGenerationJobService.get(jobId, id);
+        if (!job) {
+            res
+                .status(404)
+                .json({ success: false, message: 'Video job not found' });
+            return;
+        }
+        if (job.status === 'completed' || job.status === 'failed') {
+            res.status(409).json({
+                success: false,
+                message: 'Only an active video job can be cancelled',
+            });
+            return;
+        }
+        if (job.providerJobId === 'libre:prepared') {
+            res.status(409).json({
+                success: false,
+                message: 'The provider submission is still being reconciled',
+            });
+            return;
+        }
+        if (!(await pluginService.canCancelVideoGenRequest(job.model, job.pluginId, id))) {
+            res.status(409).json({
+                success: false,
+                message: 'The selected video provider does not declare job cancellation',
+            });
+            return;
+        }
+        await pluginService.cancelVideoGenRequest(job.model, job.providerJobId, job.pluginId, id, requestAbort.signal);
+        const durable = await getDurableJobRuntime().service.getByIdempotency(id, VIDEO_RESUME_IDEMPOTENCY_SCOPE, job.id);
+        if (durable &&
+            (durable.state === 'queued' || durable.state === 'running')) {
+            await getDurableJobRuntime().service.cancel(durable.id, id, 'user-requested');
+        }
+        await mediaGenerationJobService.remove(job.id, id);
+        if (requestAbort.signal.aborted)
+            return;
+        res.json({ success: true });
+    }
+    catch (error) {
+        if (requestAbort.signal.aborted)
+            return;
+        const unsupported = error instanceof VideoCancellationUnsupportedError;
+        logger.error('Video generation cancellation failed:', error);
+        res.status(unsupported ? 409 : 500).json({
+            success: false,
+            message: error instanceof Error ? error.message : 'Video cancellation failed',
+        });
+    }
+    finally {
+        releaseJobLock?.();
+        requestAbort.cleanup();
+    }
 });
-router.get('/gallery', galleryRateLimiter, (req, res) => {
+async function acquireVideoJobLock(key) {
+    const previous = videoJobLocks.get(key) || Promise.resolve();
+    let release = () => { };
+    const held = new Promise(resolve => {
+        release = resolve;
+    });
+    const tail = previous.catch(() => undefined).then(() => held);
+    videoJobLocks.set(key, tail);
+    await previous.catch(() => undefined);
+    return () => {
+        release();
+        if (videoJobLocks.get(key) === tail)
+            videoJobLocks.delete(key);
+    };
+}
+router.get('/gallery', galleryRateLimiter, async (req, res) => {
     const kind = req.query.kind;
     if (kind && !['image', 'video', 'audio'].includes(String(kind))) {
         res.status(400).json({ success: false, message: 'Invalid media kind' });
         return;
     }
-    const result = galleryService.getMedia(userId(req), {
+    const result = await galleryService.getMedia(userId(req), {
         limit: Number(req.query.limit) || 20,
         offset: Number(req.query.offset) || 0,
         ...(kind ? { kind: kind } : {}),
@@ -304,59 +732,73 @@ router.get('/gallery', galleryRateLimiter, (req, res) => {
         data: { ...result, media: result.media.map(publicMedia) },
     });
 });
-router.get('/gallery/:mediaId/content', galleryRateLimiter, (req, res) => {
+router.get('/gallery/:mediaId/content', galleryRateLimiter, async (req, res) => {
+    const requestAbort = requestAbortSignal(req, res);
     const mediaId = Array.isArray(req.params.mediaId)
         ? req.params.mediaId[0]
         : req.params.mediaId;
-    const item = galleryService.getMediaItem(mediaId, userId(req));
-    if (!item) {
-        res.status(404).json({ success: false, message: 'Media not found' });
-        return;
-    }
-    const match = /^data:([a-z0-9.+-]+\/[a-z0-9.+-]+);base64,([a-z0-9+/]+={0,2})$/i.exec(item.mediaData);
-    if (match) {
-        const encodedMimeType = match[1].toLowerCase();
-        if (encodedMimeType !== item.mimeType.toLowerCase() ||
-            !isSafeMediaMimeType(item.kind, encodedMimeType)) {
+    try {
+        const rawRange = req.headers.range;
+        let range;
+        if (rawRange) {
+            const match = /^bytes=(\d+)-(\d*)$/.exec(rawRange.trim());
+            if (!match) {
+                res.status(416).set('Accept-Ranges', 'bytes').end();
+                return;
+            }
+            range = {
+                start: Number(match[1]),
+                ...(match[2] ? { end: Number(match[2]) } : {}),
+            };
+        }
+        const opened = await galleryService.openMediaContent(mediaId, userId(req), range, requestAbort.signal);
+        if (!opened) {
+            res.status(404).json({ success: false, message: 'Media not found' });
+            return;
+        }
+        if (!isSafeMediaMimeType(opened.record.kind, opened.record.mimeType)) {
             res
                 .status(422)
                 .json({ success: false, message: 'Stored media type is invalid' });
             return;
         }
-        const data = Buffer.from(match[2], 'base64');
-        if (data.length > 200 * 1024 * 1024) {
-            res.status(413).json({ success: false, message: 'Media is too large' });
-            return;
-        }
+        res.status(opened.content.range ? 206 : 200);
         res.set({
-            'Content-Type': encodedMimeType,
-            'Content-Length': String(data.length),
+            'Content-Type': opened.record.mimeType,
+            'Content-Length': String(opened.content.range?.length ?? opened.content.descriptor.size),
+            'Accept-Ranges': 'bytes',
             'Cache-Control': 'private, max-age=300',
             'Content-Security-Policy': "default-src 'none'; sandbox",
             'X-Content-Type-Options': 'nosniff',
         });
-        res.send(data);
-        return;
+        if (opened.content.range) {
+            res.set('Content-Range', `bytes ${opened.content.range.start}-${opened.content.range.end}/${opened.content.range.total}`);
+        }
+        opened.content.body.on('error', error => res.destroy(error));
+        opened.content.body.pipe(res);
     }
-    try {
-        const url = new URL(item.mediaData);
-        if (item.kind !== 'image' ||
-            (url.protocol !== 'http:' && url.protocol !== 'https:')) {
-            throw new Error();
+    catch (error) {
+        if (requestAbort.signal.aborted)
+            return;
+        if (error &&
+            typeof error === 'object' &&
+            'code' in error &&
+            error.code === 'invalid-range') {
+            res.status(416).set('Accept-Ranges', 'bytes').end();
+            return;
         }
-        res.redirect(302, url.toString());
+        logger.error('Gallery media stream failed:', error);
+        res.status(500).json({ success: false, message: 'Failed to read media' });
     }
-    catch {
-        res
-            .status(422)
-            .json({ success: false, message: 'Stored media is invalid' });
+    finally {
+        requestAbort.cleanup();
     }
 });
-router.delete('/gallery/:mediaId', galleryRateLimiter, (req, res) => {
+router.delete('/gallery/:mediaId', galleryRateLimiter, async (req, res) => {
     const mediaId = Array.isArray(req.params.mediaId)
         ? req.params.mediaId[0]
         : req.params.mediaId;
-    const deleted = galleryService.deleteMedia(mediaId, userId(req));
+    const deleted = await galleryService.deleteMedia(mediaId, userId(req));
     if (!deleted) {
         res.status(404).json({ success: false, message: 'Media not found' });
         return;
@@ -405,7 +847,7 @@ function isGeneratedAudioFormat(value) {
     return (typeof value === 'string' &&
         ['wav', 'mp3', 'flac', 'opus', 'pcm16'].includes(value));
 }
-function publicJob(job) {
+async function publicJob(job, id) {
     return {
         id: job.id,
         status: job.status,
@@ -415,6 +857,10 @@ function publicJob(job) {
         error: job.error,
         createdAt: job.createdAt,
         updatedAt: job.updatedAt,
+        prompt: job.prompt,
+        cancellable: (job.status === 'pending' || job.status === 'in_progress') &&
+            job.providerJobId !== 'libre:prepared' &&
+            (await pluginService.canCancelVideoGenRequest(job.model, job.pluginId, id)),
     };
 }
 function publicMedia(media) {