videobook 0.0.0-stage → 0.2.0

package/dist/tools/list-assets.js

@@ -0,0 +1,98 @@
+import { z } from "zod";
+import { buildAssetList } from "./reconcile-project-work.js";
+import { matchesTagFilter, } from "../asset-tags.js";
+import { tagSelectorSchema } from "./asset-tags.js";
+import { LIBRARY_BROWSE_STATUSES, isLibraryBrowseStatus, pageLibraryAssets, } from "../library-browse.js";
+export function listAssetsDef(engine) {
+    return {
+        name: "list_assets",
+        description: "List a bounded asset page with media and thumbnail URLs, optionally including notebook and sequence-referenced assets outside the page.",
+        schema: {
+            book_id: z.string().describe("Book id"),
+            sort: z.enum(["newest", "oldest"]).optional().describe("Sort order by creation date"),
+            limit: z.number().int().positive().max(500).optional(),
+            offset: z.number().int().nonnegative().optional(),
+            include_referenced: z.boolean().optional(),
+            browse_status: z.enum(LIBRARY_BROWSE_STATUSES).optional()
+                .describe("Filter Library media by artifact status before paging. Omit to keep the unfiltered page, including notebooks and other non-media artifacts."),
+            tags_all: z.array(tagSelectorSchema).optional()
+                .describe("Only assets carrying every one of these tags"),
+            tags_any: z.array(tagSelectorSchema).optional()
+                .describe("Only assets carrying at least one of these tags"),
+        },
+        handler: async (args) => {
+            const { book_id, sort, limit, offset, include_referenced, browse_status, tags_all, tags_any, } = args;
+            const allAssets = await buildAssetList(engine, book_id, sort);
+            const tagFilter = {
+                ...(tags_all ? { all: tags_all } : {}),
+                ...(tags_any ? { any: tags_any } : {}),
+            };
+            let taggedAssets;
+            try {
+                taggedAssets = allAssets.filter((asset) => matchesTagFilter(asset.tags ?? undefined, tagFilter));
+            }
+            catch (cause) {
+                return {
+                    isError: true,
+                    content: [{
+                            type: "text",
+                            text: cause instanceof Error ? cause.message : String(cause),
+                        }],
+                };
+            }
+            const browseStatus = isLibraryBrowseStatus(browse_status)
+                ? browse_status
+                : undefined;
+            const paged = pageLibraryAssets(taggedAssets, {
+                ...(browseStatus ? { browseStatus } : {}),
+                offset: offset ?? 0,
+                limit: limit ?? 200,
+            });
+            const pageArtifactIds = new Set(paged.pageAssets.map((asset) => asset.artifact_id));
+            const referencedArtifactIds = include_referenced
+                ? new Set(engine.notebooks
+                    .list()
+                    .flatMap((notebook) => notebook.cells.flatMap((cell) => {
+                    const versionIds = Array.isArray(cell.inputs?.outputVersionArtifactIds)
+                        ? cell.inputs.outputVersionArtifactIds.filter((id) => typeof id === "string" && id.length > 0)
+                        : [];
+                    return [
+                        ...(cell.outputArtifactId ? [cell.outputArtifactId] : []),
+                        ...(typeof cell.inputs?.firstFrameArtifactId === "string"
+                            ? [cell.inputs.firstFrameArtifactId]
+                            : []),
+                        ...(typeof cell.inputs?.lastFrameArtifactId === "string"
+                            ? [cell.inputs.lastFrameArtifactId]
+                            : []),
+                        ...(typeof cell.inputs?.providerArtifactId === "string"
+                            ? [cell.inputs.providerArtifactId]
+                            : []),
+                        ...versionIds,
+                    ];
+                })))
+                : new Set();
+            if (include_referenced) {
+                for (const clip of engine.sequences.getPrimary().clips) {
+                    referencedArtifactIds.add(clip.source.artifactId);
+                }
+            }
+            // Hydration is deliberately unfiltered: a notebook needs the media it
+            // references whether or not that asset carries the filtered tags.
+            const referencedAssets = include_referenced
+                ? allAssets.filter((asset) => referencedArtifactIds.has(asset.artifact_id)
+                    && !pageArtifactIds.has(asset.artifact_id))
+                : [];
+            const assets = [...paged.pageAssets, ...referencedAssets];
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            assets,
+                            page: paged.page,
+                            status_counts: paged.statusCounts,
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/list-cell-generations.js

@@ -0,0 +1,225 @@
+import { z } from "zod";
+import { findGenerateAudioOutput, findGenerateImageOutput, findGenerateVideoOutput, listGenerateImageOutputs, listGenerateVideoOutputs, } from "../notebook-cell-outputs.js";
+import { buildAssetList } from "./reconcile-project-work.js";
+import { readProviderTaskStatus } from "../provider-task-status.js";
+function generationArtifactIds(generations) {
+    return [...new Set(generations.flatMap((row) => [
+            ...(row.outputArtifactId ? [row.outputArtifactId] : []),
+            ...(row.providerArtifactId ? [row.providerArtifactId] : []),
+        ]))];
+}
+export function pairForCell(document, cellId) {
+    const cell = document.cells.find((candidate) => candidate.id === cellId);
+    if (!cell)
+        throw new Error(`Cell not found: ${cellId}`);
+    if (cell.type === "generate_video") {
+        const output = findGenerateVideoOutput(document, cell.id);
+        return { generateCell: cell, outputCell: output?.outputCell ?? null };
+    }
+    if (cell.type === "generate_image") {
+        const output = findGenerateImageOutput(document, cell.id);
+        return { generateCell: cell, outputCell: output?.outputCell ?? null };
+    }
+    if (cell.type === "generate_audio") {
+        const output = findGenerateAudioOutput(document, cell.id);
+        return { generateCell: cell, outputCell: output?.outputCell ?? null };
+    }
+    if (cell.type === "video") {
+        const producerEdge = document.edges.find((edge) => edge.target === cell.id
+            && (edge.targetInput === "output" || edge.targetInput === "media"));
+        const producer = producerEdge
+            ? document.cells.find((candidate) => candidate.id === producerEdge.source)
+            : undefined;
+        if (producer?.type === "generate_video") {
+            return { generateCell: producer, outputCell: cell };
+        }
+    }
+    if (cell.type === "image") {
+        const producerEdge = document.edges.find((edge) => edge.target === cell.id
+            && (edge.targetInput === "media" || edge.targetInput === "output"));
+        const producer = producerEdge
+            ? document.cells.find((candidate) => candidate.id === producerEdge.source)
+            : undefined;
+        if (producer?.type === "generate_image") {
+            return { generateCell: producer, outputCell: cell };
+        }
+    }
+    if (cell.type === "audio") {
+        const producerEdge = document.edges.find((edge) => edge.target === cell.id
+            && (edge.targetInput === "media" || edge.targetInput === "output"));
+        const producer = producerEdge
+            ? document.cells.find((candidate) => candidate.id === producerEdge.source)
+            : undefined;
+        if (producer?.type === "generate_audio") {
+            return { generateCell: producer, outputCell: cell };
+        }
+    }
+    return { generateCell: cell, outputCell: null };
+}
+const TRANSITION_SCAN_LIMIT = 500;
+function generationTransitions(engine, generations) {
+    const wanted = new Set(generations.map((row) => row.generationId));
+    const transitions = new Map();
+    if (wanted.size === 0)
+        return transitions;
+    for (const revision of engine.history.revisions(TRANSITION_SCAN_LIMIT)) {
+        const details = revision.details ?? {};
+        const generationId = typeof details.generationId === "string"
+            ? details.generationId
+            : null;
+        if (!generationId || !wanted.has(generationId))
+            continue;
+        const status = typeof details.status === "string" ? details.status : null;
+        if (!status)
+            continue;
+        const entries = transitions.get(generationId) ?? [];
+        entries.push({
+            status: status,
+            commitHash: revision.hash,
+            commitDate: revision.date,
+        });
+        transitions.set(generationId, entries);
+    }
+    for (const entries of transitions.values())
+        entries.reverse();
+    return transitions;
+}
+export function listCellGenerationsDef(engine) {
+    return {
+        name: "list_cell_generations",
+        description: "List recorded generation attempts for a notebook cell: one attempt per dispatch, each with its per-attempt transition timeline.",
+        schema: {
+            book_id: z.string().describe("Book id"),
+            notebook_id: z.string().describe("Notebook id"),
+            cell_id: z.string().describe("Cell id (generate or output cell)"),
+            include_payloads: z.boolean().optional()
+                .describe("Include full generation-payload bodies (default false)"),
+            limit: z.number().int().positive().max(100).optional()
+                .describe("Max attempts to return (default 20)"),
+        },
+        handler: async (args) => {
+            try {
+                const { book_id, notebook_id, cell_id, include_payloads = false, limit = 20, } = args;
+                const read = engine.notebooks.read(notebook_id);
+                if (!read.ok) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: read.error.message }],
+                    };
+                }
+                const document = read.value;
+                const { generateCell, outputCell } = pairForCell(document, cell_id);
+                const outputCellIds = generateCell.type === "generate_image"
+                    ? listGenerateImageOutputs(document, generateCell.id).map((item) => item.outputCell.id)
+                    : generateCell.type === "generate_video"
+                        ? listGenerateVideoOutputs(document, generateCell.id).map((item) => item.outputCell.id)
+                        : outputCell ? [outputCell.id] : [];
+                const generationsResult = engine.generations.listForCell(notebook_id, generateCell.id, { limit });
+                if (!generationsResult.ok) {
+                    return {
+                        isError: true,
+                        content: [{
+                                type: "text",
+                                text: generationsResult.error.message,
+                            }],
+                    };
+                }
+                const requestedResult = document.cells.find((cell) => cell.id === cell_id);
+                const filterToResult = requestedResult
+                    && requestedResult.id !== generateCell.id
+                    && outputCell?.id === requestedResult.id;
+                const rows = filterToResult
+                    ? generationsResult.value.filter((row) => !row.outputCellId || row.outputCellId === requestedResult.id)
+                    : generationsResult.value;
+                const transitions = generationTransitions(engine, rows);
+                const assets = await buildAssetList(engine, book_id);
+                const assetById = new Map(assets.map((asset) => [asset.artifact_id, asset]));
+                const attempts = [];
+                for (const row of rows) {
+                    const joinArtifactId = row.outputArtifactId
+                        ?? row.providerArtifactId
+                        ?? null;
+                    const asset = joinArtifactId
+                        ? assetById.get(joinArtifactId)
+                        : undefined;
+                    let payloadAvailable = false;
+                    let payload = null;
+                    let commandPlan = null;
+                    if (joinArtifactId) {
+                        const payloadRes = await engine.metadata.artifacts.read(joinArtifactId, "generation-payload");
+                        if (payloadRes.ok) {
+                            payloadAvailable = true;
+                            payload = payloadRes.value;
+                        }
+                        const planRes = await engine.metadata.artifacts.read(joinArtifactId, "command-plan");
+                        if (planRes.ok)
+                            commandPlan = planRes.value;
+                    }
+                    let error = row.error ?? null;
+                    if (!error && joinArtifactId) {
+                        const failRes = await engine.jobs.failures.read(joinArtifactId);
+                        if (failRes.ok && failRes.value)
+                            error = failRes.value.message;
+                    }
+                    attempts.push({
+                        attemptId: row.generationId,
+                        status: row.status,
+                        runId: row.runId ?? null,
+                        tool: row.tool,
+                        provider: row.provider ?? null,
+                        model: row.model ?? null,
+                        prompt: row.prompt ?? null,
+                        resolvedPrompt: row.resolvedPrompt ?? null,
+                        artifactId: row.outputArtifactId ?? null,
+                        providerArtifactId: row.providerArtifactId ?? null,
+                        providerTask: await readProviderTaskStatus(engine, row.providerArtifactId ?? joinArtifactId, row),
+                        error,
+                        mediaUrl: asset?.media_url ?? null,
+                        thumbnailUrl: asset?.thumbnail_url ?? null,
+                        payloadAvailable,
+                        ...(include_payloads ? { payload } : {}),
+                        commandPlan,
+                        transitions: transitions.get(row.generationId) ?? [],
+                        createdAt: row.createdAt,
+                        updatedAt: row.updatedAt,
+                    });
+                }
+                const currentExecution = (outputCell
+                    ? document.execution?.[outputCell.id]
+                    : undefined)
+                    ?? document.execution?.[generateCell.id]
+                    ?? null;
+                const generationPlans = (document.generationPlans ?? []).filter((plan) => plan.cellId === generateCell.id
+                    || (outputCell ? plan.cellId === outputCell.id : false));
+                const response = {
+                    notebookId: notebook_id,
+                    cellId: cell_id,
+                    generateCellId: generateCell.id,
+                    outputCellId: outputCell?.id ?? null,
+                    outputCellIds,
+                    attempts,
+                    currentExecution,
+                    generationPlans,
+                    generations: {
+                        count: rows.length,
+                        latestStatus: rows[0]?.status ?? null,
+                        artifactIds: generationArtifactIds(rows),
+                    },
+                };
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(response),
+                        }],
+                };
+            }
+            catch (cause) {
+                const message = cause instanceof Error ? cause.message : String(cause);
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: message }],
+                };
+            }
+        },
+    };
+}

