videobook 0.0.0-stage → 0.1.0

package/dist/tools/index.js

@@ -0,0 +1,323 @@
+import { coldOpenDefs } from "./cold-open.js";
+import { withBookContext } from "../book-context.js";
+import { bookManager } from "../engine.js";
+import { videobookDomainDefs } from "./videobook-domain.js";
+import { semanticSearchDefs } from "./semantic-search.js";
+import { commandPlanDefs } from "./command-plan.js";
+import { musicDraftDefs } from "./music-draft.js";
+import { musicAnalysisDefs } from "./music-analysis.js";
+import { editingMomentsDefs } from "./editing-moments.js";
+import { sequenceRhythmDefs } from "./sequence-rhythm.js";
+import { exportSequenceDefs } from "./export-sequence.js";
+import { apiStatusDef } from "./api-status.js";
+import { providerKeyStatusDef } from "./provider-key-status.js";
+import { setEnvSecretDef } from "./set-env-secret.js";
+import { mediaLibraryDefs } from "./media-library.js";
+import { listElevenLabsVoicesDef } from "./list-elevenlabs-voices.js";
+import { createCharacterDef } from "./create-character.js";
+import { setCharacterMetadataDef } from "./set-character-metadata.js";
+import { reorderCharacterImagesDef } from "./reorder-character-images.js";
+import { uploadFileDef } from "./upload-file.js";
+import { assetManifestDef } from "./asset-manifest.js";
+import { deleteAssetDef } from "./delete-asset.js";
+import { clearFailedTasksDef } from "./clear-failed-tasks.js";
+import { recoverAssetDef } from "./recover-asset.js";
+import { retryGenerationDef } from "./retry-generation.js";
+import { doctorDef } from "./doctor.js";
+import { renameAssetDef } from "./rename-asset.js";
+import { renameAllDef } from "./rename-all.js";
+import { markAssetSeenDef } from "./mark-asset-seen.js";
+import { duplicateAssetDef } from "./duplicate-asset.js";
+import { exportAssetDef } from "./export-asset.js";
+import { assetHistoryDef } from "./asset-history.js";
+import { restoreAssetVersionDef } from "./restore-asset-version.js";
+import { readFileAtCommitDef } from "./read-file-at-commit.js";
+import { readAssetMetadataDef } from "./read-asset-metadata.js";
+import { trimVideoDef } from "./trim-video.js";
+import { trimAudioDef } from "./trim-audio.js";
+import { splitVideoDef } from "./split-video.js";
+import { extractVideoClipDef } from "./extract-video-clip.js";
+import { splitVideoByDurationsDef } from "./even-split.js";
+import { padVideoDef } from "./pad-video.js";
+import { cropAssetDef } from "./crop-asset.js";
+import { invertImageDef } from "./invert-image.js";
+import { setVideoOverlayDef } from "./set-osg.js";
+import { animateKeywordsDef } from "./animate-keywords.js";
+import { aliveCaptionsDef, setAliveCaptionsDef } from "./alive-captions.js";
+import { downloadVideoDef } from "./download-video.js";
+import { archiveClipDef } from "./archive-clip.js";
+import { searchArchiveDef } from "./search-archive.js";
+import { restoreArchiveClipsDef } from "./restore-archive-clips.js";
+import { changeVideoSpeedDef } from "./change-video-speed.js";
+import { timewarpVideoDef } from "./timewarp-video.js";
+import { syncVideoToAudioDef } from "./sync-video-to-audio.js";
+import { audioBoostDef } from "./audio-boost.js";
+import { audioMixDef } from "./audio-mix.js";
+import { reverseVideoDef } from "./reverse-video.js";
+import { injectFirstFrameDef } from "./inject-first-frame.js";
+import { extractFrameDef } from "./extract-frame.js";
+import { extractNotebookFrameDef } from "./extract-notebook-frame.js";
+import { extractNotebookAudioDef } from "./extract-notebook-audio.js";
+import { extractAudioDef } from "./extract-audio.js";
+import { makeCoverSongDef } from "./make-cover-song.js";
+import { extendAudioDef } from "./extend-audio.js";
+import { removeSoundDef } from "./remove-sound.js";
+import { verifyXMentionsDef } from "./verify-x-mentions.js";
+import { replaceVideoAudioDef } from "./replace-video-audio.js";
+import { spliceVideoDef } from "./splice-video.js";
+import { smoothSceneConcatDef } from "./smooth-scene-concat.js";
+import { transcribeDef } from "./transcribe.js";
+import { readTranscriptDef } from "./read-transcript.js";
+import { analyzeVideoDef } from "./analyze-video.js";
+import { translateSubtitlesDef } from "./translate-subtitles.js";
+import { renderVideoDef } from "./render.js";
+import { reconcileProjectWorkDef } from "./reconcile-project-work.js";
+import { assetTagDefs } from "./asset-tags.js";
+import { tagBackfillDefs } from "./tag-backfill.js";
+import { listAssetsDef } from "./list-assets.js";
+import { listCellGenerationsDef } from "./list-cell-generations.js";
+import { waitForAssetReadyDef } from "./wait-for-asset-ready.js";
+import { generationPayloadDef } from "./generation-payload.js";
+import { concatImagesDef } from "./concat-images.js";
+import { chatDef } from "./chat.js";
+import { chainDef } from "./chain.js";
+import { goalDefs } from "./goal.js";
+import { getTimelineDef } from "./get-timeline.js";
+import { setTimelineDef } from "./edit-timeline.js";
+import { renderTimelineDef } from "./render-timeline.js";
+import { exportAssetFileDef } from "./export-asset-file.js";
+import { exportTranscriptSrtDef } from "./export-transcript-srt.js";
+import { recordPromptDef, listPromptHistoryDef } from "./prompt-history.js";
+import { rewritePromptDef } from "./rewrite-prompt.js";
+import { describeImageDef } from "./describe-image.js";
+import { rewriteScriptDef } from "./rewrite-script.js";
+import { isolateVocalsDef } from "./isolate-vocals.js";
+import { cleanVideoAudioDef } from "./clean-video-audio.js";
+import { assignSlotDef } from "./assign-slot.js";
+import { removeTimelineSlotDef } from "./remove-timeline-slot.js";
+import { addTimelineAudioDef } from "./add-timeline-audio.js";
+import { removeTimelineAudioDef } from "./remove-timeline-audio.js";
+import { moveTimelineAudioDef } from "./move-timeline-audio.js";
+import { updateTimelineAudioDef } from "./update-timeline-audio.js";
+import { commandsDef, getCanonicalCommands } from "./commands.js";
+import { buildWorkspaceActionCatalog } from "../workspace-action-catalog.js";
+import { workspaceActionsDef } from "./workspace-actions.js";
+import { getRenderSettingsDef } from "./render-settings.js";
+import { updateScriptDef } from "./update-script.js";
+import { imageSubjectDefs } from "./image-subjects.js";
+import { detectScenesDef } from "./detect-scenes.js";
+import { suggestCutsDef } from "./suggest-cuts.js";
+import { suggestSfxDef } from "./suggest-sfx.js";
+import { analyzeJokesDef } from "./analyze-jokes.js";
+import { applyCutsDef } from "./apply-cuts.js";
+import { applySfxDef } from "./apply-sfx.js";
+import { generateMediaDefs } from "./generate-media.js";
+import { estimateCostDef } from "./estimate-cost.js";
+import { bookUsageDef } from "./book-usage.js";
+import { postRecordDefs } from "./post-record.js";
+import { postDef } from "./post.js";
+import { connectServiceDef, serviceStatusDef } from "./connect-service.js";
+import { createWatermarkCardDef } from "./create-watermark.js";
+import { applyWatermarkDef } from "./apply-watermark.js";
+import { createQrOutroDef } from "./create-qr-outro.js";
+import { createQartDef } from "./create-qart.js";
+import { createQrbtfDef } from "./create-qrbtf.js";
+import { getWatermarkConfigDef } from "./get-watermark-config.js";
+import { withLogging } from "./log-wrapper.js";
+import { toolInputSchema } from "./tool-json-schema.js";
+import { listChatModelsDef } from "../chat-models.js";
+export function getVideoEditingToolDefs(engine) {
+    return [
+        ...coldOpenDefs(engine),
+        trimVideoDef(engine),
+        trimAudioDef(engine),
+        splitVideoDef(engine),
+        extractVideoClipDef(engine),
+        splitVideoByDurationsDef(engine),
+        padVideoDef(engine),
+        cropAssetDef(engine),
+        invertImageDef(engine),
+        setVideoOverlayDef(engine),
+        animateKeywordsDef(engine),
+        aliveCaptionsDef(engine),
+        setAliveCaptionsDef(engine),
+        detectScenesDef(engine),
+        suggestCutsDef(engine),
+        suggestSfxDef(engine),
+        analyzeJokesDef(engine),
+        applyCutsDef(engine),
+        applySfxDef(engine),
+        changeVideoSpeedDef(engine),
+        timewarpVideoDef(engine),
+        syncVideoToAudioDef(engine),
+        audioBoostDef(engine),
+        audioMixDef(engine),
+        reverseVideoDef(engine),
+        injectFirstFrameDef(engine),
+        extractFrameDef(engine),
+        extractNotebookFrameDef(engine),
+        extractNotebookAudioDef(engine),
+        extractAudioDef(engine),
+        makeCoverSongDef(engine),
+        extendAudioDef(engine),
+        removeSoundDef(engine),
+        replaceVideoAudioDef(engine),
+        spliceVideoDef(engine),
+        smoothSceneConcatDef(engine),
+        transcribeDef(engine),
+        readTranscriptDef(engine),
+        analyzeVideoDef(engine),
+        translateSubtitlesDef(engine),
+        isolateVocalsDef(engine),
+        cleanVideoAudioDef(engine),
+        renderVideoDef(engine),
+        getTimelineDef(engine),
+        setTimelineDef(engine),
+        renderTimelineDef(engine),
+        assignSlotDef(engine),
+        removeTimelineSlotDef(engine),
+        addTimelineAudioDef(engine),
+        removeTimelineAudioDef(engine),
+        moveTimelineAudioDef(engine),
+        updateTimelineAudioDef(engine),
+        getRenderSettingsDef(engine),
+        createWatermarkCardDef(engine),
+        applyWatermarkDef(engine),
+    ];
+}
+function injectedBookIdOf(engine) {
+    try {
+        return engine.book.get().bookId;
+    }
+    catch {
+        return null;
+    }
+}
+function scopeTool(def, books, injectedEngine) {
+    const scope = def.scope ?? ("book_id" in def.schema ? "book" : "global");
+    if (scope === "global")
+        return def;
+    return {
+        ...def,
+        scope,
+        handler: async (args) => {
+            const bookId = args.book_id;
+            if (typeof bookId !== "string") {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "book_id is required" }],
+                };
+            }
+            if (bookId === injectedBookIdOf(injectedEngine)) {
+                return withBookContext({ bookId, engine: injectedEngine, operation: def.name }, () => def.handler(args));
+            }
+            const book = await books.ensure(bookId);
+            if (!book.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: book.error.message }],
+                };
+            }
+            return withBookContext({ bookId, engine: book.value.engine, operation: def.name }, () => def.handler(args));
+        },
+    };
+}
+const preparedTools = new WeakMap();
+function prepareTools(engine, books) {
+    return getAllToolDefs(engine, books)
+        .map((def) => scopeTool(withLogging(def, engine), books, engine))
+        .map((def) => ({ def, inputSchema: toolInputSchema(def.schema) }));
+}
+export function preparedToolsFor(engine, books) {
+    const byBooks = preparedTools.get(engine) ?? new WeakMap();
+    preparedTools.set(engine, byBooks);
+    const prepared = byBooks.get(books) ?? prepareTools(engine, books);
+    byBooks.set(books, prepared);
+    return prepared;
+}
+export function registerAllTools(server, engine, books = bookManager) {
+    for (const { def, inputSchema } of preparedToolsFor(engine, books)) {
+        server.registerTool(def.name, {
+            description: def.description,
+            inputSchema,
+            ...(def.annotations ? { annotations: def.annotations } : {}),
+        }, def.handler);
+    }
+}
+export function getAllToolDefs(engine, books = bookManager) {
+    const rawDefs = [
+        apiStatusDef(),
+        listChatModelsDef(),
+        providerKeyStatusDef(),
+        setEnvSecretDef(),
+        listElevenLabsVoicesDef(),
+        estimateCostDef(engine, books),
+        bookUsageDef(engine),
+        createCharacterDef(engine),
+        setCharacterMetadataDef(engine),
+        reorderCharacterImagesDef(engine),
+        uploadFileDef(engine),
+        assetManifestDef(engine),
+        deleteAssetDef(engine),
+        clearFailedTasksDef(engine),
+        recoverAssetDef(engine),
+        retryGenerationDef(engine),
+        doctorDef(engine),
+        renameAssetDef(engine),
+        renameAllDef(engine),
+        markAssetSeenDef(engine),
+        duplicateAssetDef(engine),
+        exportAssetDef(engine, books),
+        assetHistoryDef(engine),
+        restoreAssetVersionDef(engine),
+        readFileAtCommitDef(engine),
+        readAssetMetadataDef(engine),
+        ...getVideoEditingToolDefs(engine),
+        downloadVideoDef(engine),
+        archiveClipDef(engine),
+        searchArchiveDef(),
+        restoreArchiveClipsDef(engine),
+        verifyXMentionsDef(),
+        reconcileProjectWorkDef(engine),
+        listAssetsDef(engine),
+        ...assetTagDefs(engine),
+        ...tagBackfillDefs(engine),
+        listCellGenerationsDef(engine),
+        waitForAssetReadyDef(engine),
+        generationPayloadDef(engine),
+        concatImagesDef(engine),
+        chatDef(engine),
+        chainDef(engine),
+        ...goalDefs(engine),
+        exportAssetFileDef(engine),
+        exportTranscriptSrtDef(engine),
+        recordPromptDef(engine),
+        listPromptHistoryDef(engine),
+        rewritePromptDef(engine),
+        describeImageDef(engine),
+        rewriteScriptDef(engine),
+        commandsDef(books, () => buildWorkspaceActionCatalog(rawDefs, getCanonicalCommands()).actions.flatMap((action) => [action.command, ...action.aliases])),
+        updateScriptDef(engine),
+        ...imageSubjectDefs(engine),
+        ...generateMediaDefs(engine),
+        postDef(),
+        ...postRecordDefs(engine),
+        connectServiceDef(),
+        serviceStatusDef(),
+        createQrOutroDef(engine),
+        createQartDef(engine),
+        createQrbtfDef(engine),
+        getWatermarkConfigDef(engine),
+        ...commandPlanDefs(engine),
+        ...exportSequenceDefs(engine),
+        ...musicAnalysisDefs(engine),
+        ...musicDraftDefs(engine),
+        ...sequenceRhythmDefs(engine),
+        ...editingMomentsDefs(engine),
+        ...semanticSearchDefs(engine, books),
+        ...mediaLibraryDefs(books),
+        ...videobookDomainDefs(engine, books),
+        workspaceActionsDef(() => rawDefs),
+    ];
+    return rawDefs;
+}

