videobook 0.0.0-stage → 0.2.0

package/dist/tools/chain.js

@@ -0,0 +1,136 @@
+import { z } from "zod";
+import { chainStepSchema, } from "../chain-plan.js";
+import { approveChainStep, cancelChainRun, getChainRun, preflightAndAccept, } from "../chain-executor.js";
+import { AUTO_APPLY_TOOL_NAMES, effectForTool } from "../chat-router.js";
+function json(value) {
+    return { content: [{ type: "text", text: JSON.stringify(value) }] };
+}
+function error(text) {
+    return { isError: true, content: [{ type: "text", text }] };
+}
+function toolEffect(name) {
+    return effectForTool(name, /^(?:generate|extend|upscale)_/u.test(name) ? "generation" : "action");
+}
+async function preflightContext(engine, bookId, notebookId) {
+    const { getAllToolDefs } = await import("./index.js");
+    const defs = getAllToolDefs(engine);
+    return {
+        engine,
+        bookId,
+        notebookId,
+        toolSchemas: new Map(defs.map((definition) => [definition.name, definition.schema])),
+        autoApplyTools: AUTO_APPLY_TOOL_NAMES,
+        effectForTool: toolEffect,
+    };
+}
+async function toolLookup(engine) {
+    const { getAllToolDefs } = await import("./index.js");
+    const defs = getAllToolDefs(engine);
+    return (name) => defs.find((definition) => definition.name === name);
+}
+function publicRun(run) {
+    return {
+        kind: "chain-run",
+        chain_id: run.chainId,
+        request_id: run.requestId,
+        status: run.status,
+        error: run.error,
+        awaiting_step_id: run.awaitingStepId,
+        steps: run.steps.map((step) => ({
+            id: step.id,
+            tool: step.tool,
+            status: step.status,
+            outputs: step.outputs,
+            error: step.error,
+            child_job_ids: step.childJobIds,
+            requires_approval: step.requiresApproval,
+            approved_at: step.approval?.approvedAt ?? null,
+            review: step.review,
+        })),
+    };
+}
+export function chainDef(engine) {
+    return {
+        name: "chain",
+        description: "Run several existing book actions in order, passing earlier outputs to later steps with {$ref:{step_id,output}}. Steps are {id, tool, params}; ids are unique and start with a letter. Paid steps pause for review. action: run, status, cancel, or approve with chain_id and step_id to let a paused step continue.",
+        scope: "book",
+        schema: {
+            action: z.enum(["run", "status", "cancel", "approve"]).default("run"),
+            version: z.literal(1).optional(),
+            book_id: z.string().uuid().describe("Book UUID"),
+            notebook_id: z.string().uuid().optional()
+                .describe("Active notebook UUID for resolving @a1-@bl8 targets"),
+            request_id: z.string().min(1).optional()
+                .describe("Idempotency key for a run"),
+            chain_id: z.string().uuid().optional()
+                .describe("Existing chain id for status or cancel"),
+            steps: z.array(chainStepSchema).optional()
+                .describe("Ordered steps for action=run"),
+            step_id: z.string().min(1).max(64).optional()
+                .describe("Step waiting for approval, required for action=approve"),
+            actor: z.enum(["chat", "voice", "api"]).optional()
+                .describe("Which surface approved the step"),
+        },
+        handler: async (args) => {
+            const action = args.action
+                ?? "run";
+            const bookId = args.book_id;
+            const notebookId = args.notebook_id;
+            const lookup = await toolLookup(engine);
+            if (action === "status") {
+                const chainId = args.chain_id;
+                if (typeof chainId !== "string")
+                    return error("chain_id is required");
+                const run = getChainRun(engine, chainId);
+                if (!run || run.bookId !== bookId)
+                    return error("Chain run not found");
+                return json(publicRun(run));
+            }
+            if (action === "approve") {
+                const chainId = args.chain_id;
+                const stepId = args.step_id;
+                if (typeof chainId !== "string")
+                    return error("chain_id is required");
+                if (typeof stepId !== "string")
+                    return error("step_id is required");
+                const existing = getChainRun(engine, chainId);
+                if (!existing || existing.bookId !== bookId)
+                    return error("Chain run not found");
+                try {
+                    const actor = args.actor ?? "api";
+                    const run = approveChainStep(engine, chainId, stepId, actor, lookup);
+                    return run ? json(publicRun(run)) : error("Chain run not found");
+                }
+                catch (cause) {
+                    return error(cause instanceof Error ? cause.message : String(cause));
+                }
+            }
+            if (action === "cancel") {
+                const chainId = args.chain_id;
+                if (typeof chainId !== "string")
+                    return error("chain_id is required");
+                const existing = getChainRun(engine, chainId);
+                if (!existing || existing.bookId !== bookId)
+                    return error("Chain run not found");
+                const run = cancelChainRun(engine, chainId);
+                return run ? json(publicRun(run)) : error("Chain run not found");
+            }
+            try {
+                const context = await preflightContext(engine, bookId, notebookId);
+                const run = await preflightAndAccept({
+                    action: "run",
+                    version: args.version ?? 1,
+                    book_id: bookId,
+                    notebook_id: notebookId,
+                    request_id: args.request_id,
+                    steps: args.steps,
+                }, context, lookup);
+                return json(publicRun(run));
+            }
+            catch (cause) {
+                const message = cause instanceof Error ? cause.message : String(cause);
+                return error(message);
+            }
+        },
+    };
+}

