videobook 0.0.0-stage → 0.2.0

package/dist/tools/tool-json-schema.js

@@ -0,0 +1,116 @@
+import { z } from "zod";
+const ADVERTISED_SCHEMAS = new WeakMap();
+const SUBSCHEMA_MAPS = new Set([
+    "properties",
+    "patternProperties",
+    "$defs",
+    "definitions",
+    "dependentSchemas",
+]);
+const SUBSCHEMA_LISTS = new Set(["anyOf", "oneOf", "allOf", "prefixItems"]);
+const SUBSCHEMAS = new Set([
+    "items",
+    "additionalProperties",
+    "propertyNames",
+    "not",
+    "contains",
+    "if",
+    "then",
+    "else",
+    "unevaluatedItems",
+    "unevaluatedProperties",
+]);
+function isSchemaObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPlainStringSchema(value) {
+    return isSchemaObject(value)
+        && Object.keys(value).length === 1
+        && value.type === "string";
+}
+function isRedundantKeyword(key, value, schema) {
+    switch (key) {
+        case "$schema":
+            return true;
+        case "pattern":
+            return typeof schema.format === "string";
+        case "propertyNames":
+            return isPlainStringSchema(value);
+        case "maximum":
+            return value === Number.MAX_SAFE_INTEGER;
+        case "minimum":
+            return value === Number.MIN_SAFE_INTEGER;
+        default:
+            return false;
+    }
+}
+function compactSubschemaMap(value) {
+    if (!isSchemaObject(value))
+        return value;
+    return Object.fromEntries(Object.entries(value).map(([name, child]) => [name, compactNode(child)]));
+}
+function compactKeyword(key, value) {
+    if (SUBSCHEMA_MAPS.has(key))
+        return compactSubschemaMap(value);
+    if (SUBSCHEMA_LISTS.has(key) && Array.isArray(value))
+        return value.map(compactNode);
+    if (!SUBSCHEMAS.has(key))
+        return value;
+    return Array.isArray(value) ? value.map(compactNode) : compactNode(value);
+}
+function compactNode(value) {
+    if (!isSchemaObject(value))
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .filter(([key, child]) => !isRedundantKeyword(key, child, value))
+        .map(([key, child]) => [key, compactKeyword(key, child)]));
+}
+export function advertisedAs(schema, advertised) {
+    ADVERTISED_SCHEMAS.set(schema, advertised);
+    return schema;
+}
+const advertise = ({ zodSchema, jsonSchema }) => {
+    const advertised = ADVERTISED_SCHEMAS.get(zodSchema);
+    if (!advertised)
+        return;
+    const target = jsonSchema;
+    for (const key of Object.keys(target))
+        delete target[key];
+    Object.assign(target, advertised);
+};
+export function compactJsonSchema(schema) {
+    return compactNode(schema);
+}
+export function toolInputJsonSchema(shape, unrepresentable = "throw") {
+    return compactJsonSchema(z.toJSONSchema(z.object(shape), {
+        io: "input",
+        unrepresentable,
+        override: advertise,
+    }));
+}
+export function toolInputSchema(shape) {
+    const standard = z.object(shape)["~standard"];
+    const advertisedInputs = new Map();
+    return {
+        "~standard": {
+            version: standard.version,
+            vendor: standard.vendor,
+            validate: standard.validate,
+            jsonSchema: {
+                input: (options) => {
+                    const cached = options.libraryOptions ? undefined : advertisedInputs.get(options.target);
+                    if (cached)
+                        return cached;
+                    const advertised = compactJsonSchema(standard.jsonSchema.input({
+                        ...options,
+                        libraryOptions: { ...options.libraryOptions, override: advertise },
+                    }));
+                    if (!options.libraryOptions)
+                        advertisedInputs.set(options.target, advertised);
+                    return advertised;
+                },
+                output: (options) => compactJsonSchema(standard.jsonSchema.output(options)),
+            },
+        },
+    };
+}

