videobook 0.0.0-stage → 0.2.0

package/dist/tools/estimate-cost.js

@@ -0,0 +1,171 @@
+import { z } from "zod";
+import { getCostProvider } from "../cost.js";
+import { referenceVideoDuration } from "../reference-video-duration.js";
+import { previewPlaceholderUrl } from "../preview-payload.js";
+import { DEFAULT_IMAGE_EDIT_MODEL_ID, findImageEditModel } from "../image-edit-models.js";
+import { tryResolveModel } from "../media/descriptor.js";
+import { estimateGeneration } from "../media/cost.js";
+import { normalizeRefs } from "../media/refs.js";
+import { REF_ROLES } from "../media/types.js";
+const GENERATION_TOOLS = new Set(["generate_image", "generate_video", "generate_audio"]);
+const REWRITE_MODEL = "gpt-5.6-sol";
+const callItem = z.object({
+    tool_name: z.string().describe("Tool whose cost to estimate: generate_image, generate_video, generate_audio, edit_image_subjects or rewrite_prompt"),
+    input: z.record(z.string(), z.unknown()).describe("Same arguments object you'd pass to the tool"),
+});
+const schema = {
+    calls: z
+        .array(callItem)
+        .min(1)
+        .describe("One or more (tool_name, input) pairs. The result sums all entries."),
+};
+const FREE_ESTIMATE = {
+    usd: 0,
+    currency: "USD",
+    source: "free",
+    breakdown: {},
+    rateAsOf: null,
+    warnings: [],
+};
+function unavailable(warning) {
+    return { ...FREE_ESTIMATE, warnings: [warning] };
+}
+function text(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function placeholderRefs(refs) {
+    const placeholders = {};
+    for (const role of REF_ROLES) {
+        const list = refs[role];
+        if (list)
+            placeholders[role] = list.map((ref) => ref.startsWith("http") ? ref : previewPlaceholderUrl(ref));
+    }
+    return placeholders;
+}
+async function sourceDuration(engine, refs) {
+    for (const ref of refs) {
+        const meta = await engine.metadata.artifacts.read(ref.replace(/^@/, ""), "original");
+        if (meta.ok && typeof meta.value?.duration === "number" && meta.value.duration > 0)
+            return meta.value.duration;
+    }
+    return undefined;
+}
+async function mediaHints(engine, refs) {
+    const videos = (refs.video ?? []).filter((ref) => !ref.startsWith("http"));
+    const videoSeconds = videos.length > 0 ? await referenceVideoDuration(engine, videos) : undefined;
+    if (videoSeconds !== undefined)
+        return { inputDurationSeconds: videoSeconds };
+    const audioSeconds = await sourceDuration(engine, (refs.audio ?? []).filter((ref) => !ref.startsWith("http")));
+    return audioSeconds === undefined ? {} : { inputDurationSeconds: audioSeconds };
+}
+async function estimateMedia(engine, input) {
+    const modelId = text(input.model);
+    const model = modelId ? tryResolveModel(modelId) : null;
+    if (!model)
+        return unavailable(`unknown model '${modelId ?? ""}'`);
+    const refs = normalizeRefs(input.refs);
+    const options = input.options !== null && typeof input.options === "object" && !Array.isArray(input.options)
+        ? input.options
+        : {};
+    const result = estimateGeneration(model, {
+        prompt: text(input.prompt),
+        refUrls: placeholderRefs(refs),
+        options,
+        mode: text(input.mode),
+    }, await mediaHints(engine, refs));
+    return result.ok ? result.estimate : unavailable(result.error);
+}
+function estimateImageEdit(input) {
+    if (input.model === "sharp/layer-composite" && input.operation === "remove")
+        return { ...FREE_ESTIMATE };
+    const editModel = findImageEditModel(text(input.model) ?? DEFAULT_IMAGE_EDIT_MODEL_ID);
+    const model = editModel ? tryResolveModel(editModel.catalogModel) : null;
+    if (!model)
+        return unavailable(`unknown image edit model '${String(input.model)}'`);
+    const imageCount = Array.isArray(input.image_refs) && input.image_refs.length > 0 ? input.image_refs.length : 1;
+    const result = estimateGeneration(model, {
+        prompt: text(input.prompt) ?? "edit",
+        refUrls: { image: Array.from({ length: imageCount }, (_, index) => `https://example.test/edit-${index + 1}.png`) },
+    });
+    return result.ok ? result.estimate : unavailable(result.error);
+}
+function estimateRewrite(input) {
+    return getCostProvider().estimate({
+        provider: "openai",
+        payload: { model: REWRITE_MODEL, input: text(input.prompt) ?? text(input.text) ?? "", max_output_tokens: 1000 },
+    });
+}
+async function estimateOne(engine, toolName, input) {
+    if (GENERATION_TOOLS.has(toolName))
+        return estimateMedia(engine, input);
+    if (toolName === "edit_image_subjects")
+        return estimateImageEdit(input);
+    if (toolName === "rewrite_prompt")
+        return estimateRewrite(input);
+    return unavailable(`no cost adapter registered for tool '${toolName}'`);
+}
+function sumEstimates(estimates) {
+    if (estimates.length === 1)
+        return estimates[0];
+    const usd = estimates.reduce((acc, e) => acc + e.usd, 0);
+    const warnings = estimates.flatMap((e) => e.warnings);
+    const allFree = estimates.every((e) => e.source === "free");
+    const sources = new Set(estimates.map((e) => e.source));
+    return {
+        usd,
+        currency: "USD",
+        source: allFree ? "free" : sources.size === 1 ? estimates[0].source : "tokens-heuristic+table",
+        breakdown: {},
+        rateAsOf: estimates.find((e) => e.rateAsOf)?.rateAsOf ?? null,
+        warnings,
+    };
+}
+export function estimateCostDef(engine, books) {
+    let injectedBookId = null;
+    try {
+        injectedBookId = engine.book.get().bookId;
+    }
+    catch {
+        injectedBookId = null;
+    }
+    const estimateCall = async (call) => {
+        const bookId = call.input.book_id;
+        if (typeof bookId !== "string" || !bookId || bookId === injectedBookId) {
+            return estimateOne(engine, call.tool_name, call.input);
+        }
+        if (!books)
+            throw new Error(`Book not found: ${bookId}`);
+        const book = await books.ensure(bookId);
+        if (!book.ok)
+            throw new Error(book.error.message);
+        return estimateOne(book.value.engine, call.tool_name, call.input);
+    };
+    return {
+        name: "estimate_cost",
+        description: "Estimate the USD cost of one or more generate_image, generate_video or generate_audio calls, given as {tool_name, input}, before running them. Models without published rates return $0 with a warning.",
+        schema,
+        handler: async (args) => {
+            const calls = args.calls;
+            let estimates;
+            try {
+                estimates = await Promise.all(calls.map(estimateCall));
+            }
+            catch (cause) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: cause instanceof Error ? cause.message : String(cause) }],
+                };
+            }
+            const total = sumEstimates(estimates);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            estimate: total,
+                            per_call: estimates.map((e, i) => ({ tool_name: calls[i].tool_name, estimate: e })),
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/even-split.js