package/dist/tools/inject-first-frame.js

@@ -0,0 +1,154 @@
+import { z } from "zod";
+import { extname, join } from "node:path";
+import { probeVideo } from "../ffmpeg.js";
+import { queue } from "../queue.js";
+import { readTimeline } from "../timeline-helpers.js";
+import { artifactKindOf, requireArtifactKind, toolError } from "./_shared.js";
+const FINAL_FILENAMES = {
+    landscape: "timeline_landscape.mp4",
+    portrait: "timeline_portrait.mp4",
+    square: "timeline_square.mp4",
+};
+const IMAGE_EXTENSIONS = new Set([".jpg", ".jpeg", ".png", ".webp"]);
+function cleanAssetId(value) {
+    return value.trim().replace(/^@/, "");
+}
+function orientationForDimensions(width, height) {
+    if (width === height)
+        return "square";
+    return width > height ? "landscape" : "portrait";
+}
+function findImageFile(files, orientation) {
+    const preferred = files.find((file) => file.name.toLowerCase() === `${orientation}.jpg`);
+    if (preferred)
+        return preferred;
+    return files.find((file) => {
+        const extension = extname(file.name).toLowerCase();
+        return file.name.toLowerCase().startsWith("original.") && IMAGE_EXTENSIONS.has(extension);
+    }) ?? null;
+}
+function findCanonicalVideo(files) {
+    return files.find((file) => /^original\.(mp4|mov)$/i.test(file.name)) ?? null;
+}
+function timelineOrientation(engine) {
+    return readTimeline(engine).render;
+}
+async function findFinalVideo(engine, files, assetDir, requested) {
+    const canonical = findCanonicalVideo(files);
+    if (canonical) {
+        const probe = await probeVideo(join(assetDir, canonical.name));
+        if (!probe.videoStream || probe.width <= 0 || probe.height <= 0)
+            return null;
+        const orientation = orientationForDimensions(probe.width, probe.height);
+        return requested && requested !== orientation ? null : { file: canonical, orientation };
+    }
+    const preferred = requested ?? timelineOrientation(engine);
+    const candidates = [
+        ...(preferred ? [preferred] : []),
+        "landscape",
+        "portrait",
+        "square",
+    ];
+    for (const orientation of [...new Set(candidates)]) {
+        const filename = FINAL_FILENAMES[orientation];
+        const file = files.find((entry) => entry.name.toLowerCase() === filename);
+        if (file)
+            return { file, orientation };
+        if (requested === orientation)
+            return null;
+    }
+    return null;
+}
+export function injectFirstFrameDef(engine) {
+    return {
+        name: "inject_first_frame",
+        description: "Replace the first frame of a video, or of the final render, with an image asset in place, keeping runtime and audio; for final, orientation defaults to the timeline's.",
+        schema: {
+            target_asset_id: z.string().describe("Target video artifact id, or final"),
+            image_asset_id: z.string().describe("Source image artifact id"),
+            book_id: z.string().describe("Book id"),
+            orientation: z
+                .enum(["landscape", "portrait", "square"])
+                .optional()
+                .describe("Final output orientation; defaults to the active timeline orientation"),
+        },
+        handler: async (args) => {
+            const { target_asset_id, image_asset_id, book_id, orientation, } = args;
+            const targetAssetId = cleanAssetId(target_asset_id);
+            const imageAssetId = cleanAssetId(image_asset_id);
+            // The timeline output is a "final"-kind artifact, so it is addressed by
+            // id like any other; only its kind distinguishes it from a plain clip.
+            const targetGate = await requireArtifactKind(engine, targetAssetId, ["video", "final"], "inject_first_frame target_asset_id");
+            if (targetGate)
+                return targetGate;
+            const isFinalTarget = artifactKindOf(engine, targetAssetId) === "final";
+            const imageGate = await requireArtifactKind(engine, imageAssetId, ["image"], "inject_first_frame image_asset_id");
+            if (imageGate)
+                return imageGate;
+            if (!isFinalTarget && orientation !== undefined) {
+                return toolError("orientation is only valid for the final timeline render");
+            }
+            const [targetManifest, imageManifest] = await Promise.all([
+                engine.files.manifest(targetAssetId),
+                engine.files.manifest(imageAssetId),
+            ]);
+            if (!targetManifest.ok)
+                return toolError(targetManifest.error.message);
+            if (!imageManifest.ok)
+                return toolError(imageManifest.error.message);
+            let targetFile;
+            let targetOrientation;
+            if (isFinalTarget) {
+                const resolved = await findFinalVideo(engine, targetManifest.value.files, targetManifest.value.path, orientation);
+                if (!resolved) {
+                    const detail = orientation ? ` for ${orientation}` : "";
+                    return toolError(`No final video output found${detail}`);
+                }
+                targetFile = resolved.file;
+                targetOrientation = resolved.orientation;
+            }
+            else {
+                targetFile = findCanonicalVideo(targetManifest.value.files);
+                if (!targetFile)
+                    return toolError(`No original MP4 or MOV found in asset ${targetAssetId}`);
+                const probe = await probeVideo(join(targetManifest.value.path, targetFile.name));
+                if (probe.videoCodec === null || probe.width <= 0 || probe.height <= 0) {
+                    return toolError(`No usable video stream found in asset ${targetAssetId}`);
+                }
+                targetOrientation = orientationForDimensions(probe.width, probe.height);
+            }
+            const imageFile = findImageFile(imageManifest.value.files, targetOrientation);
+            if (!imageFile)
+                return toolError(`No usable image file found in asset ${imageAssetId}`);
+            const now = Date.now();
+            const extension = extname(targetFile.name).toLowerCase();
+            const outputFilename = `.inject-first-frame-${now}${extension}`;
+            const jobId = `inject-first-frame-${targetAssetId}-${now}`;
+            await queue.enqueue(jobId, {
+                type: "inject_first_frame",
+                assetId: targetAssetId,
+                assetDir: targetManifest.value.path,
+                targetFilename: targetFile.name,
+                inputPath: join(targetManifest.value.path, targetFile.name),
+                outputPath: join(targetManifest.value.path, outputFilename),
+                imageAssetId,
+                imagePath: join(imageManifest.value.path, imageFile.name),
+                bookId: book_id,
+                orientation: isFinalTarget ? targetOrientation : null,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            target_asset_id: targetAssetId,
+                            image_asset_id: imageAssetId,
+                            target_filename: targetFile.name,
+                            orientation: isFinalTarget ? targetOrientation : null,
+                            job_id: jobId,
+                            status: "enqueued",
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/invert-image.js

@@ -0,0 +1,70 @@
+import { z } from "zod";
+import { extname } from "node:path";
+import { queue } from "../queue.js";
+import sharp from "sharp";
+const IMAGE_EXTENSIONS = new Set(["jpg", "jpeg", "png", "webp"]);
+function findOriginalImage(files) {
+    const images = files.filter((f) => {
+        const ext = (f.extension ?? extname(f.name)).replace(/^\./, "").toLowerCase();
+        return IMAGE_EXTENSIONS.has(ext);
+    });
+    const byName = (name) => images.find((f) => f.name === name);
+    return (byName("original.png")
+        ?? byName("original.webp")
+        ?? byName("original.jpg")
+        ?? byName("original.jpeg")
+        ?? images.find((f) => f.name.startsWith("original"))
+        ?? null);
+}
+export function invertImageDef(engine) {
+    return {
+        name: "invert_image",
+        description: "In-place inverts an img-* asset and regenerates crops.",
+        schema: {
+            asset_id: z.string().describe("Asset ID (e.g. img-my-photo)"),
+            book_id: z.string().describe("Book id"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id } = args;
+            const manifestResult = await engine.files.manifest(asset_id);
+            if (!manifestResult.ok) {
+                return { isError: true, content: [{ type: "text", text: manifestResult.error.message }] };
+            }
+            const imageFile = findOriginalImage(manifestResult.value.files);
+            if (!imageFile) {
+                return { isError: true, content: [{ type: "text", text: `No original image file found in asset ${asset_id}` }] };
+            }
+            const rawExt = imageFile.extension ?? extname(imageFile.name);
+            const extWithDot = rawExt.startsWith(".") ? rawExt : `.${rawExt}`;
+            const readResult = await engine.files.read(asset_id, imageFile.name);
+            if (!readResult.ok) {
+                return { isError: true, content: [{ type: "text", text: readResult.error.message }] };
+            }
+            const buffer = Buffer.isBuffer(readResult.value) ? readResult.value : Buffer.from(readResult.value);
+            let inverted;
+            try {
+                inverted = await sharp(buffer).negate({ alpha: false }).toBuffer();
+            }
+            catch (err) {
+                return { isError: true, content: [{ type: "text", text: `Invert failed: ${err instanceof Error ? err.message : String(err)}` }] };
+            }
+            const writeResult = await engine.files.write(asset_id, imageFile.name, inverted);
+            if (!writeResult.ok) {
+                return { isError: true, content: [{ type: "text", text: writeResult.error.message }] };
+            }
+            const metadataResult = await engine.metadata.artifacts.read(asset_id, "original");
+            const provenance = metadataResult.ok && metadataResult.value ? metadataResult.value : { origin: "invert_image" };
+            const jobId = `invert-${asset_id}-${Date.now()}`;
+            await queue.enqueueAndWait(jobId, {
+                type: "process_image",
+                assetId: asset_id,
+                bookId: book_id,
+                extension: extWithDot,
+                provenance,
+            });
+            return {
+                content: [{ type: "text", text: JSON.stringify({ asset_id, status: "completed" }) }],
+            };
+        },
+    };
+}

package/dist/tools/isolate-vocals.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { join } from "node:path";
+import { queue } from "../queue.js";
+import { findAudioFile } from "videobook-engine";
+export function isolateVocalsDef(engine) {
+    return {
+        name: "isolate_vocals",
+        description: "Isolate vocals from a video or audio asset using ElevenLabs audio-isolation via KIE. " +
+            "Writes audio_vocals.mp3 (for video assets) or mix.mp3 + .mix.json (for audio assets).",
+        schema: {
+            asset_id: z.string().describe("Video or audio artifact id"),
+            book_id: z.string().describe("Book UUID"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id } = args;
+            if (!process.env.KIE_API_KEY) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "KIE_API_KEY environment variable is not set" }],
+                };
+            }
+            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 audioFile = findAudioFile(manifest.files, artifactResult.value.kind);
+            if (!audioFile) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: `No audio file found in asset ${asset_id}`,
+                        }],
+                };
+            }
+            const audioPath = join(manifest.path, audioFile.name);
+            const jobId = `isolate-vocals-${asset_id}-${Date.now()}`;
+            await queue.enqueue(jobId, {
+                type: "isolate_vocals",
+                audioPath,
+                audioFilename: audioFile.name,
+                assetId: asset_id,
+                assetDir: manifest.path,
+                bookId: book_id,
+                isAudioAsset: artifactResult.value.kind === "audio",
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ asset_id, job_id: jobId, status: "enqueued" }),
+                    }],
+            };
+        },
+    };
+}