package/dist/tools/transcribe.js

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import { join } from "node:path";
+import { queue } from "../queue.js";
+import { findAudioFile, findVideoFile } from "videobook-engine";
+function error(text) {
+    return { isError: true, content: [{ type: "text", text }] };
+}
+export function transcribeDef(engine) {
+    return {
+        name: "transcribe",
+        description: "Transcribe a video or audio asset: word-timed ElevenLabs speech-to-text when available, otherwise OpenAI speech-to-text.",
+        schema: {
+            asset_id: z.string().describe("Video or audio artifact id"),
+            book_id: z.string().describe("Book UUID"),
+            language_code: z.string().optional().describe("Language code (e.g. 'en'). Auto-detected if omitted."),
+            tag_audio_events: z.boolean().optional().default(true).describe("Tag audio events like laughter, music, etc."),
+            diarize: z.boolean().optional().default(true).describe("Enable speaker diarization"),
+            wait: z.boolean().optional().default(false).describe("Wait for the transcription job to finish before returning (default: return as soon as the job is enqueued)"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, language_code, tag_audio_events, diarize, wait } = args;
+            const hasElevenLabsKey = Boolean(process.env.ELEVENLABS_API_KEY);
+            const hasOpenAiKey = Boolean(process.env.OPENAI_API_KEY);
+            if (!hasElevenLabsKey && !hasOpenAiKey) {
+                return error("Speech-to-text needs ELEVENLABS_API_KEY or OPENAI_API_KEY — neither is set");
+            }
+            const artifactResult = engine.artifacts.get(asset_id);
+            if (!artifactResult.ok)
+                return error(artifactResult.error.message);
+            const manifestResult = await engine.files.manifest(asset_id);
+            if (!manifestResult.ok)
+                return error(manifestResult.error.message);
+            const manifest = manifestResult.value;
+            const audioFile = findAudioFile(manifest.files, artifactResult.value.kind);
+            // ElevenLabs needs a standalone audio track; without one (or without its
+            // key) OpenAI speech-to-text reads the video file directly.
+            const mediaFile = audioFile ?? findVideoFile(manifest.files);
+            if (!mediaFile) {
+                return error(`No audio file found in artifact ${asset_id}`);
+            }
+            const useElevenLabs = hasElevenLabsKey && audioFile !== null;
+            if (!useElevenLabs && !hasOpenAiKey) {
+                return error(`No audio file found in artifact ${asset_id}`);
+            }
+            const provider = useElevenLabs ? "elevenlabs" : "openai";
+            const jobId = `transcribe-${asset_id}-${Date.now()}`;
+            const jobPayload = (useElevenLabs
+                ? {
+                    type: "transcribe",
+                    audioPath: join(manifest.path, mediaFile.name),
+                    audioFilename: mediaFile.name,
+                    tagAudioEvents: tag_audio_events,
+                    diarize,
+                    ...(language_code ? { languageCode: language_code } : {}),
+                    assetId: asset_id,
+                    assetDir: manifest.path,
+                    bookId: book_id,
+                }
+                : {
+                    type: "transcribe_video_audio",
+                    videoPath: join(manifest.path, mediaFile.name),
+                    sourceFilename: mediaFile.name,
+                    assetId: asset_id,
+                    assetDir: manifest.path,
+                    bookId: book_id,
+                });
+            if (wait) {
+                try {
+                    await queue.enqueueAndWait(jobId, jobPayload);
+                }
+                catch (err) {
+                    return error(`Transcription failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ asset_id, job_id: jobId, provider, status: "completed" }),
+                        }],
+                };
+            }
+            await queue.enqueue(jobId, jobPayload);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ asset_id, job_id: jobId, provider, status: "enqueued" }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/translate-subtitles.js

@@ -0,0 +1,59 @@
+import { z } from "zod";
+import { queue } from "../queue.js";
+import { requireArtifactKind } from "./_shared.js";
+export function translateSubtitlesDef(engine) {
+    return {
+        name: "translate_subtitles",
+        description: "Translate an asset's transcript subtitles into another language for renders with that subtitle_language; cached per language until the asset is re-transcribed.",
+        schema: {
+            asset_id: z.string().describe("Video or audio artifact id"),
+            book_id: z.string().describe("Book id"),
+            language: z
+                .string()
+                .regex(/^[a-z]{2}$/)
+                .describe("Target language as a two-letter ISO 639-1 code (e.g. 'en')"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, language } = args;
+            const kindGate = await requireArtifactKind(engine, asset_id, ["video", "audio"], "translate_subtitles");
+            if (kindGate)
+                return kindGate;
+            if (!process.env.OPENAI_API_KEY) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "OPENAI_API_KEY environment variable is not set" }],
+                };
+            }
+            const manifestResult = await engine.files.manifest(asset_id);
+            if (!manifestResult.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: manifestResult.error.message }],
+                };
+            }
+            const hasTranscript = manifestResult.value.files.some((f) => f.name === "elevenlabs.json");
+            if (!hasTranscript) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: `No elevenlabs.json in asset ${asset_id}. Transcribe the asset first.`,
+                        }],
+                };
+            }
+            const jobId = `translate-${asset_id}-${language}-${Date.now()}`;
+            await queue.enqueue(jobId, {
+                type: "translate_transcript",
+                assetId: asset_id,
+                bookId: book_id,
+                targetLanguage: language,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ asset_id, language, job_id: jobId, status: "enqueued" }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/trim-audio.js

@@ -0,0 +1,139 @@
+import { z } from "zod";
+import { join, extname } from "node:path";
+import { queue } from "../queue.js";
+import { findAudioFile } from "videobook-engine";
+import { probeVideo } from "../ffmpeg.js";
+import { validateAudioTrimRange } from "../audio-trim-range.js";
+function validateTrimParams(trimStart, trimEnd, cutStart, cutEnd) {
+    const hasKeep = trimStart !== undefined || trimEnd !== undefined;
+    const hasCut = cutStart !== undefined || cutEnd !== undefined;
+    if (hasKeep && hasCut) {
+        return { error: "Cannot specify both trim (keep) and cut (remove) parameters. Use one mode at a time." };
+    }
+    if (!hasKeep && !hasCut) {
+        return { error: "Must specify trim_start/trim_end (keep range) or cut_start/cut_end (remove range)." };
+    }
+    if (hasCut) {
+        if (cutStart === undefined || cutEnd === undefined) {
+            return { error: "Both cut_start and cut_end are required for cut mode." };
+        }
+        if (cutStart >= cutEnd) {
+            return { error: "cut_start must be less than cut_end." };
+        }
+        if (cutStart < 0 || cutEnd < 0) {
+            return { error: "cut_start and cut_end must be >= 0." };
+        }
+        return { mode: "cut", cutStart, cutEnd };
+    }
+    if (trimStart !== undefined && trimStart < 0) {
+        return { error: "trim_start must be >= 0." };
+    }
+    if (trimEnd !== undefined && trimEnd < 0) {
+        return { error: "trim_end must be >= 0." };
+    }
+    if (trimStart !== undefined && trimEnd !== undefined && trimStart >= trimEnd) {
+        return { error: "trim_start must be less than trim_end." };
+    }
+    return { mode: "keep", trimStart, trimEnd };
+}
+export function trimAudioDef(engine) {
+    return {
+        name: "trim_audio",
+        description: "Trim an audio asset: keep a time range (trim_start/trim_end) or cut out a section (cut_start/cut_end). Use trim_video for video assets so picture and sound remain synchronized. Operates in-place with git versioning.",
+        schema: {
+            asset_id: z.string().describe("Audio artifact id"),
+            book_id: z.string().describe("Book UUID"),
+            trim_start: z.number().optional().describe("Start of range to keep (seconds)"),
+            trim_end: z.number().optional().describe("End of range to keep (seconds)"),
+            cut_start: z.number().optional().describe("Start of chunk to remove (seconds)"),
+            cut_end: z.number().optional().describe("End of chunk to remove (seconds)"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, trim_start, trim_end, cut_start, cut_end } = args;
+            const validated = validateTrimParams(trim_start, trim_end, cut_start, cut_end);
+            if ("error" in validated) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: validated.error }],
+                };
+            }
+            const assetId = asset_id.replace(/^@/, "");
+            const artifact = engine.artifacts.get(assetId);
+            if (!artifact.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: artifact.error.message }],
+                };
+            }
+            if (artifact.value.kind !== "audio") {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "trim_audio requires an audio artifact. Use trim_video for video artifacts." }],
+                };
+            }
+            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 files = manifest.files || [];
+            const mediaFile = findAudioFile(files, artifact.value.kind);
+            if (!mediaFile) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `No audio file found in artifact ${assetId}` }],
+                };
+            }
+            const assetDir = manifest.path;
+            const mediaPath = join(assetDir, mediaFile.name);
+            try {
+                const source = await probeVideo(mediaPath);
+                if (!source.hasAudio)
+                    throw new Error("Audio file has no usable audio stream");
+                validateAudioTrimRange(source.audioDuration ?? source.duration, validated.mode, trim_start, trim_end, cut_start, cut_end);
+            }
+            catch (error) {
+                return { isError: true, content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }] };
+            }
+            const ext = extname(mediaFile.name);
+            const jobId = `trim-audio-${assetId}-${Date.now()}`;
+            const tempPath = join(assetDir, `${jobId}${ext}`);
+            const jobPayload = {
+                type: "trim_audio",
+                inputPath: mediaPath,
+                outputPath: tempPath,
+                mode: validated.mode,
+                assetId,
+                assetDir,
+                bookId: book_id,
+                commitParams: { trim_start, trim_end, cut_start, cut_end, mode: validated.mode },
+            };
+            if (validated.mode === "keep") {
+                jobPayload.trimStart = validated.trimStart;
+                jobPayload.trimEnd = validated.trimEnd;
+            }
+            else {
+                jobPayload.cutStart = validated.cutStart;
+                jobPayload.cutEnd = validated.cutEnd;
+            }
+            try {
+                await queue.enqueueAndWait(jobId, jobPayload);
+            }
+            catch (err) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Trim audio failed: ${err instanceof Error ? err.message : String(err)}` }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ asset_id: assetId, job_id: jobId, status: "completed" }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/trim-video.js

@@ -0,0 +1,168 @@
+import { findVideoFile } from "videobook-engine";
+import { z } from "zod";
+import { join } from "node:path";
+import { queue } from "../queue.js";
+import { resolveVideoAssetReference } from "./video-source-reference.js";
+import { parseVideoTimestamp, videoTimestampSchema } from "./video-time-input.js";
+import { waitForAssetReadyDef } from "./wait-for-asset-ready.js";
+function validateTrimParams(trimStart, trimEnd, cutStart, cutEnd) {
+    const hasKeep = trimStart !== undefined || trimEnd !== undefined;
+    const hasCut = cutStart !== undefined || cutEnd !== undefined;
+    if (hasKeep && hasCut) {
+        return { error: "Cannot specify both trim (keep) and cut (remove) parameters. Use one mode at a time." };
+    }
+    if (!hasKeep && !hasCut) {
+        return { error: "Must specify trim_start/trim_end (keep range) or cut_start/cut_end (remove range)." };
+    }
+    if (hasCut) {
+        if (cutStart === undefined || cutEnd === undefined) {
+            return { error: "Both cut_start and cut_end are required for cut mode." };
+        }
+        if (cutStart >= cutEnd) {
+            return { error: "cut_start must be less than cut_end." };
+        }
+        if (cutStart < 0 || cutEnd < 0) {
+            return { error: "cut_start and cut_end must be >= 0." };
+        }
+        return { mode: "cut", cutStart, cutEnd };
+    }
+    if (trimStart !== undefined && trimStart < 0) {
+        return { error: "trim_start must be >= 0." };
+    }
+    if (trimEnd !== undefined && trimEnd < 0) {
+        return { error: "trim_end must be >= 0." };
+    }
+    if (trimStart !== undefined && trimEnd !== undefined && trimStart >= trimEnd) {
+        return { error: "trim_start must be less than trim_end." };
+    }
+    return { mode: "keep", trimStart, trimEnd };
+}
+export function trimVideoDef(engine) {
+    return {
+        name: "trim_video",
+        description: "Change an existing video in place by keeping a range or removing a middle section. Use extract_video_clip for a new clip that keeps the source. Times accept seconds, 15s or 1:30.",
+        annotations: {
+            title: "Trim video in place",
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+        schema: {
+            asset_id: z.string().describe("Source video asset ID or notebook reference such as @a1"),
+            book_id: z.string().describe("Book id"),
+            notebook_id: z.string().uuid().optional().describe("Notebook UUID when asset_id is a grid reference and the book has multiple matching notebooks"),
+            trim_start: videoTimestampSchema.optional().describe("Start of range to keep"),
+            trim_end: videoTimestampSchema.optional().describe("End of range to keep"),
+            cut_start: videoTimestampSchema.optional().describe("Start of section to remove"),
+            cut_end: videoTimestampSchema.optional().describe("End of section to remove"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, notebook_id, trim_start, trim_end, cut_start, cut_end } = args;
+            let assetId;
+            let parsedTrimStart;
+            let parsedTrimEnd;
+            let parsedCutStart;
+            let parsedCutEnd;
+            try {
+                assetId = resolveVideoAssetReference(engine, asset_id, notebook_id);
+                parsedTrimStart = parseVideoTimestamp(trim_start, "trim_start");
+                parsedTrimEnd = parseVideoTimestamp(trim_end, "trim_end");
+                parsedCutStart = parseVideoTimestamp(cut_start, "cut_start");
+                parsedCutEnd = parseVideoTimestamp(cut_end, "cut_end");
+            }
+            catch (err) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+                };
+            }
+            const validated = validateTrimParams(parsedTrimStart, parsedTrimEnd, parsedCutStart, parsedCutEnd);
+            if ("error" in validated) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: validated.error }],
+                };
+            }
+            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 assetDir = manifest.path;
+            const videoPath = join(assetDir, videoFile.name);
+            const tempPath = join(assetDir, "original_trimmed.mp4");
+            const jobId = `trim-${assetId}-${Date.now()}`;
+            const jobPayload = {
+                type: "trim_video",
+                inputPath: videoPath,
+                outputPath: tempPath,
+                mode: validated.mode,
+                assetId,
+                assetDir,
+                bookId: book_id,
+                commitParams: {
+                    trim_start: parsedTrimStart,
+                    trim_end: parsedTrimEnd,
+                    cut_start: parsedCutStart,
+                    cut_end: parsedCutEnd,
+                    mode: validated.mode,
+                },
+            };
+            if (validated.mode === "keep") {
+                jobPayload.trimStart = validated.trimStart;
+                jobPayload.trimEnd = validated.trimEnd;
+            }
+            else {
+                jobPayload.cutStart = validated.cutStart;
+                jobPayload.cutEnd = validated.cutEnd;
+            }
+            try {
+                await queue.enqueueAndWait(jobId, jobPayload);
+                const readiness = await waitForAssetReadyDef(engine).handler({
+                    asset_id: assetId,
+                    book_id,
+                    timeout_seconds: 300,
+                });
+                if (readiness.isError) {
+                    const text = readiness.content.find((entry) => entry.type === "text")?.text;
+                    let detail = text ?? "Post-trim processing failed";
+                    if (text) {
+                        try {
+                            const parsed = JSON.parse(text);
+                            detail = typeof parsed.error === "string"
+                                ? parsed.error
+                                : `Post-trim processing ${String(parsed.status ?? "failed")}`;
+                        }
+                        catch {
+                            detail = text;
+                        }
+                    }
+                    throw new Error(detail);
+                }
+            }
+            catch (err) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Trim failed: ${err instanceof Error ? err.message : String(err)}` }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ asset_id: assetId, job_id: jobId, status: "completed" }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/update-script.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export function updateScriptDef(engine) {
+    return {
+        name: "update_script",
+        description: "Update a script asset's markdown content (original.md).",
+        schema: {
+            asset_id: z.string().describe("Asset ID of the script"),
+            content: z.string().describe("New markdown content"),
+            book_id: z.string().describe("Book id"),
+        },
+        handler: async (args) => {
+            const { asset_id, content, book_id: _book_id } = args;
+            const result = await engine.files.write(asset_id, "original.md", content);
+            if (!result.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: result.error.message }],
+                };
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify({ ok: true, path: result.value }) }],
+            };
+        },
+    };
+}

package/dist/tools/update-timeline-audio.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { readTimeline, timelineFailure, timelineInput, timelinePayload, writeTimeline, } from "../timeline-helpers.js";
+export function updateTimelineAudioDef(engine) {
+    return {
+        name: "update_timeline_audio",
+        description: "Update an audio overlay's volume or fades",
+        schema: {
+            book_id: z.string().uuid(),
+            audio_id: z.string().uuid(),
+            volume: z.number().min(0).max(100).optional(),
+            fade_in: z.number().min(0).optional(),
+            fade_out: z.number().min(0).optional(),
+        },
+        handler: async (args) => {
+            if (args.volume === undefined && args.fade_in === undefined && args.fade_out === undefined) {
+                return timelineFailure("Provide volume, fade_in, or fade_out");
+            }
+            const timeline = readTimeline(engine);
+            const audioId = String(args.audio_id);
+            if (!timeline.audio.some((clip) => clip.id === audioId)) {
+                return timelineFailure(`Timeline audio clip not found: ${audioId}`);
+            }
+            const result = await writeTimeline(engine, {
+                ...timelineInput(timeline),
+                audio: timeline.audio.map((clip) => ({
+                    id: clip.id,
+                    artifactId: clip.artifactId,
+                    startFrame: clip.startFrame,
+                    durationFrames: clip.durationFrames,
+                    ...(clip.id === audioId && args.volume !== undefined ? { volume: args.volume } : clip.volume === undefined ? {} : { volume: clip.volume }),
+                    ...(clip.id === audioId && args.fade_in !== undefined ? { fadeIn: args.fade_in } : clip.fadeIn === undefined ? {} : { fadeIn: clip.fadeIn }),
+                    ...(clip.id === audioId && args.fade_out !== undefined ? { fadeOut: args.fade_out } : clip.fadeOut === undefined ? {} : { fadeOut: clip.fadeOut }),
+                })),
+            });
+            return result.ok ? {
+                content: [{ type: "text", text: JSON.stringify(timelinePayload(result.value)) }],
+            } : timelineFailure(result.error.message);
+        },
+    };
+}

package/dist/tools/upload-file.js

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { uploadLocalBytes } from "../local-upload.js";
+function isBase64Upload(value) {
+    const normalized = value.replace(/\s/gu, "");
+    const match = /^([A-Za-z0-9+/_-]*)(={0,2})$/u.exec(normalized);
+    return match !== null
+        && match[1].length % 4 !== 1
+        && (match[2].length === 0 || normalized.length % 4 === 0);
+}
+export function uploadFileDef(engine) {
+    return {
+        name: "upload_file",
+        description: "Upload a media or markdown file into a Videobook project as an asset",
+        schema: {
+            book_id: z.string().describe("Book id to upload into"),
+            filename: z.string().describe("Original filename with extension"),
+            data: z.string().refine(isBase64Upload, "File contents must be valid base64").describe("Base64-encoded file contents"),
+        },
+        handler: async (args) => {
+            const { book_id, filename, data } = args;
+            const result = await uploadLocalBytes(engine, {
+                bookId: book_id,
+                filename,
+                data: Buffer.from(data, "base64"),
+                waitForProcessing: true,
+            });
+            if (!result.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: result.message }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify(result.value),
+                    }],
+            };
+        },
+    };
+}