videobook 0.0.0-stage → 0.2.0

package/dist/tools/split-video.js

@@ -0,0 +1,202 @@
+import { findVideoFile } from "videobook-engine";
+import { z } from "zod";
+import { join } from "node:path";
+import { queue } from "../queue.js";
+import { probeVideo } from "../ffmpeg.js";
+import { resolveVideoAssetReference } from "./video-source-reference.js";
+import { parseVideoTimestamp, videoTimestampSchema } from "./video-time-input.js";
+// Each chunk must be at least this long, otherwise downstream process_video
+// can't extract frames / probe meaningfully and the asset gets stuck.
+const MIN_CHUNK_SEC = 0.5;
+function validateSplitParams(chunkAEnd, chunkBStart) {
+    if (!Number.isFinite(chunkAEnd) || !Number.isFinite(chunkBStart)) {
+        return { error: "chunk_a_end and chunk_b_start must be finite numbers." };
+    }
+    if (chunkAEnd <= 0) {
+        return { error: "chunk_a_end must be > 0." };
+    }
+    if (chunkBStart < 0) {
+        return { error: "chunk_b_start must be >= 0." };
+    }
+    // Overlap is allowed (chunkBStart <= chunkAEnd) but not fully reversed.
+    if (chunkBStart > chunkAEnd) {
+        return {
+            error: `chunk_b_start (${chunkBStart}) must be <= chunk_a_end (${chunkAEnd}). Gaps are not supported; use trim_video instead.`,
+        };
+    }
+    return { chunkAEnd, chunkBStart };
+}
+// Numeric suffixes 1/2 mark chunk order; trim the source label to its last
+// 2 words so labels stay short. Mirrors even-split.ts.
+function deriveChunkName(source, suffix) {
+    const base = source.label ?? source.artifactId;
+    const words = base.split(/[\s-]+/u).filter((w) => w.length > 0);
+    const tail = words.slice(-2).join("-") || base;
+    return `${tail}-${suffix}`;
+}
+export function splitVideoDef(engine) {
+    return {
+        name: "split_video",
+        description: "Create two new clips from one video while preserving the source. Use for requests such as 'trim @a1 15s and remaining'. chunk_a_end accepts seconds or timestamps such as 15s or 1:30; omit chunk_b_start for a clean split.",
+        annotations: {
+            title: "Split video into clips",
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        schema: {
+            asset_id: z.string().describe("Source video artifact id or notebook reference such as @a1"),
+            book_id: z.string().describe("Book UUID"),
+            notebook_id: z.string().uuid().optional().describe("Notebook UUID when asset_id is a grid reference and the book has multiple matching notebooks"),
+            chunk_a_end: videoTimestampSchema.describe("End of the first clip in seconds or a timestamp such as 15s or 1:30"),
+            chunk_b_start: videoTimestampSchema.optional().describe("Start of the remaining clip; defaults to chunk_a_end for a clean split"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, notebook_id, chunk_a_end, chunk_b_start } = args;
+            let assetId;
+            let chunkAEnd;
+            let chunkBStart;
+            try {
+                assetId = resolveVideoAssetReference(engine, asset_id, notebook_id);
+                chunkAEnd = parseVideoTimestamp(chunk_a_end, "chunk_a_end");
+                chunkBStart = parseVideoTimestamp(chunk_b_start, "chunk_b_start") ?? chunkAEnd;
+            }
+            catch (err) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+                };
+            }
+            const validated = validateSplitParams(chunkAEnd, chunkBStart);
+            if ("error" in validated) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: validated.error }],
+                };
+            }
+            const sourceArtifact = engine.artifacts.get(assetId);
+            if (!sourceArtifact.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: sourceArtifact.error.message }],
+                };
+            }
+            const manifestResult = await engine.files.manifest(assetId);
+            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 ${assetId}` }],
+                };
+            }
+            const sourcePath = join(manifest.path, videoFile.name);
+            let sourceDurationSec;
+            try {
+                const probe = await probeVideo(sourcePath);
+                sourceDurationSec = probe.videoDuration || probe.duration;
+            }
+            catch (err) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: `Failed to probe source duration: ${err instanceof Error ? err.message : String(err)}`,
+                        }],
+                };
+            }
+            if (validated.chunkAEnd > sourceDurationSec + 0.05) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: `chunk_a_end (${validated.chunkAEnd.toFixed(2)}s) exceeds source duration (${sourceDurationSec.toFixed(2)}s).`,
+                        }],
+                };
+            }
+            const chunkADur = validated.chunkAEnd;
+            const chunkBDur = sourceDurationSec - validated.chunkBStart;
+            if (chunkADur < MIN_CHUNK_SEC || chunkBDur < MIN_CHUNK_SEC) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: `Chunks would be too short: A=${chunkADur.toFixed(2)}s, B=${chunkBDur.toFixed(2)}s (min ${MIN_CHUNK_SEC}s each). Source is ${sourceDurationSec.toFixed(2)}s — pick a split point further from the ends.`,
+                        }],
+                };
+            }
+            const nameA = deriveChunkName(sourceArtifact.value, "1");
+            const nameB = deriveChunkName(sourceArtifact.value, "2");
+            const createA = await engine.artifacts.create(sourceArtifact.value.kind, nameA);
+            if (!createA.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Failed to create chunk A asset: ${createA.error.message}` }],
+                };
+            }
+            const createB = await engine.artifacts.create(sourceArtifact.value.kind, nameB);
+            if (!createB.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Failed to create chunk B asset: ${createB.error.message}` }],
+                };
+            }
+            const assetIdA = createA.value.artifactId;
+            const assetIdB = createB.value.artifactId;
+            const assetDirA = createA.value.path;
+            const assetDirB = createB.value.path;
+            const outputPathA = join(assetDirA, "original.mp4");
+            const outputPathB = join(assetDirB, "original.mp4");
+            const jobId = `split-${assetId}-${Date.now()}`;
+            try {
+                await queue.enqueueAndWait(jobId, {
+                    type: "split_video",
+                    sourcePath,
+                    sourceAssetId: assetId,
+                    chunkAEnd: validated.chunkAEnd,
+                    chunkBStart: validated.chunkBStart,
+                    assetIdA,
+                    assetDirA,
+                    outputPathA,
+                    assetIdB,
+                    assetDirB,
+                    outputPathB,
+                    bookId: book_id,
+                });
+            }
+            catch (err) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: `Split failed: ${err instanceof Error ? err.message : String(err)}`,
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            source_asset_id: assetId,
+                            chunk_a_asset_id: assetIdA,
+                            chunk_a_artifact_id: createA.value.artifactId,
+                            chunk_b_asset_id: assetIdB,
+                            chunk_b_artifact_id: createB.value.artifactId,
+                            chunk_a_end: validated.chunkAEnd,
+                            chunk_b_start: validated.chunkBStart,
+                            overlap_sec: Math.max(0, validated.chunkAEnd - validated.chunkBStart),
+                            job_id: jobId,
+                            status: "completed",
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/suggest-cuts.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+import { queue } from "../queue.js";
+import { loadAssetForAnalysis } from "./_suggest-shared.js";
+export function suggestCutsDef(engine) {
+    return {
+        name: "suggest_cuts",
+        description: "Suggest trims for visual pacing and awkward transitions from a video's frames in a background job. Uses a transcript when available for dialogue, dead air and fillers; no transcript is required. Pass the editing goal in instructions; review the result before apply_cuts.",
+        schema: {
+            asset_id: z.string().describe("Video artifact ID"),
+            book_id: z.string().describe("Book id"),
+            instructions: z.string().trim().min(1).optional().describe("Requested editing goal, such as smoother transitions and better timing"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, instructions } = args;
+            const assetId = asset_id.replace(/^@/, "");
+            if (!process.env.OPENAI_API_KEY) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "OPENAI_API_KEY environment variable is not set" }],
+                };
+            }
+            const loaded = await loadAssetForAnalysis(engine, assetId, { requireTranscript: false });
+            if (!loaded.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: loaded.error.message }],
+                };
+            }
+            const jobId = `suggest-cuts-${assetId}-${Date.now()}`;
+            await queue.enqueue(jobId, {
+                type: "suggest_cuts",
+                assetId,
+                assetDir: loaded.value.manifest.path,
+                bookId: book_id,
+                instructions,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ asset_id: assetId, job_id: jobId, status: "enqueued" }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/suggest-sfx.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { queue } from "../queue.js";
+import { loadAssetForAnalysis } from "./_suggest-shared.js";
+export function suggestSfxDef(engine) {
+    return {
+        name: "suggest_sfx",
+        description: "Suggest timed sound effects for a video from its frames and transcript in a background job. Needs a transcript; mix the result in with apply_sfx.",
+        schema: {
+            asset_id: z.string().describe("Video asset ID (vid-* or @vid-slug)"),
+            book_id: z.string().describe("Book id"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id } = args;
+            const assetId = asset_id.replace(/^@/, "");
+            if (!process.env.OPENAI_API_KEY) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "OPENAI_API_KEY environment variable is not set" }],
+                };
+            }
+            const loaded = await loadAssetForAnalysis(engine, assetId);
+            if (!loaded.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: loaded.error.message }],
+                };
+            }
+            const jobId = `suggest-sfx-${assetId}-${Date.now()}`;
+            await queue.enqueue(jobId, {
+                type: "suggest_sfx",
+                assetId,
+                assetDir: loaded.value.manifest.path,
+                bookId: book_id,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ asset_id: assetId, job_id: jobId, status: "enqueued" }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/sync-video-to-audio.js

@@ -0,0 +1,115 @@
+import { findVideoFile } from "videobook-engine";
+import { join } from "node:path";
+import { z } from "zod";
+import { createAudioSyncPlan } from "../audio-sync.js";
+import { probeVideo } from "../ffmpeg.js";
+import { queue } from "../queue.js";
+function errorResult(message) {
+    return {
+        isError: true,
+        content: [{ type: "text", text: message }],
+    };
+}
+const videoAnchor = z.object({
+    video_seconds: z.number().nonnegative().describe("Timestamp of the visual action in the source video"),
+    audio_seconds: z.number().nonnegative().describe("Timestamp in the original audio where that action should land"),
+}).strict();
+const cueAnchor = z.object({
+    video_seconds: z.number().nonnegative().describe("Timestamp of the visual action in the source video"),
+    audio_cue: z.string().trim().min(1).describe("Unique contiguous phrase in the timed ElevenLabs transcript"),
+}).strict();
+function validateVideoAnchors(anchors, videoDuration, sourceFps) {
+    const frameDuration = 1 / sourceFps;
+    let previousVideoSeconds = 0;
+    for (const [index, anchor] of anchors.entries()) {
+        if (anchor.videoSeconds > videoDuration) {
+            throw new Error(`Video anchor ${index + 1} must be within the video duration`);
+        }
+        if (index > 0 && anchor.videoSeconds <= previousVideoSeconds) {
+            throw new Error("Audio-sync video anchors must be strictly increasing");
+        }
+        if (anchor.videoSeconds - previousVideoSeconds < frameDuration) {
+            throw new Error(`Audio-sync video anchor intervals must be at least one source frame (${frameDuration.toFixed(6)}s)`);
+        }
+        previousVideoSeconds = anchor.videoSeconds;
+    }
+    if (videoDuration - previousVideoSeconds < frameDuration) {
+        throw new Error(`Audio-sync video anchor intervals must be at least one source frame (${frameDuration.toFixed(6)}s)`);
+    }
+}
+export function syncVideoToAudioDef(engine) {
+    return {
+        name: "sync_video_to_audio",
+        description: "Smoothly retime a video's picture through multiple anchors while preserving its original audio unchanged.",
+        schema: {
+            asset_id: z.string().describe("Video asset ID"),
+            book_id: z.string().describe("Book id"),
+            anchors: z.array(z.union([cueAnchor, videoAnchor])).min(1).describe("Visual timestamps mapped to transcript cues or numeric audio timestamps"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, anchors } = args;
+            const manifestResult = await engine.files.manifest(asset_id);
+            if (!manifestResult.ok)
+                return errorResult(manifestResult.error.message);
+            const videoFile = findVideoFile(manifestResult.value.files);
+            if (!videoFile)
+                return errorResult(`No video file found in asset ${asset_id}`);
+            const inputPath = join(manifestResult.value.path, videoFile.name);
+            let source;
+            try {
+                source = await probeVideo(inputPath);
+            }
+            catch (error) {
+                return errorResult(error instanceof Error ? error.message : String(error));
+            }
+            if (source.videoCodec === null) {
+                return errorResult(`No usable video stream found in asset ${asset_id}`);
+            }
+            if (!source.hasAudio || source.audioDuration === null) {
+                return errorResult(`sync_video_to_audio requires an audio stream in asset ${asset_id}`);
+            }
+            const requestedAnchors = anchors.map((anchor) => ("audio_cue" in anchor
+                ? { videoSeconds: anchor.video_seconds, audioCue: anchor.audio_cue }
+                : { videoSeconds: anchor.video_seconds, audioSeconds: anchor.audio_seconds }));
+            const numericAnchors = requestedAnchors.filter((anchor) => "audioSeconds" in anchor);
+            try {
+                if (numericAnchors.length === requestedAnchors.length) {
+                    createAudioSyncPlan({
+                        videoDuration: source.videoDuration,
+                        audioDuration: source.audioDuration,
+                        sourceFps: source.fps,
+                        anchors: numericAnchors,
+                    });
+                }
+                else {
+                    validateVideoAnchors(requestedAnchors, source.videoDuration, source.fps);
+                }
+            }
+            catch (error) {
+                return errorResult(error instanceof Error ? error.message : String(error));
+            }
+            const now = Date.now();
+            const jobId = `sync-audio-${asset_id}-${now}`;
+            const outputPath = join(manifestResult.value.path, `.sync-audio-${now}.mp4`);
+            await queue.enqueue(jobId, {
+                type: "sync_video_to_audio",
+                inputPath,
+                outputPath,
+                anchors: requestedAnchors,
+                assetId: asset_id,
+                assetDir: manifestResult.value.path,
+                bookId: book_id,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            asset_id,
+                            job_id: jobId,
+                            status: "enqueued",
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/tag-backfill.js

@@ -0,0 +1,177 @@
+/**
+ * Controls for tagging a library that already exists, and for how new assets
+ * are tagged from here on.
+ *
+ * The split these tools express: adopting cached analysis is free and happens
+ * by default, while asking a provider to analyze media that was never
+ * analyzed costs money and happens only when someone says so. A caller can
+ * therefore run a full pass, read the counts, and then decide whether the
+ * remaining assets are worth paying for.
+ */
+import { z } from "zod";
+import { queue } from "../queue.js";
+import { backfillProgress, startedState, } from "../jobs/backfill-asset-tags.js";
+import { runAssetTagging } from "../jobs/tag-asset.js";
+import { readBackfillState, writeBackfillState, } from "../tag-backfill-state.js";
+import { readTaggingSettings, writeTaggingSettings, } from "../tag-settings.js";
+import { assetTagSummary } from "../asset-tags.js";
+import { TAG_ANALYZER_VERSION } from "../tag-vocabulary.js";
+function json(value) {
+    return { content: [{ type: "text", text: JSON.stringify(value) }] };
+}
+function failure(cause) {
+    return {
+        isError: true,
+        content: [{
+                type: "text",
+                text: cause instanceof Error ? cause.message : String(cause),
+            }],
+    };
+}
+function progressPayload(engine, state) {
+    const progress = backfillProgress(engine, state);
+    return {
+        status: progress.state.status,
+        analyzer_version: TAG_ANALYZER_VERSION,
+        allow_analysis: progress.state.allowAnalysis,
+        force: progress.state.force,
+        scanned: progress.state.scanned,
+        total: progress.total,
+        remaining: progress.remaining,
+        counts: {
+            tagged: progress.state.counts.tagged,
+            already_current: progress.state.counts.current,
+            no_useful_evidence: progress.state.counts.empty,
+            needs_analysis: progress.state.counts.needsAnalysis,
+            unsupported: progress.state.counts.unsupported,
+            skipped: progress.state.counts.skipped,
+            failed: progress.state.counts.failed,
+        },
+        started_at: progress.state.startedAt,
+        updated_at: progress.state.updatedAt,
+        finished_at: progress.state.finishedAt,
+        ...(progress.state.lastError ? { last_error: progress.state.lastError } : {}),
+    };
+}
+export function tagBackfillDefs(engine) {
+    return [
+        {
+            name: "backfill_asset_tags",
+            description: "Tag the assets already in a book. 'start' adopts cached analysis; allow_analysis permits provider calls. Pause and cancel stop new work; already queued analysis may finish. Resume continues saved progress.",
+            schema: {
+                book_id: z.string().describe("Book to backfill"),
+                action: z.enum(["start", "resume", "pause", "cancel", "status"])
+                    .describe("What to do with this book's backfill pass"),
+                allow_analysis: z.boolean().optional().describe("Analyze assets with no usable cached analysis; this spends provider calls"),
+                force: z.boolean().optional().describe("Re-tag assets whose tags already cover their current content"),
+            },
+            handler: async (args) => {
+                const { book_id, action, allow_analysis, force } = args;
+                try {
+                    const previous = readBackfillState(engine);
+                    if (action === "status")
+                        return json(progressPayload(engine, previous));
+                    if (action === "pause" || action === "cancel") {
+                        if (previous.status !== "running" && !(action === "cancel" && previous.status === "paused")) {
+                            return json(progressPayload(engine, previous));
+                        }
+                        const stopped = writeBackfillState(engine, {
+                            ...previous,
+                            status: action === "pause" ? "paused" : "cancelled",
+                            ...(action === "cancel" ? { finishedAt: Date.now() } : {}),
+                        });
+                        return json(progressPayload(engine, stopped));
+                    }
+                    if (previous.status === "running") {
+                        return json(progressPayload(engine, previous));
+                    }
+                    const started = writeBackfillState(engine, startedState(previous, {
+                        allowAnalysis: allow_analysis ?? (action === "resume" && previous.allowAnalysis),
+                        force: force ?? (action === "resume" && previous.force),
+                        resume: action === "resume",
+                    }));
+                    await queue.enqueue(`backfill-asset-tags-${book_id}-${started.runId}`, {
+                        type: "backfill_asset_tags",
+                        bookId: book_id,
+                        runId: started.runId,
+                        ...(allow_analysis ? { allowAnalysis: true } : {}),
+                        ...(force ? { force: true } : {}),
+                    });
+                    return json(progressPayload(engine, started));
+                }
+                catch (cause) {
+                    return failure(cause);
+                }
+            },
+        },
+        {
+            name: "retag_asset",
+            description: "Re-run tagging for one asset and return its tag state. Manual tags and dismissals are preserved; use it to retry after adding a provider key or to pick up a newer analysis.",
+            schema: {
+                book_id: z.string().describe("Book that owns the asset"),
+                asset_id: z.string().describe("Artifact id to re-tag"),
+                force: z.boolean().optional().describe("Re-run even when the current tags already cover this content"),
+                cached_only: z.boolean().optional().describe("Adopt cached analysis only; never request new provider analysis"),
+            },
+            handler: async (args) => {
+                const { book_id, asset_id, force, cached_only } = args;
+                try {
+                    const result = await runAssetTagging(engine, {
+                        type: "tag_asset",
+                        bookId: book_id,
+                        assetId: asset_id,
+                        ...(force ? { force: true } : {}),
+                        ...(cached_only ? { cacheOnly: true } : {}),
+                    });
+                    if (result.outcome === "missing_asset") {
+                        return failure(new Error(`Asset not found: ${asset_id}`));
+                    }
+                    const state = engine.tags.read(asset_id);
+                    return json({
+                        asset_id,
+                        outcome: result.outcome,
+                        tag_count: result.tagCount,
+                        analyzer_version: result.analyzerVersion,
+                        ...(state.ok ? { tags: assetTagSummary(state.value) } : {}),
+                    });
+                }
+                catch (cause) {
+                    return failure(cause);
+                }
+            },
+        },
+        {
+            name: "configure_asset_tagging",
+            description: "Read or change how new assets are tagged in a book. Manual tagging, filtering and search keep working whatever this is set to.",
+            schema: {
+                book_id: z.string().describe("Book to configure"),
+                automatic_enabled: z.boolean().optional().describe("Tag new assets automatically as they become ready"),
+                analysis_on_new_assets: z.boolean().optional().describe("Let automatic tagging analyze new assets that have no cached analysis"),
+            },
+            handler: async (args) => {
+                const { automatic_enabled, analysis_on_new_assets } = args;
+                try {
+                    const update = {
+                        ...(automatic_enabled === undefined
+                            ? {}
+                            : { automaticEnabled: automatic_enabled }),
+                        ...(analysis_on_new_assets === undefined
+                            ? {}
+                            : { analysisOnNewAssets: analysis_on_new_assets }),
+                    };
+                    const settings = Object.keys(update).length > 0
+                        ? writeTaggingSettings(engine, update)
+                        : readTaggingSettings(engine);
+                    return json({
+                        automatic_enabled: settings.automaticEnabled,
+                        analysis_on_new_assets: settings.analysisOnNewAssets,
+                        analyzer_version: TAG_ANALYZER_VERSION,
+                    });
+                }
+                catch (cause) {
+                    return failure(cause);
+                }
+            },
+        },
+    ];
+}

package/dist/tools/timewarp-video.js

@@ -0,0 +1,85 @@
+import { findVideoFile } from "videobook-engine";
+import { join } from "node:path";
+import { z } from "zod";
+import { probeVideo } from "../ffmpeg.js";
+import { queue } from "../queue.js";
+import { createTimewarpPlan } from "../timewarp.js";
+function errorResult(message) {
+    return {
+        isError: true,
+        content: [{ type: "text", text: message }],
+    };
+}
+export function timewarpVideoDef(engine) {
+    return {
+        name: "timewarp_video",
+        description: "Retime one video range and compensate the remaining picture to preserve the original duration and audio.",
+        schema: {
+            asset_id: z.string().describe("Video asset ID"),
+            book_id: z.string().describe("Book id"),
+            start_seconds: z.number().describe("Selected range start in seconds"),
+            end_seconds: z.number().describe("Selected range end in seconds"),
+            stretch_factor: z.number().describe("Duration multiplier from 0.25 to 4; values above 1 lengthen the selection"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, start_seconds, end_seconds, stretch_factor, } = args;
+            const manifestResult = await engine.files.manifest(asset_id);
+            if (!manifestResult.ok)
+                return errorResult(manifestResult.error.message);
+            const videoFile = findVideoFile(manifestResult.value.files);
+            if (!videoFile)
+                return errorResult(`No video file found in asset ${asset_id}`);
+            const inputPath = join(manifestResult.value.path, videoFile.name);
+            let source;
+            try {
+                source = await probeVideo(inputPath);
+            }
+            catch (error) {
+                return errorResult(error instanceof Error ? error.message : String(error));
+            }
+            if (source.videoCodec === null) {
+                return errorResult(`No usable video stream found in asset ${asset_id}`);
+            }
+            let plan;
+            try {
+                plan = createTimewarpPlan({
+                    sourceDuration: source.duration,
+                    sourceFps: source.fps,
+                    startSeconds: start_seconds,
+                    endSeconds: end_seconds,
+                    stretchFactor: stretch_factor,
+                });
+            }
+            catch (error) {
+                return errorResult(error instanceof Error ? error.message : String(error));
+            }
+            const now = Date.now();
+            const jobId = `timewarp-${asset_id}-${now}`;
+            const outputPath = join(manifestResult.value.path, `.timewarp-${now}.mp4`);
+            await queue.enqueue(jobId, {
+                type: "timewarp_video",
+                inputPath,
+                outputPath,
+                startSeconds: start_seconds,
+                endSeconds: end_seconds,
+                stretchFactor: stretch_factor,
+                assetId: asset_id,
+                assetDir: manifestResult.value.path,
+                bookId: book_id,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            asset_id,
+                            job_id: jobId,
+                            status: "enqueued",
+                            source_duration: plan.sourceDuration,
+                            selected_output_duration: plan.selectedOutputDuration,
+                            outside_stretch_factor: plan.outsideStretchFactor,
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/tool-def.js

@@ -0,0 +1 @@
+export {};