package/dist/tools/list-elevenlabs-voices.js

@@ -0,0 +1,163 @@
+import { createElevenLabs } from "../usage-providers.js";
+import { getApiKey } from "../api-key.js";
+export const GENERIC_FALLBACK_VOICES = [
+    { voice_id: "JBFqnCBsd6RMkjVDRZzb", name: "Generic", source: "generic" },
+    { voice_id: "21m00Tcm4TlvDq8ikWAM", name: "Rachel", source: "generic" },
+    { voice_id: "AZnzlk1XvdvUeBnXmlld", name: "Domi", source: "generic" },
+    { voice_id: "EXAVITQu4vr4xnSDxMaL", name: "Bella", source: "generic" },
+    { voice_id: "ErXwobaYiN019PkySvjV", name: "Antoni", source: "generic" },
+    { voice_id: "MF3mGyEYCl7XYWbV9V6O", name: "Elli", source: "generic" },
+    { voice_id: "TxGEqnHWrfWFTfGW9XjX", name: "Josh", source: "generic" },
+    { voice_id: "VR6AewLTigWG4xSOukaG", name: "Arnold", source: "generic" },
+    { voice_id: "pNInz6obpgDQGcFmaJgB", name: "Adam", source: "generic" },
+    { voice_id: "yoZ06aMxZJJ28mfd3POQ", name: "Sam", source: "generic" },
+];
+function readConfiguredCustomVoices() {
+    const raw = process.env.ELEVENLABS_CUSTOM_VOICE_IDS ?? process.env.ELEVENLABS_CUSTOM_VOICES ?? "";
+    return raw
+        .split(/[\n,]+/)
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .map(parseCustomVoice)
+        .filter((voice) => voice !== null);
+}
+function parseCustomVoice(entry) {
+    const parts = entry.split(/\s*(?:=|\||:)\s*/);
+    if (parts.length >= 2) {
+        const [name, ...idParts] = parts;
+        const voiceId = idParts.join(":").trim();
+        if (!voiceId)
+            return null;
+        return { voice_id: voiceId, name: name.trim() || voiceId, source: "custom" };
+    }
+    return { voice_id: entry, name: entry, source: "custom" };
+}
+function addUnique(target, seen, voice) {
+    const id = voice.voice_id.trim();
+    if (!id || seen.has(id))
+        return;
+    seen.add(id);
+    target.push({ ...voice, voice_id: id, name: voice.name.trim() || id });
+}
+function mergeVoiceGroups(...groups) {
+    const seen = new Set();
+    const voices = [];
+    for (const group of groups) {
+        for (const voice of group) {
+            addUnique(voices, seen, voice);
+        }
+    }
+    return voices;
+}
+function normalizeApiVoice(item, source) {
+    const voiceId = item.voice_id.trim();
+    if (!voiceId)
+        return null;
+    const name = item.name?.trim() || voiceId;
+    const category = item.category?.trim();
+    const previewUrl = item.preview_url?.trim();
+    return {
+        voice_id: voiceId,
+        name,
+        source,
+        ...(category ? { category } : {}),
+        ...(previewUrl ? { preview_url: previewUrl } : {}),
+    };
+}
+async function fetchVoiceGroup(apiKey, voiceType, fetchFn) {
+    const provider = createElevenLabs({ apiKey, timeout: 30_000, fetch: fetchFn });
+    const source = voiceType === "default" ? "generic" : "custom";
+    const voices = [];
+    let nextPageToken = null;
+    for (let page = 0; page < 10; page += 1) {
+        const body = await provider.v2.voices({
+            voice_type: voiceType,
+            page_size: 100,
+            include_total_count: false,
+            ...(nextPageToken ? { next_page_token: nextPageToken } : {}),
+        });
+        for (const item of body.voices) {
+            const normalized = normalizeApiVoice(item, source);
+            if (normalized)
+                voices.push(normalized);
+        }
+        nextPageToken = body.next_page_token?.trim()
+            ? body.next_page_token.trim()
+            : null;
+        if (!body.has_more || !nextPageToken)
+            break;
+    }
+    return voices;
+}
+export async function listElevenLabsVoices(fetchFn = fetch) {
+    const configuredCustom = readConfiguredCustomVoices();
+    const apiKey = getApiKey("ELEVENLABS_API_KEY");
+    if (!apiKey) {
+        return {
+            voices: mergeVoiceGroups(configuredCustom, GENERIC_FALLBACK_VOICES),
+            status: "fallback",
+            warning: "ELEVENLABS_API_KEY is not configured; showing configured custom IDs and generic fallback IDs.",
+        };
+    }
+    try {
+        const [custom, generic] = await Promise.all([
+            fetchVoiceGroup(apiKey, "non-default", fetchFn),
+            fetchVoiceGroup(apiKey, "default", fetchFn),
+        ]);
+        return {
+            voices: mergeVoiceGroups(configuredCustom, custom, generic.length > 0 ? generic : GENERIC_FALLBACK_VOICES),
+            status: "live",
+            warning: generic.length > 0 ? null : "No default voices were returned by ElevenLabs; generic fallback IDs are shown after custom voices.",
+        };
+    }
+    catch (error) {
+        return {
+            voices: mergeVoiceGroups(configuredCustom, GENERIC_FALLBACK_VOICES),
+            status: "fallback",
+            warning: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+const LIVE_VOICE_CACHE_TTL_MS = 5 * 60 * 1000;
+let liveVoiceCache = null;
+function voiceCredentialFingerprint() {
+    const customVoices = process.env.ELEVENLABS_CUSTOM_VOICE_IDS
+        ?? process.env.ELEVENLABS_CUSTOM_VOICES
+        ?? "";
+    return `${getApiKey("ELEVENLABS_API_KEY") ?? ""}\u0000${customVoices}`;
+}
+export function listElevenLabsVoicesDef() {
+    return {
+        name: "list_elevenlabs_voices",
+        description: "List available ElevenLabs voice IDs with custom voices first and generic voices after them",
+        schema: {},
+        handler: async () => {
+            const now = Date.now();
+            const credentialFingerprint = voiceCredentialFingerprint();
+            if (liveVoiceCache
+                && liveVoiceCache.expiresAt > now
+                && liveVoiceCache.credentialFingerprint === credentialFingerprint) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(liveVoiceCache.payload),
+                        }],
+                };
+            }
+            const payload = await listElevenLabsVoices();
+            if (payload.status === "live") {
+                liveVoiceCache = {
+                    expiresAt: now + LIVE_VOICE_CACHE_TTL_MS,
+                    credentialFingerprint,
+                    payload,
+                };
+            }
+            else {
+                liveVoiceCache = null;
+            }
+            return {
+                content: [{ type: "text", text: JSON.stringify(payload) }],
+            };
+        },
+    };
+}

