ysk-omni 1.0.0

package/dist/controllers/admin/media.handlers.js

@@ -0,0 +1,637 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adminMediaHandlers = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const zod_1 = require("zod");
+const database_1 = require("../../config/database");
+const env_1 = require("../../config/env");
+const constants_1 = require("../../config/constants");
+const images_dto_1 = require("../../dto/images.dto");
+const exception_factory_1 = require("../../exceptions/exception.factory");
+const async_handler_1 = require("../../utils/async-handler");
+const api_key_service_1 = require("../../services/api-key.service");
+const audit_service_1 = require("../../services/audit.service");
+const document_service_1 = require("../../services/document.service");
+const media_jobs_service_1 = require("../../services/media/media-jobs.service");
+const media_orchestrator_service_1 = require("../../services/media/media-orchestrator.service");
+const media_store_service_1 = require("../../services/media/media-store.service");
+const audio_worker_1 = require("../../services/media/audio-worker");
+const format_convert_1 = require("../../services/media/format-convert");
+const client_ip_1 = require("../../utils/client-ip");
+const list_sort_1 = require("../../utils/list-sort");
+const MEDIA_ASSET_SORT_FIELDS = [
+    'createdAt',
+    'kind',
+    'mime',
+    'byteSize',
+    'provider',
+    'originalName',
+];
+const MEDIA_JOB_SORT_FIELDS = [
+    'createdAt',
+    'status',
+    'kind',
+    'completedAt',
+];
+function mediaRoot() {
+    return node_path_1.default.join(env_1.env.storageDir, 'media');
+}
+/** Admin: browse / download / delete generated media + video jobs */
+exports.adminMediaHandlers = {
+    listAssets: (0, async_handler_1.asyncHandler)(async (req, res) => {
+        const limit = Math.min(Math.max(Number(req.query.limit) || 50, 1), 200);
+        const offset = Math.max(Number(req.query.offset) || 0, 0);
+        const kind = typeof req.query.kind === 'string' && req.query.kind
+            ? String(req.query.kind)
+            : undefined;
+        const provider = typeof req.query.provider === 'string' && req.query.provider
+            ? String(req.query.provider)
+            : undefined;
+        const q = typeof req.query.q === 'string' && req.query.q.trim()
+            ? String(req.query.q).trim()
+            : undefined;
+        const fromRaw = typeof req.query.from === 'string' ? req.query.from : undefined;
+        const toRaw = typeof req.query.to === 'string' ? req.query.to : undefined;
+        const sortBy = typeof req.query.sortBy === 'string' ? req.query.sortBy : undefined;
+        const sortDir = typeof req.query.sortDir === 'string' ? req.query.sortDir : undefined;
+        const createdAt = {};
+        if (fromRaw) {
+            const d = new Date(fromRaw);
+            if (!Number.isNaN(d.getTime()))
+                createdAt.gte = d;
+        }
+        if (toRaw) {
+            const d = new Date(toRaw);
+            if (!Number.isNaN(d.getTime()))
+                createdAt.lte = d;
+        }
+        const where = {
+            deletedAt: null,
+            ...(kind ? { kind } : {}),
+            ...(provider ? { provider: { contains: provider } } : {}),
+            ...(Object.keys(createdAt).length ? { createdAt } : {}),
+            ...(q
+                ? {
+                    OR: [
+                        { prompt: { contains: q } },
+                        { originalName: { contains: q } },
+                        { mime: { contains: q } },
+                        { provider: { contains: q } },
+                        { id: { contains: q } },
+                        { source: { contains: q } },
+                    ],
+                }
+                : {}),
+        };
+        const orderBy = (0, list_sort_1.resolveScalarOrderBy)(sortBy, sortDir, MEDIA_ASSET_SORT_FIELDS, 'createdAt');
+        const [rows, total] = await Promise.all([
+            database_1.prisma.mediaAsset.findMany({
+                where,
+                orderBy,
+                take: limit,
+                skip: offset,
+                select: {
+                    id: true,
+                    kind: true,
+                    mime: true,
+                    byteSize: true,
+                    originalName: true,
+                    source: true,
+                    provider: true,
+                    prompt: true,
+                    createdAt: true,
+                    apiKeyId: true,
+                    apiKey: { select: { name: true, keyPrefix: true } },
+                },
+            }),
+            database_1.prisma.mediaAsset.count({ where }),
+        ]);
+        res.json({
+            object: 'list',
+            total,
+            limit,
+            offset,
+            data: rows.map((r) => ({
+                id: r.id,
+                kind: r.kind,
+                mime: r.mime,
+                bytes: r.byteSize,
+                filename: r.originalName,
+                source: r.source,
+                provider: r.provider,
+                prompt: r.prompt,
+                created_at: r.createdAt.toISOString(),
+                apiKeyId: r.apiKeyId,
+                apiKeyName: r.apiKey?.name,
+                apiKeyPrefix: r.apiKey?.keyPrefix,
+            })),
+        });
+    }),
+    getAsset: (0, async_handler_1.asyncHandler)(async (req, res) => {
+        const id = String(req.params.id);
+        const row = await database_1.prisma.mediaAsset.findFirst({
+            where: { id, deletedAt: null },
+            include: { apiKey: { select: { name: true, keyPrefix: true } } },
+        });
+        if (!row)
+            throw exception_factory_1.ExceptionFactory.notFound('Media asset');
+        res.json({
+            object: 'admin.media_asset',
+            data: {
+                id: row.id,
+                kind: row.kind,
+                mime: row.mime,
+                bytes: row.byteSize,
+                filename: row.originalName,
+                source: row.source,
+                provider: row.provider,
+                prompt: row.prompt,
+                meta: row.metaJson,
+                created_at: row.createdAt.toISOString(),
+                apiKeyId: row.apiKeyId,
+                apiKeyName: row.apiKey?.name,
+                apiKeyPrefix: row.apiKey?.keyPrefix,
+            },
+        });
+    }),
+    downloadAsset: (0, async_handler_1.asyncHandler)(async (req, res) => {
+        const id = String(req.params.id);
+        const row = await database_1.prisma.mediaAsset.findFirst({
+            where: { id, deletedAt: null },
+        });
+        if (!row)
+            throw exception_factory_1.ExceptionFactory.notFound('Media asset');
+        const full = node_path_1.default.join(mediaRoot(), row.storagePath);
+        const bytes = await node_fs_1.promises.readFile(full);
+        res.setHeader('Content-Type', row.mime);
+        if (row.originalName) {
+            res.setHeader('Content-Disposition', `inline; filename="${row.originalName.replace(/"/g, '')}"`);
+        }
+        res.setHeader('Content-Length', String(bytes.length));
+        res.status(200).send(bytes);
+    }),
+    deleteAsset: (0, async_handler_1.asyncHandler)(async (req, res) => {
+        if (!req.apiKey)
+            throw exception_factory_1.ExceptionFactory.unauthorized();
+        const id = String(req.params.id);
+        const row = await database_1.prisma.mediaAsset.findFirst({
+            where: { id, deletedAt: null },
+        });
+        if (!row)
+            throw exception_factory_1.ExceptionFactory.notFound('Media asset');
+        await database_1.prisma.mediaAsset.update({
+            where: { id },
+            data: { deletedAt: new Date() },
+        });
+        await audit_service_1.auditService.log({
+            apiKeyId: req.apiKey.id,
+            action: constants_1.AUDIT_ACTIONS.MEDIA_DELETE,
+            resource: 'media_asset',
+            resourceId: id,
+            ip: (0, client_ip_1.requestIp)(req),
+        });
+        res.json({ object: 'admin.media_asset.deleted', id, deleted: true });
+    }),
+    listJobs: (0, async_handler_1.asyncHandler)(async (req, res) => {
+        const limit = Math.min(Math.max(Number(req.query.limit) || 50, 1), 200);
+        const offset = Math.max(Number(req.query.offset) || 0, 0);
+        const sortBy = typeof req.query.sortBy === 'string' ? req.query.sortBy : undefined;
+        const sortDir = typeof req.query.sortDir === 'string' ? req.query.sortDir : undefined;
+        const orderBy = (0, list_sort_1.resolveScalarOrderBy)(sortBy, sortDir, MEDIA_JOB_SORT_FIELDS, 'createdAt');
+        const [rows, total] = await Promise.all([
+            database_1.prisma.mediaJob.findMany({
+                orderBy,
+                take: limit,
+                skip: offset,
+            }),
+            database_1.prisma.mediaJob.count(),
+        ]);
+        res.json({
+            object: 'list',
+            total,
+            data: rows.map((r) => ({
+                id: r.id,
+                kind: r.kind,
+                status: r.status,
+                prompt: r.prompt,
+                model: r.model,
+                provider: r.provider,
+                result_asset_id: r.resultAssetId,
+                error: r.errorMessage,
+                created_at: r.createdAt.toISOString(),
+                completed_at: r.completedAt?.toISOString() ?? null,
+            })),
+        });
+    }),
+    /**
+     * Admin SPA image generation (uses session admin actor or optional agent apiKeyId).
+     * Body mirrors POST /v1/images/generations + optional apiKeyId + aspect_ratio.
+     */
+    generateImage: (0, async_handler_1.asyncHandler)(async (req, res) => {
+        if (!req.apiKey)
+            throw exception_factory_1.ExceptionFactory.unauthorized();
+        const body = req.body;
+        const actor = await resolveMediaActor(req, body.apiKeyId);
+        const host = req.get('host') || '127.0.0.1';
+        const proto = req.protocol || 'http';
+        const baseUrl = `${proto}://${host}`;
+        const result = await media_orchestrator_service_1.mediaOrchestratorService.generateImages({
+            apiKey: actor,
+            prompt: body.prompt,
+            model: body.model,
+            n: body.n ?? 1,
+            size: body.size,
+            aspectRatio: body.aspect_ratio,
+            responseFormat: body.response_format || 'url',
+            format: body.format,
+            baseUrl,
+            ip: (0, client_ip_1.requestIp)(req),
+        });
+        await audit_service_1.auditService.log({
+            apiKeyId: req.apiKey.id,
+            action: constants_1.AUDIT_ACTIONS.MEDIA_GENERATE,
+            resource: 'media_asset',
+            resourceId: result.omni?.asset_ids?.[0],
+            meta: {
+                via: 'admin.media.generate',
+                asKeyId: actor.id,
+                asKeyName: actor.name,
+                count: result.omni?.asset_ids?.length ?? 0,
+                aspect_ratio: body.aspect_ratio || body.size || null,
+            },
+            ip: (0, client_ip_1.requestIp)(req),
+        });
+        res.status(200).json({
+            object: 'admin.media.generate',
+            data: result,
+        });
+    }),
+    /**
+     * Admin SPA image edit.
+     * Source (any one): multipart `image`, `sourceAssetId` (media), or `sourceDocumentId` (documents).
+     */
+    editImage: (0, async_handler_1.asyncHandler)(async (req, res) => {
+        if (!req.apiKey)
+            throw exception_factory_1.ExceptionFactory.unauthorized();
+        const files = req.files;
+        const image = files?.image?.[0];
+        const parsed = images_dto_1.createImageEditSchema
+            .extend({
+            apiKeyId: zod_1.z.string().uuid().optional(),
+            sourceAssetId: zod_1.z.string().uuid().optional(),
+            sourceDocumentId: zod_1.z.string().uuid().optional(),
+            // form fields may arrive as snake_case from multipart
+            source_asset_id: zod_1.z.string().uuid().optional(),
+            source_document_id: zod_1.z.string().uuid().optional(),
+        })
+            .safeParse(req.body);
+        if (!parsed.success) {
+            throw exception_factory_1.ExceptionFactory.validation('Invalid image edit body', parsed.error.issues);
+        }
+        const body = parsed.data;
+        const actor = await resolveMediaActor(req, body.apiKeyId);
+        const mask = files?.mask?.[0];
+        const source = await resolveMediaSourceBytes({
+            file: image,
+            sourceAssetId: body.sourceAssetId || body.source_asset_id,
+            sourceDocumentId: body.sourceDocumentId || body.source_document_id,
+            requireImage: true,
+        });
+        const host = req.get('host') || '127.0.0.1';
+        const proto = req.protocol || 'http';
+        const baseUrl = `${proto}://${host}`;
+        const result = await media_orchestrator_service_1.mediaOrchestratorService.editImages({
+            apiKey: actor,
+            prompt: body.prompt,
+            imageBytes: source.bytes,
+            imageMime: source.mime,
+            maskBytes: mask?.buffer,
+            model: body.model,
+            n: body.n ?? 1,
+            size: body.size,
+            aspectRatio: body.aspect_ratio,
+            responseFormat: body.response_format || 'url',
+            baseUrl,
+            ip: (0, client_ip_1.requestIp)(req),
+        });
+        await audit_service_1.auditService.log({
+            apiKeyId: req.apiKey.id,
+            action: constants_1.AUDIT_ACTIONS.MEDIA_GENERATE,
+            resource: 'media_asset',
+            resourceId: result.omni?.asset_ids?.[0],
+            meta: {
+                via: 'admin.media.edit',
+                asKeyId: actor.id,
+                count: result.omni?.asset_ids?.length ?? 0,
+                sourceKind: source.kind,
+                sourceId: source.id,
+            },
+            ip: (0, client_ip_1.requestIp)(req),
+        });
+        res.status(200).json({
+            object: 'admin.media.edit',
+            data: result,
+        });
+    }),
+    /**
+     * Admin SPA: enqueue video job.
+     * Source frame (optional): multipart `image`, media asset id, or document id.
+     * If none, a frame is generated from the prompt first (image-to-video).
+     */
+    createVideo: (0, async_handler_1.asyncHandler)(async (req, res) => {
+        if (!req.apiKey)
+            throw exception_factory_1.ExceptionFactory.unauthorized();
+        const files = req.files;
+        const image = files?.image?.[0];
+        // Body may be JSON or multipart form fields (all strings)
+        const raw = req.body || {};
+        const prompt = String(raw.prompt || '').trim();
+        if (!prompt) {
+            throw exception_factory_1.ExceptionFactory.validation('prompt is required');
+        }
+        const secondsRaw = raw.seconds !== undefined ? Number(raw.seconds) : 6;
+        const seconds = Number.isFinite(secondsRaw) && secondsRaw >= 1 && secondsRaw <= 15
+            ? Math.round(secondsRaw)
+            : 6;
+        const voicesRaw = raw.voices;
+        const voices = Array.isArray(voicesRaw)
+            ? voicesRaw.map(String).filter(Boolean)
+            : typeof voicesRaw === 'string' && voicesRaw.trim()
+                ? voicesRaw.split(',').map((s) => s.trim()).filter(Boolean)
+                : undefined;
+        if (voices?.length) {
+            const { VIDEO_VOICES } = await Promise.resolve().then(() => __importStar(require('../../config/constants')));
+            const allowed = new Set(VIDEO_VOICES);
+            const bad = voices.filter((v) => !allowed.has(v));
+            if (bad.length) {
+                throw exception_factory_1.ExceptionFactory.validation(`Unknown video voice(s): ${bad.join(', ')}. Allowed: ${VIDEO_VOICES.join(', ')}`);
+            }
+        }
+        const model = typeof raw.model === 'string' && raw.model.trim()
+            ? raw.model.trim()
+            : undefined;
+        const aspectRatio = typeof raw.aspect_ratio === 'string' && raw.aspect_ratio.trim()
+            ? raw.aspect_ratio.trim()
+            : undefined;
+        const apiKeyId = typeof raw.apiKeyId === 'string' && raw.apiKeyId
+            ? raw.apiKeyId
+            : undefined;
+        const sourceAssetId = (typeof raw.source_asset_id === 'string' && raw.source_asset_id) ||
+            (typeof raw.sourceAssetId === 'string' && raw.sourceAssetId) ||
+            undefined;
+        const sourceDocumentId = (typeof raw.source_document_id === 'string' && raw.source_document_id) ||
+            (typeof raw.sourceDocumentId === 'string' && raw.sourceDocumentId) ||
+            undefined;
+        const actor = await resolveMediaActor(req, apiKeyId);
+        let sourceBytes;
+        if (image?.buffer?.length || sourceAssetId || sourceDocumentId) {
+            const src = await resolveMediaSourceBytes({
+                file: image,
+                sourceAssetId: sourceAssetId || undefined,
+                sourceDocumentId: sourceDocumentId || undefined,
+                requireImage: true,
+            });
+            sourceBytes = src.bytes;
+        }
+        const job = await media_jobs_service_1.mediaJobsService.createVideo({
+            apiKey: actor,
+            prompt,
+            model,
+            seconds,
+            aspectRatio,
+            sourceAssetId: sourceBytes ? undefined : sourceAssetId || undefined,
+            sourceDocumentId: sourceBytes ? undefined : sourceDocumentId || undefined,
+            sourceBytes,
+            voices,
+            format: typeof raw.format === 'string' ? raw.format : undefined,
+        });
+        await audit_service_1.auditService.log({
+            apiKeyId: req.apiKey.id,
+            action: constants_1.AUDIT_ACTIONS.MEDIA_GENERATE,
+            resource: 'media_job',
+            resourceId: job.id,
+            meta: {
+                via: 'admin.media.video',
+                asKeyId: actor.id,
+                seconds,
+                hasUpload: Boolean(image?.buffer?.length),
+                source_asset_id: sourceAssetId || null,
+                source_document_id: sourceDocumentId || null,
+            },
+            ip: (0, client_ip_1.requestIp)(req),
+        });
+        res.status(200).json({
+            object: 'admin.media.video',
+            data: job,
+        });
+    }),
+    speech: (0, async_handler_1.asyncHandler)(async (req, res) => {
+        if (!req.apiKey)
+            throw exception_factory_1.ExceptionFactory.unauthorized();
+        const raw = req.body;
+        const input = String(raw.input || raw.prompt || '').trim();
+        if (!input)
+            throw exception_factory_1.ExceptionFactory.validation('input is required');
+        const actor = await resolveMediaActor(req, raw.apiKeyId);
+        const { bytes, mime } = await (0, audio_worker_1.synthesizeSpeech)({
+            input,
+            voice: raw.voice,
+            model: raw.model,
+            response_format: raw.format || raw.response_format || 'wav',
+            apiKey: actor,
+        });
+        const stored = await media_store_service_1.mediaStoreService.save({
+            apiKeyId: actor.id,
+            kind: 'audio',
+            mime,
+            bytes,
+            originalName: `speech-${Date.now()}${mime.includes('mpeg') ? '.mp3' : mime.includes('ogg') ? '.opus' : mime.includes('flac') ? '.flac' : mime.includes('aac') ? '.aac' : '.wav'}`,
+            source: 'generation',
+            provider: 'tts',
+            prompt: input,
+        });
+        await audit_service_1.auditService.log({
+            apiKeyId: req.apiKey.id,
+            action: constants_1.AUDIT_ACTIONS.MEDIA_GENERATE,
+            resource: 'media_asset',
+            resourceId: stored.id,
+            meta: { via: 'admin.media.speech', asKeyId: actor.id, bytes: stored.byteSize },
+            ip: (0, client_ip_1.requestIp)(req),
+        });
+        res.status(200).json({
+            object: 'admin.media.speech',
+            data: {
+                asset_id: stored.id,
+                mime: stored.mime,
+                bytes: stored.byteSize,
+            },
+        });
+    }),
+    transcribe: (0, async_handler_1.asyncHandler)(async (req, res) => {
+        if (!req.apiKey)
+            throw exception_factory_1.ExceptionFactory.unauthorized();
+        const files = req.files;
+        const file = files?.file?.[0] ||
+            req.file;
+        const raw = req.body || {};
+        const sourceAssetId = (typeof raw.sourceAssetId === 'string' && raw.sourceAssetId) ||
+            (typeof raw.source_asset_id === 'string' && raw.source_asset_id) ||
+            undefined;
+        const sourceDocumentId = (typeof raw.sourceDocumentId === 'string' && raw.sourceDocumentId) ||
+            (typeof raw.source_document_id === 'string' && raw.source_document_id) ||
+            undefined;
+        const apiKeyId = typeof raw.apiKeyId === 'string' && raw.apiKeyId
+            ? raw.apiKeyId
+            : undefined;
+        const src = await resolveMediaSourceBytes({
+            file,
+            sourceAssetId,
+            sourceDocumentId,
+            requireAudio: true,
+        });
+        const actor = await resolveMediaActor(req, apiKeyId);
+        const model = typeof raw.model === 'string' && raw.model.trim()
+            ? raw.model.trim()
+            : undefined;
+        const { text } = await (0, audio_worker_1.transcribeAudio)({
+            bytes: src.bytes,
+            filename: src.name || 'audio.wav',
+            mime: src.mime,
+            model,
+            apiKey: actor,
+        });
+        const formatted = (0, format_convert_1.formatTranscript)(text, String(raw.format || 'txt'));
+        const stored = await media_store_service_1.mediaStoreService.save({
+            apiKeyId: actor.id,
+            kind: 'file',
+            mime: formatted.mime,
+            bytes: formatted.bytes,
+            originalName: `transcript-${Date.now()}.${formatted.format}`,
+            source: 'transcription',
+            provider: 'stt',
+            prompt: src.name || src.id || 'audio',
+            meta: { sourceKind: src.kind, sourceId: src.id || null },
+        });
+        await audit_service_1.auditService.log({
+            apiKeyId: req.apiKey.id,
+            action: constants_1.AUDIT_ACTIONS.MEDIA_GENERATE,
+            resource: 'media_asset',
+            resourceId: stored.id,
+            meta: { via: 'admin.media.transcribe', asKeyId: actor.id },
+            ip: (0, client_ip_1.requestIp)(req),
+        });
+        res.status(200).json({
+            object: 'admin.media.transcribe',
+            data: { text, asset_id: stored.id },
+        });
+    }),
+};
+async function resolveMediaActor(req, apiKeyId) {
+    if (!req.apiKey)
+        throw exception_factory_1.ExceptionFactory.unauthorized();
+    let actor = req.apiKey;
+    if (apiKeyId && apiKeyId !== req.apiKey.id) {
+        if (!String(apiKeyId).startsWith('admin-session:')) {
+            actor = await api_key_service_1.apiKeyService.getByIdForAuth(apiKeyId);
+        }
+    }
+    return actor;
+}
+/**
+ * Resolve image bytes from upload, media asset, or documents library.
+ * Admin may read any non-deleted system file.
+ */
+async function resolveMediaSourceBytes(input) {
+    if (input.file?.buffer?.length) {
+        return {
+            bytes: input.file.buffer,
+            mime: input.file.mimetype || 'application/octet-stream',
+            kind: 'upload',
+            name: input.file.originalname,
+        };
+    }
+    if (input.sourceAssetId) {
+        const row = await database_1.prisma.mediaAsset.findFirst({
+            where: { id: input.sourceAssetId, deletedAt: null },
+        });
+        if (!row)
+            throw exception_factory_1.ExceptionFactory.notFound('Media asset');
+        if (input.requireImage && !String(row.mime || '').startsWith('image/')) {
+            throw exception_factory_1.ExceptionFactory.validation('Source media asset must be an image for image_edit / image_to_video', { reason: 'source_must_be_image' });
+        }
+        if (input.requireAudio && !String(row.mime || '').startsWith('audio/')) {
+            throw exception_factory_1.ExceptionFactory.validation('Source media asset must be audio for transcription', { reason: 'source_must_be_audio' });
+        }
+        const full = node_path_1.default.join(mediaRoot(), row.storagePath);
+        const bytes = await node_fs_1.promises.readFile(full);
+        return {
+            bytes,
+            mime: row.mime,
+            kind: 'asset',
+            id: row.id,
+            name: row.originalName || row.id,
+        };
+    }
+    if (input.sourceDocumentId) {
+        const doc = await database_1.prisma.document.findFirst({
+            where: { id: input.sourceDocumentId, deletedAt: null },
+        });
+        if (!doc)
+            throw exception_factory_1.ExceptionFactory.notFound('Document');
+        if (input.requireImage && !String(doc.mimeType || '').startsWith('image/')) {
+            throw exception_factory_1.ExceptionFactory.validation('Source document must be an image for image_edit / image_to_video', { reason: 'source_must_be_image' });
+        }
+        if (input.requireAudio && !String(doc.mimeType || '').startsWith('audio/')) {
+            throw exception_factory_1.ExceptionFactory.validation('Source document must be audio for transcription', { reason: 'source_must_be_audio' });
+        }
+        const bytes = await document_service_1.documentService.readDecryptedContent(doc.apiKeyId, doc.id);
+        return {
+            bytes,
+            mime: doc.mimeType,
+            kind: 'document',
+            id: doc.id,
+            name: doc.originalName,
+        };
+    }
+    throw exception_factory_1.ExceptionFactory.validation(input.requireAudio
+        ? 'Provide an audio file, sourceAssetId, or sourceDocumentId'
+        : 'Provide an image file, sourceAssetId, or sourceDocumentId', { reason: 'source_required' });
+}
+//# sourceMappingURL=media.handlers.js.map