@@ -0,0 +1,295 @@
+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";
+// Default first-chunk target for no-arg ad-hoc slicing. Caller can override
+// via target_secs (e.g. [10] or [10, 15]) for tailored chunk lengths.
+const DEFAULT_TARGET_SEC = 7;
+// ffmpeg can't reliably produce a usable mp4 below this. Mirrors split-video.ts.
+const MIN_CHUNK_SEC = 0.5;
+/**
+ * Slice the source into N+1 chunks: one chunk per target length, plus a
+ * trailing "leftover" chunk holding whatever's left. Caller decides whether
+ * to keep the leftover.
+ *
+ * Why a 1-second backup on the last target? Most gens accept 9s clips just
+ * as readily as 10s, so when the targets sum would leave a sub-MIN tail,
+ * dropping 1s from the last target is the cheapest way to still get
+ * magic-sized targeted chunks.
+ */
+export function planEvenSplit(D, targets) {
+    if (!Number.isFinite(D) || D <= 0) {
+        return { ok: false, error: "Invalid source duration." };
+    }
+    if (targets.length === 0) {
+        return { ok: false, error: "At least one target_secs value is required." };
+    }
+    for (const t of targets) {
+        if (!Number.isFinite(t) || t <= 0) {
+            return { ok: false, error: `Invalid target_secs value: ${t}.` };
+        }
+    }
+    // Build a plan if these targets are workable: sum must fit within D,
+    // and the trailing leftover must be either exactly zero or ≥ MIN.
+    const tryPlan = (ts) => {
+        const sum = ts.reduce((a, b) => a + b, 0);
+        if (sum > D)
+            return null;
+        const leftover = D - sum;
+        if (leftover > 0 && leftover < MIN_CHUNK_SEC)
+            return null;
+        const chunks = [];
+        let cursor = 0;
+        for (const t of ts) {
+            chunks.push({ start: cursor, end: cursor + t, duration: t, exact: true });
+            cursor += t;
+        }
+        const hasLeftover = leftover >= MIN_CHUNK_SEC;
+        if (hasLeftover) {
+            chunks.push({ start: cursor, end: D, duration: leftover, exact: false });
+        }
+        return { chunks, hasLeftover };
+    };
+    // Try targets as-is first.
+    const direct = tryPlan(targets);
+    if (direct) {
+        return { ok: true, chunks: direct.chunks, usedTargets: targets, hasLeftover: direct.hasLeftover };
+    }
+    // Backup: knock 1s off the last target. Covers two failure modes:
+    //   (a) last target overshoots D (e.g. D=9.5, [10] → [9])
+    //   (b) sub-MIN tail (e.g. D=10.4, [10] → [9] with 1.4s leftover)
+    const last = targets[targets.length - 1];
+    if (last > 1) {
+        const backed = [...targets.slice(0, -1), last - 1];
+        const backedPlan = tryPlan(backed);
+        if (backedPlan) {
+            return {
+                ok: true,
+                chunks: backedPlan.chunks,
+                usedTargets: backed,
+                hasLeftover: backedPlan.hasLeftover,
+            };
+        }
+    }
+    const sum = targets.reduce((a, b) => a + b, 0);
+    return {
+        ok: false,
+        error: `Source ${D.toFixed(2)}s is too short to split off targets [${targets.join(", ")}] (sum ${sum.toFixed(2)}s).`,
+    };
+}
+function parseSingleTarget(input) {
+    if (typeof input === "number")
+        return input;
+    // Strip a trailing unit suffix like "s" / " sec" so "10s" parses cleanly.
+    const stripped = input.trim().replace(/\s*s(ec(onds?)?)?$/i, "");
+    return Number(stripped);
+}
+function parseTargetSecs(input) {
+    if (input === undefined || input.length === 0)
+        return [DEFAULT_TARGET_SEC];
+    return input.map(parseSingleTarget);
+}
+// Numeric suffixes "1".."N" mark chunk order; trim the source label to its
+// last 2 words so labels stay short. Mirrors split-video.ts.
+function deriveChunkName(source, index) {
+    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}-${index}`;
+}
+export function splitVideoByDurationsDef(engine) {
+    return {
+        name: "split_video_by_durations",
+        description: "Cut a video into chunks of the target_secs lengths (e.g. [10, 15]) plus a leftover chunk, as new video assets; the source is kept. With destination, the chunks are written as files into an existing asset instead, without the leftover.",
+        schema: {
+            asset_id: z.string().describe("Source video artifact id"),
+            book_id: z.string().describe("Book UUID"),
+            // Accept array of strings/numbers; chat positional args arrive as strings
+            // (possibly with unit suffixes like "10s"), MCP clients typically pass numbers.
+            target_secs: z
+                .array(z.union([z.number(), z.string()]))
+                .optional()
+                .describe("Ordered list of target chunk lengths in seconds (default [7]). Each entry accepts '7', '7s', or 7. A leftover chunk holds whatever's left after these."),
+            destination: z
+                .object({
+                asset_id: z.string().describe("Existing artifact id to write chunk files into"),
+                filenames: z.array(z.string()).describe("One filename per target_secs entry; written as siblings inside the destination asset's directory"),
+            })
+                .optional()
+                .describe("When set, write each chunk to <destination.asset_id>/<filenames[i]> instead of minting fresh video assets. filenames.length must equal target_secs.length; no leftover chunk is produced in destination mode."),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, target_secs, destination } = args;
+            const targets = parseTargetSecs(target_secs);
+            // Destination-mode arity: one filename per target, and no leftover —
+            // the caller has named exactly which siblings to write inside the
+            // destination asset. Reject early so we don't probe ffmpeg for nothing.
+            if (destination !== undefined && destination.filenames.length !== targets.length) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: `destination.filenames length (${destination.filenames.length}) must equal target_secs length (${targets.length})`,
+                        }],
+                };
+            }
+            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 sourcePath = join(manifest.path, videoFile.name);
+            let sourceDurationSec;
+            try {
+                sourceDurationSec = (await probeVideo(sourcePath)).duration;
+            }
+            catch (err) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: `Failed to probe source duration: ${err instanceof Error ? err.message : String(err)}`,
+                        }],
+                };
+            }
+            const plan = planEvenSplit(sourceDurationSec, targets);
+            if (!plan.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: plan.error }],
+                };
+            }
+            // Destination mode produces one output per target — no leftover —
+            // because the caller declared the exact set of filenames to write.
+            // The targets-only plan already enforces summing fits under D, so
+            // hasLeftover signals "leftover would have spilled" and we refuse.
+            if (destination !== undefined && plan.hasLeftover) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: `Destination mode does not support leftover chunks: targets sum to ${plan.usedTargets.reduce((a, b) => a + b, 0).toFixed(2)}s but source is ${sourceDurationSec.toFixed(2)}s`,
+                        }],
+                };
+            }
+            let created;
+            let destinationMode = false;
+            if (destination !== undefined) {
+                destinationMode = true;
+                try {
+                    destination.filenames = await validateMediaOutputPaths(engine, destination.asset_id, destination.filenames, ".mp4");
+                }
+                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}` }],
+                    };
+                }
+                // In destination mode `plan.chunks` has exactly N entries (no leftover);
+                // pair them with the caller's filenames positionally.
+                created = plan.chunks.map((chunk, i) => ({
+                    assetId: destination.asset_id,
+                    assetDir: destManifest.value.path,
+                    outputPath: join(destManifest.value.path, destination.filenames[i]),
+                    start: chunk.start,
+                    end: chunk.end,
+                    duration: chunk.duration,
+                    exact: chunk.exact,
+                }));
+            }
+            else {
+                created = [];
+                for (let i = 0; i < plan.chunks.length; i++) {
+                    const chunk = plan.chunks[i];
+                    const name = deriveChunkName(sourceArtifact.value, i + 1);
+                    const c = await engine.artifacts.create(sourceArtifact.value.kind, name);
+                    if (!c.ok) {
+                        return {
+                            isError: true,
+                            content: [{ type: "text", text: `Failed to create chunk ${i + 1} asset: ${c.error.message}` }],
+                        };
+                    }
+                    created.push({
+                        assetId: c.value.artifactId,
+                        assetDir: c.value.path,
+                        outputPath: join(c.value.path, "original.mp4"),
+                        start: chunk.start,
+                        end: chunk.end,
+                        duration: chunk.duration,
+                        exact: chunk.exact,
+                    });
+                }
+            }
+            const jobId = `even-split-${asset_id}-${Date.now()}`;
+            // Fire-and-forget: the chunk assets/files were already created above, so
+            // the UI can pick them up immediately. ffmpeg failures now surface via the
+            // asset-work failed state like every other queued tool, not this response.
+            await queue.enqueue(jobId, {
+                type: "even_split",
+                sourcePath,
+                sourceAssetId: asset_id,
+                chunks: created,
+                bookId: book_id,
+                destination: destinationMode ? { assetId: destination.asset_id } : undefined,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify(destinationMode
+                            ? {
+                                source_asset_id: asset_id,
+                                source_duration_sec: sourceDurationSec,
+                                target_secs: targets,
+                                used_target_secs: plan.usedTargets,
+                                destination: {
+                                    asset_id: destination.asset_id,
+                                    filenames: destination.filenames,
+                                },
+                                job_id: jobId,
+                                status: "enqueued",
+                            }
+                            : {
+                                source_asset_id: asset_id,
+                                source_duration_sec: sourceDurationSec,
+                                target_secs: targets,
+                                used_target_secs: plan.usedTargets,
+                                has_leftover: plan.hasLeftover,
+                                chunks: created.map((c) => ({
+                                    asset_id: c.assetId,
+                                    duration: c.duration,
+                                    exact: c.exact,
+                                })),
+                                job_id: jobId,
+                                status: "enqueued",
+                            }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/export-asset-file.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+import { copyFileToClipboardDef } from "./copy-file-to-clipboard.js";
+import { exportToDownloadsDef } from "./export-to-downloads.js";
+import { showFolderDef } from "./show-folder.js";
+const DESTINATIONS = ["downloads", "clipboard", "finder"];
+export function exportAssetFileDef(engine) {
+    const handlers = {
+        downloads: exportToDownloadsDef(engine).handler,
+        clipboard: copyFileToClipboardDef(engine).handler,
+        finder: showFolderDef(engine).handler,
+    };
+    return {
+        name: "export_asset_file",
+        description: "Hand an asset's original media file to macOS: copy it to Downloads, put it on the pasteboard as a file, or reveal its folder in Finder.",
+        schema: {
+            book_id: z.string().describe("Book id"),
+            asset_id: z.string().describe("Artifact id"),
+            to: z.enum(DESTINATIONS),
+        },
+        handler: async (args) => handlers[args.to](args),
+    };
+}

package/dist/tools/export-asset.js

@@ -0,0 +1,140 @@
+import { v7 as uuidv7 } from "uuid";
+import { z } from "zod";
+import { transferAssetTags } from "../asset-tags.js";
+import { resolveBookReference } from "../media-library.js";
+import { queue } from "../queue.js";
+export function exportAssetDef(engine, books) {
+    return {
+        name: "export_asset_to_project",
+        description: "Export an asset from one project to a different project",
+        ...(books ? { scope: "global" } : {}),
+        schema: {
+            asset_id: z.string().describe("Artifact id to export"),
+            book_id: z.string().describe("Source book UUID"),
+            target_project: z.string().describe("Target book name or UUID"),
+            new_name: z.string().optional().describe("Optional custom name for the exported asset"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, target_project, new_name } = args;
+            if (book_id === target_project) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: "Source and target are the same project. Use duplicate_asset to copy within the same project.",
+                        }],
+                };
+            }
+            if (books) {
+                try {
+                    const sourceBook = await resolveBookReference(books, book_id);
+                    const targetBook = await resolveBookReference(books, target_project);
+                    if (sourceBook.bookId === targetBook.bookId) {
+                        throw new Error("Source and target are the same project. Use duplicate_asset to copy within the same project.");
+                    }
+                    const sourceArtifact = sourceBook.engine.artifacts.get(asset_id);
+                    if (!sourceArtifact.ok) {
+                        throw new Error(sourceArtifact.error.message);
+                    }
+                    const result = await queue.enqueueAndWait(`copy-library-asset-${uuidv7()}`, {
+                        type: "copy_library_asset",
+                        bookId: targetBook.bookId,
+                        sourceBookId: sourceBook.bookId,
+                        sourceArtifactId: sourceArtifact.value.artifactId,
+                        targetBookId: targetBook.bookId,
+                        ...(new_name ? { newName: new_name } : {}),
+                    }, 15 * 60_000);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    source_asset_id: asset_id,
+                                    new_asset_id: result.targetArtifactId,
+                                    source_project: book_id,
+                                    target_project,
+                                    source_artifact_id: result.sourceArtifactId,
+                                    target_artifact_id: result.targetArtifactId,
+                                    source_book_id: result.sourceBookId,
+                                    target_book_id: result.targetBookId,
+                                }),
+                            }],
+                    };
+                }
+                catch (cause) {
+                    return {
+                        isError: true,
+                        content: [{
+                                type: "text",
+                                text: cause instanceof Error ? cause.message : String(cause),
+                            }],
+                    };
+                }
+            }
+            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 name = new_name ?? sourceArtifact.value.label;
+            const createResult = await engine.artifacts.create({
+                kind: sourceArtifact.value.kind,
+                ...(name ? { label: name } : {}),
+            });
+            if (!createResult.ok) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: createResult.error.message }],
+                };
+            }
+            const newAssetId = createResult.value.artifactId;
+            for (const file of manifestResult.value.files) {
+                const readResult = await engine.files.read(asset_id, file.name);
+                if (!readResult.ok) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: readResult.error.message }],
+                    };
+                }
+                const writeResult = await engine.files.write(newAssetId, file.name, readResult.value);
+                if (!writeResult.ok) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: writeResult.error.message }],
+                    };
+                }
+            }
+            try {
+                await transferAssetTags({ engine, artifactId: asset_id }, { engine, artifactId: newAssetId });
+            }
+            catch (cause) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: cause instanceof Error ? cause.message : String(cause),
+                        }],
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            source_asset_id: asset_id,
+                            new_asset_id: newAssetId,
+                            source_project: book_id,
+                            target_project,
+                        }),
+                    }],
+            };
+        },
+    };
+}