package/dist/tools/log-wrapper.js

@@ -0,0 +1,29 @@
+import { registerDiagnosticName } from "../diagnostics.js";
+import { logger } from "../logger.js";
+export function withLogging(def, _engine) {
+    registerDiagnosticName("tool", def.name);
+    return {
+        ...def,
+        handler: async (args) => {
+            const startedAt = performance.now();
+            try {
+                const result = await def.handler(args);
+                logger.info("mcp", {
+                    tool: def.name,
+                    status: result.isError ? "error" : "ok",
+                    durationMs: Math.round(performance.now() - startedAt),
+                });
+                return result;
+            }
+            catch (error) {
+                logger.info("mcp", {
+                    tool: def.name,
+                    status: "error",
+                    durationMs: Math.round(performance.now() - startedAt),
+                    error,
+                });
+                throw error;
+            }
+        },
+    };
+}

package/dist/tools/make-cover-song.js

@@ -0,0 +1,95 @@
+import { join } from "node:path";
+import { findAudioFile, findVideoFile } from "videobook-engine";
+import { z } from "zod";
+import { checkAceStepAvailability } from "../acestep/config.js";
+import { probeVideo } from "../ffmpeg.js";
+import { queue } from "../queue.js";
+import { toolError } from "./_shared.js";
+const MIN_SOURCE_DURATION_MS = 10_000;
+const MAX_SOURCE_DURATION_MS = 240_000;
+function coverSongLabel(source) {
+    return `cover-song-${source.label?.trim() || source.artifactId}`;
+}
+export function makeCoverSongDef(engine) {
+    return {
+        name: "make_cover_song",
+        description: "Make a new drums-and-strings instrumental cover of 10-240 seconds of a video or audio asset's sound, generated locally with ACE-Step. The duration matches exactly; style matching is best-effort.",
+        schema: {
+            book_id: z.string().describe("Book UUID"),
+            asset_id: z.string().describe("Source video or audio artifact id"),
+            direction: z.string().trim().min(1).max(500).optional().describe("Optional additional musical direction"),
+        },
+        handler: async (args) => {
+            const availability = await checkAceStepAvailability();
+            if (!availability.available) {
+                return toolError(availability.reason);
+            }
+            const { asset_id, book_id, direction } = args;
+            const sourceAssetId = asset_id.replace(/^@/u, "");
+            const sourceArtifact = engine.artifacts.get(sourceAssetId);
+            if (!sourceArtifact.ok)
+                return toolError(sourceArtifact.error.message);
+            const sourceKind = sourceArtifact.value.kind;
+            const isVideo = sourceKind === "video";
+            const isAudio = sourceKind === "audio";
+            if (!isVideo && !isAudio) {
+                return toolError(`make_cover_song requires video or audio media; ${sourceAssetId} is ${sourceKind}`);
+            }
+            const manifest = await engine.files.manifest(sourceAssetId);
+            if (!manifest.ok)
+                return toolError(manifest.error.message);
+            const sourceFile = isVideo
+                ? findVideoFile(manifest.value.files)
+                : findAudioFile(manifest.value.files, sourceKind);
+            if (!sourceFile)
+                return toolError(`No ${isVideo ? "video" : "audio"} file found in artifact ${sourceAssetId}`);
+            let targetDurationMs;
+            try {
+                const probe = await probeVideo(join(manifest.value.path, sourceFile.name));
+                if (isVideo && (probe.videoStream === null || probe.videoCodec === null)) {
+                    return toolError(`Video file ${sourceFile.name} has no video stream`);
+                }
+                if (!probe.hasAudio || probe.audioStream === null) {
+                    return toolError(`Media file ${sourceFile.name} has no audio stream`);
+                }
+                const sourceDuration = isVideo ? probe.videoDuration : probe.audioDuration;
+                if (sourceDuration === null || !Number.isFinite(sourceDuration) || sourceDuration <= 0) {
+                    return toolError(`Could not determine a valid media duration for ${sourceAssetId}`);
+                }
+                targetDurationMs = Math.round(sourceDuration * 1000);
+            }
+            catch (error) {
+                return toolError(`Failed to probe ${sourceAssetId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (targetDurationMs < MIN_SOURCE_DURATION_MS || targetDurationMs > MAX_SOURCE_DURATION_MS) {
+                return toolError(`make_cover_song requires a media duration between 10.000s and 240.000s inclusive; got ${(targetDurationMs / 1000).toFixed(3)}s`);
+            }
+            const created = await engine.artifacts.create("audio", coverSongLabel(sourceArtifact.value));
+            if (!created.ok)
+                return toolError(`Failed to create audio asset: ${created.error.message}`);
+            const jobId = `make-cover-song-${created.value.artifactId}-${Date.now()}`;
+            await queue.enqueue(jobId, {
+                type: "generate_acestep_cover",
+                audAssetId: created.value.artifactId,
+                sourceAssetId,
+                sourceFilename: sourceFile.name,
+                targetDurationMs,
+                direction,
+                bookId: book_id,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            audio_asset_id: created.value.artifactId,
+                            source_asset_id: sourceAssetId,
+                            source_kind: sourceKind,
+                            duration_seconds: targetDurationMs / 1000,
+                            job_id: jobId,
+                            status: "enqueued",
+                        }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/mark-asset-seen.js

@@ -0,0 +1,23 @@
+import { z } from "zod";
+export function markAssetSeenDef(engine) {
+    return {
+        name: "mark_asset_seen",
+        description: "Mark an asset as seen so the sidebar's NEW badge clears. Idempotent: re-marking an already-seen asset is a no-op.",
+        schema: {
+            asset_id: z.string().describe("Asset ID to mark seen (e.g. img-cute-cat)"),
+            book_id: z.string().describe("Book id"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id } = args;
+            const updated = await engine.jobs.artifactWork.markSeen(book_id);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({ asset_id, updated }),
+                    },
+                ],
+            };
+        },
+    };
+}