package/dist/tools/change-video-speed.js

@@ -0,0 +1,105 @@
+import { z } from "zod";
+import { join } from "node:path";
+import { queue } from "../queue.js";
+import { probeVideo } from "../ffmpeg.js";
+import { findVideoFile } from "videobook-engine";
+const SPEED_MIN = 0.25;
+const SPEED_MAX = 4.0;
+function validateSpeed(speed) {
+    if (speed === 1.0)
+        return "Speed 1.0 is a no-op — nothing to change";
+    if (speed < SPEED_MIN || speed > SPEED_MAX)
+        return `Speed must be between ${SPEED_MIN} and ${SPEED_MAX}, got ${speed}`;
+    return null;
+}
+export function changeVideoSpeedDef(engine) {
+    return {
+        name: "change_video_speed",
+        description: "Change video playback speed (speed up or slow down). Operates in-place with git versioning.",
+        schema: {
+            asset_id: z.string().describe("Asset ID (e.g. vid-my-video)"),
+            book_id: z.string().describe("Book id"),
+            speed: z.number().optional().describe("Speed multiplier (0.25–4.0). >1 = faster, <1 = slower."),
+            target_duration_seconds: z.number().optional().describe("Exact target output duration in seconds"),
+        },
+        handler: async (args) => {
+            const { asset_id, book_id, speed: requestedSpeed, target_duration_seconds } = args;
+            if ((requestedSpeed === undefined && target_duration_seconds === undefined) || (requestedSpeed !== undefined && target_duration_seconds !== undefined)) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: "Must provide exactly one of speed or target_duration_seconds" }],
+                };
+            }
+            if (target_duration_seconds !== undefined && (target_duration_seconds <= 0 || !Number.isFinite(target_duration_seconds))) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Target duration must be a positive finite number, got ${target_duration_seconds}` }],
+                };
+            }
+            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 assetDir = manifest.path;
+            const videoPath = join(assetDir, videoFile.name);
+            const probe = await probeVideo(videoPath);
+            const { hasAudio } = probe;
+            // Exact-duration mode derives the multiplier from the video stream, not
+            // the container: format duration follows the longest stream, so a
+            // longer audio track would under-speed the video and leave it short of
+            // the target (and the duration cap would clip a longer video stream's
+            // tail).
+            const duration = probe.videoDuration;
+            let speed;
+            if (target_duration_seconds !== undefined) {
+                if (duration <= 0) {
+                    return {
+                        isError: true,
+                        content: [{ type: "text", text: `Failed to probe source duration for asset ${asset_id}` }],
+                    };
+                }
+                speed = duration / target_duration_seconds;
+            }
+            else {
+                speed = requestedSpeed;
+            }
+            const speedError = validateSpeed(speed);
+            if (speedError) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: speedError }],
+                };
+            }
+            const tempPath = join(assetDir, "original_speed.mp4");
+            const jobId = `speed-${asset_id}-${Date.now()}`;
+            await queue.enqueue(jobId, {
+                type: "change_video_speed",
+                inputPath: videoPath,
+                outputPath: tempPath,
+                speed,
+                targetDuration: target_duration_seconds,
+                hasAudio,
+                assetId: asset_id,
+                assetDir,
+                bookId: book_id,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({ asset_id, job_id: jobId, status: "enqueued" }),
+                    }],
+            };
+        },
+    };
+}

package/dist/tools/chat-history.js

@@ -0,0 +1,5 @@
+export async function appendVoiceHistory(engine, input) {
+    const result = await engine.logs.append("voice-chat", { ...input, ts: Date.now() });
+    if (!result.ok)
+        throw new Error(result.error.message);
+}