videobook 0.0.0-stage → 0.2.0

package/dist/tools/export-sequence.js

@@ -0,0 +1,250 @@
+import { v7 as uuidv7 } from "uuid";
+import { z } from "zod";
+import { queue } from "../queue.js";
+import { sequenceContinuationRevision } from "./command-plan.js";
+const exportSettingsSchema = z.object({
+    sequence_revision: z.string().min(1),
+    orientation: z.enum(["landscape", "portrait", "square"]),
+    captions: z.enum(["burn-in", "sidecar", "omit"]),
+});
+function json(value) {
+    return { content: [{ type: "text", text: JSON.stringify(value) }] };
+}
+export function sequenceExportDimensions(orientation) {
+    if (orientation === "portrait")
+        return [1080, 1920];
+    if (orientation === "square")
+        return [1080, 1080];
+    return [1920, 1080];
+}
+function sequenceDuration(sequence) {
+    return Math.max(0, ...sequence.clips.map((clip) => clip.timelineStartFrame + clip.durationFrames), ...sequence.captions.map((cue) => cue.timelineStartFrame + cue.durationFrames));
+}
+export async function validateSequenceExport(engine, settings) {
+    const sequence = engine.sequences.getPrimary();
+    const errors = [];
+    const warnings = [];
+    const objectHashes = new Set();
+    const [width, height] = sequenceExportDimensions(settings.orientation);
+    const durationFrames = sequenceDuration(sequence);
+    if (settings.sequence_revision !== sequence.revision
+        || settings.sequence_revision !== engine.head) {
+        errors.push({
+            code: "STALE_REVISION",
+            message: `Requested ${settings.sequence_revision} but the current revision is ${engine.head}`,
+        });
+    }
+    if (durationFrames < 1) {
+        errors.push({
+            code: "EMPTY_SEQUENCE",
+            message: "The sequence has no playable duration",
+        });
+    }
+    const enabledTracks = new Map(sequence.tracks
+        .filter((track) => track.enabled)
+        .map((track) => [track.trackId, track]));
+    for (const clip of sequence.clips.filter((candidate) => candidate.enabled)) {
+        const track = enabledTracks.get(clip.trackId);
+        if (!track || track.kind === "caption") {
+            errors.push({
+                code: "MISSING_TRACK",
+                message: "The clip is not on an enabled media track",
+                clipId: clip.clipId,
+            });
+            continue;
+        }
+        const transform = clip.transform;
+        if (transform
+            && (transform.anchorX !== 0.5
+                || transform.anchorY !== 0.5
+                || transform.cropLeft + transform.cropRight >= 1
+                || transform.cropTop + transform.cropBottom >= 1)) {
+            errors.push({
+                code: "UNSUPPORTED_EFFECT",
+                message: "This export renderer requires a centered anchor and non-empty crop",
+                clipId: clip.clipId,
+            });
+        }
+        const artifact = engine.artifacts.get(clip.source.artifactId);
+        if (!artifact.ok) {
+            errors.push({
+                code: "MISSING_MEDIA",
+                message: artifact.error.message,
+                clipId: clip.clipId,
+            });
+            continue;
+        }
+        const manifest = await engine.files.manifest(artifact.value.artifactId);
+        if (!manifest.ok) {
+            errors.push({
+                code: "OFFLINE_OBJECT",
+                message: manifest.error.message,
+                clipId: clip.clipId,
+            });
+            continue;
+        }
+        let expectedHash;
+        let sourcePath;
+        if (clip.source.kind === "timed") {
+            expectedHash = clip.source.range.objectHash;
+            const streamId = clip.source.range.streamId;
+            const streams = engine.streams.list(artifact.value.artifactId);
+            sourcePath = streams.ok
+                ? streams.value.find((stream) => stream.streamId === streamId)?.sourcePath
+                : undefined;
+        }
+        else {
+            expectedHash = clip.source.objectHash;
+            sourcePath = clip.source.sourcePath;
+        }
+        const file = manifest.value.files.find((candidate) => candidate.objectHash === expectedHash
+            && (sourcePath === undefined || candidate.name === sourcePath));
+        if (!file) {
+            errors.push({
+                code: "SOURCE_REPLACED",
+                message: "The immutable source snapshot is not available locally",
+                clipId: clip.clipId,
+            });
+            continue;
+        }
+        objectHashes.add(file.objectHash);
+    }
+    if (settings.captions !== "omit") {
+        for (const cue of sequence.captions) {
+            const seconds = cue.durationFrames
+                * sequence.frameRate.denominator
+                / sequence.frameRate.numerator;
+            if (cue.text.length > Math.max(42, Math.floor(seconds * 28))) {
+                warnings.push({
+                    code: "CAPTION_OVERFLOW",
+                    message: "Caption text may not fit its display duration",
+                    cueId: cue.cueId,
+                });
+            }
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        sequenceId: sequence.sequenceId,
+        revision: sequence.revision,
+        durationFrames,
+        orientation: settings.orientation,
+        width,
+        height,
+        captions: settings.captions,
+        inputObjectHashes: [...objectHashes].sort(),
+        errors,
+        warnings,
+    };
+}
+export function exportSequenceDefs(engine) {
+    return [
+        {
+            name: "validate_sequence_export",
+            description: "Validate a revision-pinned canonical sequence export and resolve immutable inputs",
+            scope: "book",
+            schema: {
+                book_id: z.string().uuid(),
+                ...exportSettingsSchema.shape,
+            },
+            handler: async (args) => json(await validateSequenceExport(engine, args)),
+        },
+        {
+            name: "plan_sequence_export",
+            description: "Create a queued export CommandPlan for a validated canonical sequence revision",
+            scope: "book",
+            schema: {
+                book_id: z.string().uuid(),
+                source_surface: z.enum(["ui", "slash", "chat"]),
+                actor: z.string().min(1),
+                ...exportSettingsSchema.shape,
+            },
+            handler: async (args) => {
+                const settings = args;
+                const validation = await validateSequenceExport(engine, settings);
+                if (!validation.valid)
+                    return json({ kind: "invalid-export", validation });
+                const planId = uuidv7();
+                return json({
+                    planVersion: 1,
+                    planId,
+                    sourceSurface: args.source_surface,
+                    actor: args.actor,
+                    bookId: engine.book.get().bookId,
+                    summary: `Export ${validation.orientation} MP4`,
+                    normalizedReferences: [{
+                            kind: "sequence",
+                            targetId: validation.sequenceId,
+                            revision: validation.revision,
+                        }],
+                    stages: [
+                        {
+                            stageId: `${planId}:export:0`,
+                            kind: "export",
+                            summary: "Validate final render settings",
+                            sequenceId: validation.sequenceId,
+                            revision: validation.revision,
+                            orientation: validation.orientation,
+                            captions: validation.captions,
+                        },
+                        {
+                            stageId: `${planId}:queued:1`,
+                            kind: "queued",
+                            summary: "Render H.264/AAC MP4",
+                            jobType: "export",
+                            tool: "export_sequence",
+                            input: {
+                                sequence_revision: validation.revision,
+                                sequence_content_revision: sequenceContinuationRevision(engine.sequences.getPrimary()),
+                                orientation: validation.orientation,
+                                captions: validation.captions,
+                                width: validation.width,
+                                height: validation.height,
+                                input_object_hashes: validation.inputObjectHashes,
+                            },
+                            insertsOutput: false,
+                        },
+                    ],
+                    confirmation: {
+                        required: true,
+                        policy: "always",
+                        reason: "Export runs as a queued render against this exact revision",
+                    },
+                    validation,
+                });
+            },
+        },
+        {
+            name: "enqueue_sequence_export",
+            description: "Queue a confirmed canonical sequence export after revalidating its exact revision",
+            scope: "book",
+            schema: {
+                book_id: z.string().uuid(),
+                confirm: z.literal(true),
+                ...exportSettingsSchema.shape,
+            },
+            handler: async (args) => {
+                const settings = args;
+                const validation = await validateSequenceExport(engine, settings);
+                if (!validation.valid)
+                    return json({ kind: "invalid-export", validation });
+                const jobId = `export-sequence-${engine.book.get().bookId}-${uuidv7()}`;
+                await queue.enqueue(jobId, {
+                    type: "export_sequence",
+                    bookId: engine.book.get().bookId,
+                    sequenceRevision: validation.revision,
+                    orientation: validation.orientation,
+                    captions: validation.captions,
+                });
+                return json({
+                    status: "enqueued",
+                    jobId,
+                    sequenceId: validation.sequenceId,
+                    sequenceRevision: validation.revision,
+                    orientation: validation.orientation,
+                    captions: validation.captions,
+                });
+            },
+        },
+    ];
+}

package/dist/tools/export-to-downloads.js

@@ -0,0 +1,54 @@
+import { extname, join } from "node:path";
+import { z } from "zod";
+import { findOriginalMediaFile } from "../original-media-file.js";
+import { copyToDownloads } from "../downloads-dest.js";
+export function exportToDownloadsDef(engine) {
+    return {
+        name: "export_to_downloads",
+        description: "Copy an asset's original media file to the user's Downloads folder",
+        schema: {
+            asset_id: z.string().describe("Artifact id"),
+            book_id: z.string().describe("Book UUID"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id: _book_id } = args;
+            const artifactResult = engine.artifacts.get(asset_id);
+            if (!artifactResult.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: artifactResult.error.message }],
+                };
+            }
+            const manifestResult = await engine.files.manifest(asset_id);
+            if (!manifestResult.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: manifestResult.error.message }],
+                };
+            }
+            const manifest = manifestResult.value;
+            const file = findOriginalMediaFile(manifest.files, artifactResult.value.kind);
+            if (!file) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "No original media file found for asset" }],
+                };
+            }
+            const source = join(manifest.path, file.name);
+            const ext = extname(file.name);
+            let dest;
+            try {
+                dest = await copyToDownloads(source, engine.book.get().name, ext);
+            }
+            catch (err) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Failed to copy file: ${err.message}` }],
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify({ status: "exported", path: dest }) }],
+            };
+        },
+    };
+}

package/dist/tools/export-transcript-srt.js

@@ -0,0 +1,79 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+import { copyToDownloads } from "../downloads-dest.js";
+import { PLAIN_TRANSCRIPT_FILE, TIMED_TRANSCRIPT_FILE, timedTranscriptFrom, } from "../transcript-projection.js";
+import { transcriptToSrt } from "../transcript-srt.js";
+function parseJson(value) {
+    try {
+        return JSON.parse(value.toString());
+    }
+    catch {
+        return null;
+    }
+}
+function errorResult(message) {
+    return {
+        isError: true,
+        content: [{ type: "text", text: message }],
+    };
+}
+export function exportTranscriptSrtDef(engine) {
+    return {
+        name: "export_transcript_srt",
+        description: "Render an asset's word-timed ElevenLabs transcript as SubRip (.srt) and save it to the user's Downloads folder. Errors when the asset has no elevenlabs.json timings.",
+        schema: {
+            asset_id: z.string().describe("Artifact id"),
+            book_id: z.string().describe("Book UUID"),
+            downloads_dir: z.string().optional()
+                .describe("Override Downloads directory (tests)"),
+        },
+        handler: async (args) => {
+            const { asset_id, downloads_dir } = args;
+            const artifactResult = engine.artifacts.get(asset_id);
+            if (!artifactResult.ok) {
+                return errorResult(artifactResult.error.message);
+            }
+            const timedRead = await engine.files.read(asset_id, TIMED_TRANSCRIPT_FILE);
+            if (!timedRead.ok) {
+                const plainRead = await engine.files.read(asset_id, PLAIN_TRANSCRIPT_FILE);
+                if (plainRead.ok) {
+                    return errorResult("No word-timed ElevenLabs transcript for this asset. A plain gpt-4o transcription cannot be exported as SRT.");
+                }
+                return errorResult("No word-timed ElevenLabs transcript for this asset. Run /transcribe first.");
+            }
+            const raw = parseJson(timedRead.value);
+            const timed = timedTranscriptFrom(raw);
+            if (!timed || timed.kind !== "timed") {
+                return errorResult("No word-timed ElevenLabs transcript for this asset. A plain gpt-4o transcription cannot be exported as SRT.");
+            }
+            let srt;
+            try {
+                srt = transcriptToSrt({ words: timed.words });
+            }
+            catch (err) {
+                return errorResult(err.message);
+            }
+            const tempDir = await mkdtemp(join(tmpdir(), "videobook-srt-"));
+            let dest;
+            try {
+                const tempPath = join(tempDir, "captions.srt");
+                await writeFile(tempPath, srt, "utf8");
+                dest = await copyToDownloads(tempPath, artifactResult.value.label ?? asset_id, ".srt", downloads_dir);
+            }
+            catch (err) {
+                return errorResult(`Failed to save SRT: ${err.message}`);
+            }
+            finally {
+                await rm(tempDir, { recursive: true, force: true });
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ status: "exported", path: dest }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/extend-audio.js

@@ -0,0 +1,100 @@
+import { join } from "node:path";
+import { findAudioFile } from "videobook-engine";
+import { z } from "zod";
+import { MAX_AUDIO_CONTINUATION_MS, MAX_CONTINUATION_DIRECTION_CHARS, MAX_SOUND_GENERATION_PROMPT_CHARS, MIN_AUDIO_CONTINUATION_MS, normalizeContinuationPrompt, } from "../elevenlabs-audio-extension.js";
+import { probeVideo } from "../ffmpeg.js";
+import { queue } from "../queue.js";
+import { toolError } from "./_shared.js";
+function defaultExtendedName(source, targetDurationSeconds) {
+    const base = source.label ?? source.artifactId;
+    const duration = String(targetDurationSeconds).replace(".", "-");
+    return `extended-${base}-${duration}s`;
+}
+export function extendAudioDef(engine) {
+    return {
+        name: "extend_audio_asset",
+        description: "Extend an audio asset to a total duration with a matching ElevenLabs continuation that keeps the source at the start, as a new audio asset.",
+        schema: {
+            asset_id: z.string().describe("Source audio artifact id"),
+            target_duration_seconds: z.number().positive().describe("Requested total output duration in seconds"),
+            continuation_prompt: z.string().min(1).max(MAX_SOUND_GENERATION_PROMPT_CHARS).optional().describe('Optional direction for what should follow the source audio, e.g. "add outro music"'),
+            asset_name: z.string().min(1).optional().describe("Optional name for the new audio asset"),
+            book_id: z.string().describe("Book UUID"),
+        },
+        handler: async (args) => {
+            const { asset_id, target_duration_seconds, continuation_prompt, asset_name, book_id, } = args;
+            if (!process.env.ELEVENLABS_API_KEY) {
+                return toolError("ELEVENLABS_API_KEY environment variable is not set");
+            }
+            const sourceAssetId = asset_id.replace(/^@/, "");
+            const sourceArtifact = engine.artifacts.get(sourceAssetId);
+            if (!sourceArtifact.ok)
+                return toolError(sourceArtifact.error.message);
+            if (sourceArtifact.value.kind !== "audio") {
+                return toolError(`extend_audio requires an audio source, got ${sourceArtifact.value.kind} artifact ${sourceAssetId}`);
+            }
+            const continuationPrompt = normalizeContinuationPrompt(continuation_prompt);
+            if (continuationPrompt && continuationPrompt.length > MAX_CONTINUATION_DIRECTION_CHARS) {
+                return toolError(`continuation_prompt supports at most ${MAX_CONTINUATION_DIRECTION_CHARS} characters of direction`);
+            }
+            const manifest = await engine.files.manifest(sourceAssetId);
+            if (!manifest.ok)
+                return toolError(manifest.error.message);
+            const audioFile = findAudioFile(manifest.value.files, sourceArtifact.value.kind);
+            if (!audioFile)
+                return toolError(`No audio file found in artifact ${sourceAssetId}`);
+            let sourceDurationSeconds;
+            try {
+                const probe = await probeVideo(join(manifest.value.path, audioFile.name));
+                sourceDurationSeconds = probe.audioDuration ?? probe.duration;
+            }
+            catch (error) {
+                return toolError(`Failed to probe ${sourceAssetId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (!Number.isFinite(sourceDurationSeconds) || sourceDurationSeconds <= 0) {
+                return toolError(`Could not determine a valid duration for ${sourceAssetId}`);
+            }
+            const sourceDurationMs = Math.round(sourceDurationSeconds * 1000);
+            const targetDurationMs = Math.round(target_duration_seconds * 1000);
+            if (targetDurationMs <= sourceDurationMs) {
+                return toolError(`Target duration must exceed the source duration of ${(sourceDurationMs / 1000).toFixed(3)}s`);
+            }
+            const continuationDurationMs = targetDurationMs - sourceDurationMs;
+            if (continuationDurationMs < MIN_AUDIO_CONTINUATION_MS) {
+                return toolError(`ElevenLabs requires at least ${(MIN_AUDIO_CONTINUATION_MS / 1000).toFixed(1)}s of new continuation`);
+            }
+            if (continuationDurationMs > MAX_AUDIO_CONTINUATION_MS) {
+                return toolError(`ElevenLabs Sound Generation supports at most ${(MAX_AUDIO_CONTINUATION_MS / 1000).toFixed(1)}s of new continuation per request`);
+            }
+            const name = asset_name?.trim() || defaultExtendedName(sourceArtifact.value, target_duration_seconds);
+            const created = await engine.artifacts.create("audio", name);
+            if (!created.ok)
+                return toolError(`Failed to create audio asset: ${created.error.message}`);
+            const jobId = `extend-audio-${created.value.artifactId}-${Date.now()}`;
+            await queue.enqueue(jobId, {
+                type: "extend_audio",
+                audAssetId: created.value.artifactId,
+                sourceAssetId,
+                sourceFilename: audioFile.name,
+                sourceDurationMs,
+                targetDurationMs,
+                continuationPrompt,
+                bookId: book_id,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            aud_asset_id: created.value.artifactId,
+                            source_audio_asset_id: sourceAssetId,
+                            source_duration_seconds: sourceDurationMs / 1000,
+                            target_duration_seconds: targetDurationMs / 1000,
+                            continuation_duration_seconds: (targetDurationMs - sourceDurationMs) / 1000,
+                            job_id: jobId,
+                            status: "enqueued",
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/extract-audio.js

@@ -0,0 +1,174 @@
+import { z } from "zod";
+import { join } from "node:path";
+import { queue } from "../queue.js";
+import { findVideoFile } from "videobook-engine";
+import { probeVideo } from "../ffmpeg.js";
+import { validateMediaOutputPaths } from "../media-output-path.js";
+function deriveAudioName(source) {
+    return `ext-${source.label ?? source.artifactId}`;
+}
+export function extractAudioDef(engine) {
+    return {
+        name: "extract_audio",
+        description: "Extract a video's audio as MP3 into a new audio asset, or as a file inside an existing asset with destination. range limits it to a time window.",
+        schema: {
+            asset_id: z.string().describe("Video artifact id"),
+            book_id: z.string().describe("Book UUID"),
+            destination: z
+                .object({
+                asset_id: z.string().describe("Existing artifact id to write the mp3 into"),
+                filename: z.string().describe("Filename for the mp3 inside the destination asset (e.g. \"s1.mp3\")"),
+            })
+                .optional()
+                .describe("When set, write the mp3 to <destination.asset_id>/<destination.filename> instead of minting a fresh audio asset."),
+            range: z
+                .object({
+                start_s: z.number().min(0).describe("Start offset in seconds (inclusive)"),
+                duration_s: z.number().positive().describe("Duration in seconds"),
+            })
+                .optional()
+                .describe("When set, extract only this time window from the source."),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, destination, range } = args;
+            const sourceArtifact = engine.artifacts.get(asset_id);
+            if (!sourceArtifact.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: sourceArtifact.error.message }],
+                };
+            }
+            const manifestResult = await engine.files.manifest(asset_id);
+            if (!manifestResult.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: manifestResult.error.message }],
+                };
+            }
+            const manifest = manifestResult.value;
+            const videoFile = findVideoFile(manifest.files);
+            if (!videoFile) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `No video file found in asset ${asset_id}` }],
+                };
+            }
+            const videoPath = join(manifest.path, videoFile.name);
+            let probe;
+            try {
+                probe = await probeVideo(videoPath);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Failed to probe video: ${msg}` }],
+                };
+            }
+            if (!probe.hasAudio) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Video has no audio stream: ${asset_id}` }],
+                };
+            }
+            const audioDuration = probe.audioDuration ?? probe.duration;
+            if (range && (!Number.isFinite(audioDuration) || range.start_s >= audioDuration)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "Audio range must start before the source audio ends." }],
+                };
+            }
+            let audioAssetId;
+            let audioAssetDir;
+            let outputPath;
+            const destinationMode = destination !== undefined;
+            if (destination !== undefined) {
+                try {
+                    [destination.filename] = await validateMediaOutputPaths(engine, destination.asset_id, [destination.filename], ".mp3");
+                }
+                catch (error) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+                    };
+                }
+                const destManifest = await engine.files.manifest(destination.asset_id);
+                if (!destManifest.ok) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `Destination asset ${destination.asset_id} not found: ${destManifest.error.message}` }],
+                    };
+                }
+                audioAssetId = destination.asset_id;
+                audioAssetDir = destManifest.value.path;
+                outputPath = join(audioAssetDir, destination.filename);
+            }
+            else {
+                const audioName = deriveAudioName(sourceArtifact.value);
+                const assetResult = await engine.artifacts.create("audio", audioName);
+                if (!assetResult.ok) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `Failed to create audio asset: ${assetResult.error.message}` }],
+                    };
+                }
+                audioAssetId = assetResult.value.artifactId;
+                audioAssetDir = assetResult.value.path;
+                outputPath = join(audioAssetDir, "original.mp3");
+            }
+            const jobId = `extract-audio-${audioAssetId}-${Date.now()}`;
+            const payload = {
+                type: "extract_audio",
+                inputPath: videoPath,
+                outputPath,
+                audioAssetId,
+                audioAssetDir,
+                sourceVideoId: asset_id,
+                bookId: book_id,
+                destination: destinationMode ? { filename: destination.filename } : undefined,
+                range,
+            };
+            // Destination mode synchronously awaits the ffmpeg + commit so the
+            // caller (PlanViewer bootstrap) knows the file is on disk before
+            // gating RUN VIDEO. The auto-mint path keeps fire-and-forget so the
+            // sidebar shows a pending aud-* tile while the job runs.
+            if (destinationMode) {
+                try {
+                    await queue.enqueueAndWait(jobId, payload);
+                }
+                catch (err) {
+                    return {
+                        isError: true,
+                        content: [{
+                                type: "text",
+                                text: `Audio extract failed: ${err instanceof Error ? err.message : String(err)}`,
+                            }],
+                    };
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                destination: { asset_id: audioAssetId, filename: destination.filename },
+                                source_video: asset_id,
+                                job_id: jobId,
+                                status: "completed",
+                            }),
+                        }],
+                };
+            }
+            await queue.enqueue(jobId, payload);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            audio_asset_id: audioAssetId,
+                            source_video: asset_id,
+                            job_id: jobId,
+                            status: "enqueued",
+                        }),
+                    }],
+            };
+        },
+    };
+}