vidspotai-shared 1.0.82-dev.0 → 1.0.83

package/lib/services/agent/tools/generateScript.tool.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateScriptTool = void 0;
+exports.generateScriptCore = generateScriptCore;
+const zod_1 = require("zod");
+const brief_schema_1 = require("../../../schemas/brief.schema");
+const videoPlan_schema_1 = require("../../../schemas/videoPlan.schema");
+const llmCallerRegistry_1 = require("../llmCallerRegistry");
+const modelRouter_1 = require("../modelRouter");
+const ttsDuration_1 = require("../ttsDuration");
+const toolRegistry_1 = require("../toolRegistry");
+/**
+ * Stream L (L-4) — generate_script. Script-first authoring for long-form (L1+):
+ * the FIRST pass of L-3's two-pass flow. Produces the full spoken narration for
+ * the whole video as ONE coherent piece of writing, before any scenes exist.
+ *
+ * Why script-first: long-form (3-60min) authored scene-by-scene drifts — each
+ * scene's voiceoverLine is written in isolation and the through-line is lost.
+ * Writing the whole narration first keeps argument flow, callbacks, and pacing
+ * coherent; chapter_outline then segments it (L-4) and match_broll_to_script
+ * explodes each segment into scenes (L-4) whose voiceoverLines are slices of
+ * THIS text.
+ *
+ * The LLM returns prose only; word count + duration estimate are computed
+ * deterministically (estimateTtsMs) rather than trusted from the model, mirror-
+ * ing how the planner stamps credit estimates rather than believing the LLM.
+ */
+const InputSchema = zod_1.z.object({
+    brief: brief_schema_1.VideoBriefSchema.describe("Structured brief. durationSec drives the target word count; tone / audience / niche steer the writing."),
+    /**
+     * Override the words-per-minute used to size the script against durationSec.
+     * Defaults to the TTS calibration (150 wpm). Lower for slow/contemplative
+     * narration, higher for energetic delivery.
+     */
+    wpm: zod_1.z.number().int().positive().optional(),
+});
+/** What we ask the LLM for — prose + an optional working title only. */
+const LlmScriptSchema = zod_1.z.object({
+    fullText: zod_1.z
+        .string()
+        .describe("The complete spoken narration for the entire video, as flowing prose with normal sentence punctuation. No scene markers, no '[VISUAL]' directions, no headings — just what the narrator says, start to finish."),
+    suggestedTitle: zod_1.z
+        .string()
+        .optional()
+        .describe("A working title for the video (used for chapter UI / file naming)."),
+});
+const OutputSchema = zod_1.z.object({
+    script: videoPlan_schema_1.ScriptSchema,
+    suggestedTitle: zod_1.z.string().optional(),
+});
+/**
+ * Pure core, shared by the tool handler and the script-first planner (L-3).
+ * Takes an explicit LlmCaller so the planner can pass its own injected caller
+ * rather than relying on the global registry. Returns the script + title.
+ */
+async function generateScriptCore(llm, brief, wpmOverride) {
+    const router = new modelRouter_1.ModelRouter();
+    const wpm = wpmOverride ?? ttsDuration_1.TTS_DEFAULT_WPM;
+    // Target word count from requested duration at the chosen wpm. Gives the
+    // model a concrete length budget so it doesn't under/over-write.
+    const durationSec = brief.durationSec ?? 300;
+    const targetWords = Math.max(80, Math.round((durationSec / 60) * wpm));
+    const system = [
+        "You are a senior long-form video scriptwriter (YouTube essays, explainers,",
+        "documentaries). Write spoken narration that one narrator reads start to",
+        "finish: a strong hook, a clear through-line, signposted transitions between",
+        "ideas, and a payoff/CTA at the end. Use natural spoken rhythm and normal",
+        "punctuation. Do NOT write scene directions, shot lists, headings, or",
+        "bracketed visual notes — ONLY the words spoken aloud.",
+    ].join(" ");
+    const user = [
+        `Topic / request: ${brief.rawPrompt}`,
+        brief.goal ? `Goal: ${brief.goal}` : "",
+        brief.audience ? `Audience: ${brief.audience}` : "",
+        brief.tone ? `Tone: ${brief.tone}` : "",
+        brief.niche ? `Niche: ${brief.niche}` : "",
+        brief.cta ? `Call to action to land at the end: ${brief.cta}` : "",
+        `Target length: ~${durationSec}s of speech ≈ ${targetWords} words at ${wpm} wpm. Stay within ±15% of that word count.`,
+        brief.claims?.block?.length
+            ? `NEVER use these phrases (compliance): ${brief.claims.block.join("; ")}.`
+            : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+    const res = await llm.structured({
+        model: router.pickFor("planner", { premium: brief.tierBudget === "T3" }),
+        fallbackModel: router.fallbackFor("planner"),
+        schema: LlmScriptSchema,
+        schemaName: "Script",
+        messages: [
+            { role: "system", content: system },
+            { role: "user", content: user },
+        ],
+        temperature: 0.7,
+        maxTokens: 8000,
+    });
+    const fullText = res.data.fullText.trim();
+    const wordCount = fullText.split(/\s+/).filter(Boolean).length;
+    return {
+        script: {
+            fullText,
+            wordCount,
+            estimatedDurationMs: (0, ttsDuration_1.estimateTtsMs)(fullText, wpm),
+            wpm,
+        },
+        suggestedTitle: res.data.suggestedTitle,
+    };
+}
+exports.generateScriptTool = {
+    name: "generate_script",
+    description: [
+        "Write the full spoken narration for a long-form (L1+) video as one coherent",
+        "script BEFORE planning scenes. First pass of script-first authoring: the",
+        "output feeds chapter_outline (to segment) then match_broll_to_script (to",
+        "explode each segment into scenes). Only for M1+/L1+ tiers — short-form",
+        "(S1/S2) stays scene-first via plan_video.",
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: false,
+    handler: async (input) => generateScriptCore((0, llmCallerRegistry_1.getLlmCaller)(), input.brief, input.wpm),
+};
+(0, toolRegistry_1.registerTool)(exports.generateScriptTool);

package/lib/services/agent/tools/generateVideo.tool.d.ts

@@ -16,6 +16,7 @@ declare const InputSchema: z.ZodObject<{
         "4k": "4k";
     }>>;
     inputImageUrl: z.ZodOptional<z.ZodString>;
+    lastFrameImageUrl: z.ZodOptional<z.ZodString>;
     audio: z.ZodOptional<z.ZodBoolean>;
     negativePrompt: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;

package/lib/services/agent/tools/generateVideo.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generateVideo.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/generateVideo.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAI5D,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AA4B/D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;iBA+Bf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;iBAOhB,CAAC;AAEH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAC5C,OAAO,WAAW,EAClB,OAAO,YAAY,CA0GpB,CAAC"}
+{"version":3,"file":"generateVideo.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/generateVideo.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAI5D,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AA4B/D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;iBA4Cf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;iBAOhB,CAAC;AAEH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAC5C,OAAO,WAAW,EAClB,OAAO,YAAY,CAqHpB,CAAC"}

package/lib/services/agent/tools/generateVideo.tool.js

@@ -42,6 +42,17 @@ const InputSchema = zod_1.z.object({
         .url()
         .optional()
         .describe("Source image for image-to-video. If set, this is an animate_image-style call."),
+    lastFrameImageUrl: zod_1.z
+        .string()
+        .url()
+        .optional()
+        .describe("AG-1: last/end frame for first-last-frame (FLF) interpolation — the model " +
+        "animates FROM inputImageUrl (first frame) TO this image (last frame), the " +
+        "cleanest way to get reliable directed motion between two specific " +
+        "compositions. REQUIRES inputImageUrl (the first frame). Only " +
+        "FLF-capable models accept it (google-veo-3.1/-fast, kling, runway-gen4-turbo, " +
+        "alibaba-wan); the capability gate skips models that don't, and the chain " +
+        "falls back. Omit for normal single-image animation."),
     audio: zod_1.z.boolean().optional().describe("Whether the model should generate audio."),
     negativePrompt: zod_1.z.string().optional(),
 });
@@ -78,6 +89,13 @@ exports.generateVideoTool = {
     },
     handler: async (input) => {
         const isI2V = Boolean(input.inputImageUrl);
+        // AG-1: FLF needs a first frame to interpolate FROM. A last frame without an
+        // inputImageUrl is meaningless, so ignore it (and warn) rather than passing
+        // it to a text-to-video chain that would dead-end on the capability gate.
+        if (input.lastFrameImageUrl && !isI2V) {
+            logger_1.logger.warn("generate_video: lastFrameImageUrl ignored — no inputImageUrl (first frame) supplied", { modelKey: input.modelKey });
+        }
+        const lastFrameImageUrl = isI2V ? input.lastFrameImageUrl : undefined;
         const chain = (0, chains_1.buildVideoChain)(input.modelKey, pickChain(input.modelKey, isI2V));
         const outcome = await (0, withFallback_1.withProviderFallback)({
             providers: chain,
@@ -85,7 +103,7 @@ exports.generateVideoTool = {
                 aspect: input.aspectRatio,
                 durationSec: input.durationSec,
                 type: isI2V ? "image-to-video" : "text-to-video",
-                lastFrame: false,
+                lastFrame: Boolean(lastFrameImageUrl),
                 audio: input.audio,
                 hasInputImage: isI2V,
             }),
@@ -118,6 +136,7 @@ exports.generateVideoTool = {
                         aspectRatio: input.aspectRatio,
                         resolution: input.resolution,
                         inputImageUrl: input.inputImageUrl,
+                        lastFrameImageUrl,
                         audio: input.audio,
                         negativePrompt: input.negativePrompt,
                         type: isI2V ? "image-to-video" : "text-to-video",

package/lib/services/agent/tools/index.d.ts

@@ -5,12 +5,16 @@
 export * from "./searchStock.tool";
 export * from "./generateImage.tool";
 export * from "./generateVideo.tool";
+export * from "./extendVideo.tool";
 export * from "./generateVoiceover.tool";
 export * from "./generateCaptions.tool";
 export * from "./animateImage.tool";
 export * from "./animateImageWithMotionBrush.tool";
 export * from "./generateAvatarVideo.tool";
 export * from "./planVideo.tool";
+export * from "./generateScript.tool";
+export * from "./chapterOutline.tool";
+export * from "./matchBrollToScript.tool";
 export * from "./composeScene.tool";
 export * from "./render.tool";
 export * from "./analyzeReference.tool";

package/lib/services/agent/tools/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/lib/services/agent/tools/index.js

@@ -21,12 +21,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./searchStock.tool"), exports);
 __exportStar(require("./generateImage.tool"), exports);
 __exportStar(require("./generateVideo.tool"), exports);
+__exportStar(require("./extendVideo.tool"), exports);
 __exportStar(require("./generateVoiceover.tool"), exports);
 __exportStar(require("./generateCaptions.tool"), exports);
 __exportStar(require("./animateImage.tool"), exports);
 __exportStar(require("./animateImageWithMotionBrush.tool"), exports);
 __exportStar(require("./generateAvatarVideo.tool"), exports);
 __exportStar(require("./planVideo.tool"), exports);
+__exportStar(require("./generateScript.tool"), exports);
+__exportStar(require("./chapterOutline.tool"), exports);
+__exportStar(require("./matchBrollToScript.tool"), exports);
 __exportStar(require("./composeScene.tool"), exports);
 __exportStar(require("./render.tool"), exports);
 __exportStar(require("./analyzeReference.tool"), exports);

package/lib/services/agent/tools/matchBrollToScript.tool.d.ts

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { Aspect } from "../../../schemas/project.schema";
+import { LlmCaller } from "../llmCaller";
+import { ToolDefinition } from "../toolRegistry";
+declare const InputSchema: z.ZodObject<{
+    narration: z.ZodString;
+    aspect: z.ZodEnum<{
+        "9:16": "9:16";
+        "1:1": "1:1";
+        "4:5": "4:5";
+        "16:9": "16:9";
+    }>;
+    niche: z.ZodOptional<z.ZodString>;
+    startSceneIndex: z.ZodDefault<z.ZodNumber>;
+    wpm: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const BrollSceneSchema: z.ZodObject<{
+    sceneIndex: z.ZodNumber;
+    intent: z.ZodString;
+    prompt: z.ZodString;
+    voiceoverLine: z.ZodString;
+    strategy: z.ZodLiteral<"ai-image-to-video">;
+    durationMs: z.ZodNumber;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    scenes: z.ZodArray<z.ZodObject<{
+        sceneIndex: z.ZodNumber;
+        intent: z.ZodString;
+        prompt: z.ZodString;
+        voiceoverLine: z.ZodString;
+        strategy: z.ZodLiteral<"ai-image-to-video">;
+        durationMs: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type BrollScene = z.infer<typeof BrollSceneSchema>;
+/**
+ * Pure core, shared by the tool handler and the script-first planner (L-3).
+ */
+export declare function matchBrollToScriptCore(llm: LlmCaller, args: {
+    narration: string;
+    aspect: Aspect;
+    niche?: string;
+    startSceneIndex: number;
+    wpm?: number;
+}): Promise<{
+    scenes: BrollScene[];
+}>;
+export declare const matchBrollToScriptTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=matchBrollToScript.tool.d.ts.map

package/lib/services/agent/tools/matchBrollToScript.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matchBrollToScript.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/matchBrollToScript.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,MAAM,EAAgB,MAAM,iCAAiC,CAAC;AACvE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAIzC,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAkB/D,QAAA,MAAM,WAAW;;;;;;;;;;;iBAef,CAAC;AAyBH,QAAA,MAAM,gBAAgB;;;;;;;iBASpB,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;iBAEhB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAE1D;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,SAAS,EACd,IAAI,EAAE;IACJ,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,MAAM,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GACA,OAAO,CAAC;IAAE,MAAM,EAAE,UAAU,EAAE,CAAA;CAAE,CAAC,CAmDnC;AAED,eAAO,MAAM,sBAAsB,EAAE,cAAc,CACjD,OAAO,WAAW,EAClB,OAAO,YAAY,CAoBpB,CAAC"}

package/lib/services/agent/tools/matchBrollToScript.tool.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchBrollToScriptTool = void 0;
+exports.matchBrollToScriptCore = matchBrollToScriptCore;
+const zod_1 = require("zod");
+const project_schema_1 = require("../../../schemas/project.schema");
+const llmCallerRegistry_1 = require("../llmCallerRegistry");
+const modelRouter_1 = require("../modelRouter");
+const ttsDuration_1 = require("../ttsDuration");
+const toolRegistry_1 = require("../toolRegistry");
+/**
+ * Stream L (L-4) — match_broll_to_script. Third pass of script-first authoring:
+ * explodes ONE chapter's narration into a sequence of B-roll scenes. Each scene
+ * pairs a VERBATIM sentence-boundary slice of the narration (the voiceoverLine)
+ * with a concrete B-roll visual prompt that illustrates it. Run once per chapter
+ * (from chapter_outline); the orchestrator (L-3) concatenates the per-chapter
+ * scene lists into the plan and back-fills chapter.sceneIndices.
+ *
+ * Durations are computed deterministically from the voiceoverLine's TTS length
+ * (estimateTtsMs) clamped to the long-form 3-8s band — the model only writes
+ * the visual prompt + chooses the sentence grouping, it does NOT set durations.
+ */
+const LONGFORM_MIN_MS = 3000;
+const LONGFORM_MAX_MS = 8000;
+const InputSchema = zod_1.z.object({
+    narration: zod_1.z
+        .string()
+        .min(1)
+        .describe("A single chapter's narration text (verbatim slice of the script)."),
+    aspect: project_schema_1.AspectSchema.describe("Target aspect ratio — steers the visual prompts."),
+    niche: zod_1.z.string().optional().describe("Brief niche, for visual style steering."),
+    /**
+     * sceneIndex to assign to the FIRST scene of this chapter; subsequent scenes
+     * increment from here. Lets the orchestrator keep indices globally unique and
+     * contiguous across chapters.
+     */
+    startSceneIndex: zod_1.z.number().int().nonnegative().default(0),
+    /** wpm for duration estimates; defaults to TTS calibration. */
+    wpm: zod_1.z.number().int().positive().optional(),
+});
+/** The model groups sentences + writes visuals; we stamp index + duration. */
+const LlmBrollSchema = zod_1.z.object({
+    scenes: zod_1.z
+        .array(zod_1.z.object({
+        voiceoverLine: zod_1.z
+            .string()
+            .describe("One or a few consecutive sentences from the narration, VERBATIM. Concatenating all scenes' voiceoverLines in order must reproduce the chapter narration exactly."),
+        intent: zod_1.z
+            .string()
+            .describe("One-line plain-English description of what this scene shows."),
+        prompt: zod_1.z
+            .string()
+            .describe("A concrete B-roll visual prompt that illustrates the voiceoverLine — subject, setting, lighting, camera. Describe the VISUAL, not the words."),
+    }))
+        .min(1),
+});
+const BrollSceneSchema = zod_1.z.object({
+    sceneIndex: zod_1.z.number().int().nonnegative(),
+    intent: zod_1.z.string(),
+    prompt: zod_1.z.string(),
+    voiceoverLine: zod_1.z.string(),
+    /** Strategy hint — long-form B-roll defaults to ai-image-to-video. */
+    strategy: zod_1.z.literal("ai-image-to-video"),
+    /** TTS-derived duration, clamped to the long-form 3-8s band. */
+    durationMs: zod_1.z.number().int().positive(),
+});
+const OutputSchema = zod_1.z.object({
+    scenes: zod_1.z.array(BrollSceneSchema),
+});
+/**
+ * Pure core, shared by the tool handler and the script-first planner (L-3).
+ */
+async function matchBrollToScriptCore(llm, args) {
+    const router = new modelRouter_1.ModelRouter();
+    const wpm = args.wpm ?? ttsDuration_1.TTS_DEFAULT_WPM;
+    const system = [
+        "You are a video editor matching B-roll to narration. Split the chapter",
+        "narration into a sequence of short scenes. For each scene: (1) copy one or",
+        "a few CONSECUTIVE sentences VERBATIM as the voiceoverLine — together they",
+        "must reproduce the whole chapter narration with nothing added or dropped;",
+        "(2) write a concrete B-roll visual prompt illustrating that line. Prefer",
+        "one scene per sentence or two; aim for ~3-8s of speech per scene. Visuals",
+        "should vary shot-to-shot (don't repeat the same composition).",
+    ].join(" ");
+    const user = [
+        `Target aspect: ${args.aspect}.`,
+        args.niche ? `Niche: ${args.niche}.` : "",
+        "",
+        "CHAPTER NARRATION:",
+        args.narration,
+    ]
+        .filter(Boolean)
+        .join("\n");
+    const res = await llm.structured({
+        model: router.pickFor("planner"),
+        fallbackModel: router.fallbackFor("planner"),
+        schema: LlmBrollSchema,
+        schemaName: "BrollScenes",
+        messages: [
+            { role: "system", content: system },
+            { role: "user", content: user },
+        ],
+        temperature: 0.6,
+        maxTokens: 8000,
+    });
+    const scenes = res.data.scenes.map((s, i) => {
+        const raw = (0, ttsDuration_1.estimateTtsMs)(s.voiceoverLine, wpm);
+        const durationMs = Math.min(LONGFORM_MAX_MS, Math.max(LONGFORM_MIN_MS, raw));
+        return {
+            sceneIndex: args.startSceneIndex + i,
+            intent: s.intent,
+            prompt: s.prompt,
+            voiceoverLine: s.voiceoverLine.trim(),
+            strategy: "ai-image-to-video",
+            durationMs,
+        };
+    });
+    return { scenes };
+}
+exports.matchBrollToScriptTool = {
+    name: "match_broll_to_script",
+    description: [
+        "Explode one chapter's narration into B-roll scenes: each scene = a verbatim",
+        "sentence slice (voiceoverLine) + a visual prompt. Third pass of script-first",
+        "authoring, run once per chapter from chapter_outline. Durations are computed",
+        "from TTS length (3-8s band), not chosen by the model.",
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: false,
+    handler: async (input) => matchBrollToScriptCore((0, llmCallerRegistry_1.getLlmCaller)(), {
+        narration: input.narration,
+        aspect: input.aspect,
+        niche: input.niche,
+        startSceneIndex: input.startSceneIndex,
+        wpm: input.wpm,
+    }),
+};
+(0, toolRegistry_1.registerTool)(exports.matchBrollToScriptTool);

package/lib/services/agent/tools/planVideo.tool.d.ts

@@ -55,6 +55,14 @@ declare const InputSchema: z.ZodObject<{
             "4:5": "4:5";
             "16:9": "16:9";
         }>>;
+        lengthTier: z.ZodOptional<z.ZodEnum<{
+            S1: "S1";
+            S2: "S2";
+            M1: "M1";
+            L1: "L1";
+            L2: "L2";
+            L3: "L3";
+        }>>;
         voice: z.ZodOptional<z.ZodObject<{
             gender: z.ZodOptional<z.ZodEnum<{
                 male: "male";
@@ -114,12 +122,14 @@ declare const InputSchema: z.ZodObject<{
                 transcriptExcerpt: z.ZodOptional<z.ZodString>;
             }, z.core.$strip>>;
         }, z.core.$strip>>>;
+        preferredModelKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
         tierBudget: z.ZodDefault<z.ZodEnum<{
             T0: "T0";
             T1: "T1";
             T2: "T2";
             T3: "T3";
         }>>;
+        maxSpendUSD: z.ZodOptional<z.ZodNumber>;
         videoStrategy: z.ZodOptional<z.ZodEnum<{
             auto: "auto";
             direct: "direct";
@@ -151,6 +161,14 @@ declare const OutputSchema: z.ZodObject<{
         }>;
         totalDurationMs: z.ZodNumber;
         totalEstimatedCredits: z.ZodNumber;
+        lengthTier: z.ZodOptional<z.ZodEnum<{
+            S1: "S1";
+            S2: "S2";
+            M1: "M1";
+            L1: "L1";
+            L2: "L2";
+            L3: "L3";
+        }>>;
         scenes: z.ZodArray<z.ZodObject<{
             sceneIndex: z.ZodNumber;
             intent: z.ZodString;
@@ -175,7 +193,15 @@ declare const OutputSchema: z.ZodObject<{
             prompt: z.ZodString;
             durationMs: z.ZodNumber;
             voiceoverLine: z.ZodOptional<z.ZodString>;
+            autoCaptions: z.ZodOptional<z.ZodBoolean>;
             voiceStyle: z.ZodOptional<z.ZodString>;
+            captionStyle: z.ZodOptional<z.ZodObject<{
+                fontFamily: z.ZodOptional<z.ZodString>;
+                fontSize: z.ZodOptional<z.ZodNumber>;
+                fontWeight: z.ZodOptional<z.ZodNumber>;
+                color: z.ZodOptional<z.ZodString>;
+                highlightColor: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
             onScreenText: z.ZodOptional<z.ZodString>;
             overlays: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 text: z.ZodString;
@@ -209,8 +235,8 @@ declare const OutputSchema: z.ZodObject<{
                 fontSize: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"auto">, z.ZodNumber]>>;
                 sizePct: z.ZodOptional<z.ZodNumber>;
                 weight: z.ZodOptional<z.ZodEnum<{
-                    bold: "bold";
                     regular: "regular";
+                    bold: "bold";
                     black: "black";
                     medium: "medium";
                 }>>;
@@ -250,6 +276,7 @@ declare const OutputSchema: z.ZodObject<{
             avatarFaceUrl: z.ZodOptional<z.ZodString>;
             characterAnchorSceneIndex: z.ZodOptional<z.ZodNumber>;
             bibleEntityIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            lastFramePrompt: z.ZodOptional<z.ZodString>;
             allowTrailingSilence: z.ZodOptional<z.ZodBoolean>;
             layout: z.ZodOptional<z.ZodObject<{
                 composition: z.ZodEnum<{
@@ -273,6 +300,28 @@ declare const OutputSchema: z.ZodObject<{
                     gradient: "gradient";
                 }>>;
             }, z.core.$strip>>;
+            broll: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                assetUrl: z.ZodString;
+                kind: z.ZodDefault<z.ZodEnum<{
+                    image: "image";
+                    video: "video";
+                }>>;
+                startMs: z.ZodDefault<z.ZodNumber>;
+                durationMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        chapters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            narration: z.ZodOptional<z.ZodString>;
+            estimatedDurationMs: z.ZodOptional<z.ZodNumber>;
+            sceneIndices: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>>>;
+        script: z.ZodOptional<z.ZodObject<{
+            fullText: z.ZodString;
+            wordCount: z.ZodOptional<z.ZodNumber>;
+            estimatedDurationMs: z.ZodOptional<z.ZodNumber>;
+            wpm: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
         music: z.ZodOptional<z.ZodObject<{
             strategy: z.ZodEnum<{
@@ -292,6 +341,13 @@ declare const OutputSchema: z.ZodObject<{
         voiceId: z.ZodOptional<z.ZodString>;
         voiceStyle: z.ZodOptional<z.ZodString>;
         notes: z.ZodOptional<z.ZodString>;
+        captionStyle: z.ZodOptional<z.ZodObject<{
+            fontFamily: z.ZodOptional<z.ZodString>;
+            fontSize: z.ZodOptional<z.ZodNumber>;
+            fontWeight: z.ZodOptional<z.ZodNumber>;
+            color: z.ZodOptional<z.ZodString>;
+            highlightColor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
         bible: z.ZodOptional<z.ZodObject<{
             characters: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;

package/lib/services/agent/tools/planVideo.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"planVideo.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/planVideo.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAQ/D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAExD;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEhB,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,cAAc,CACxC,OAAO,WAAW,EAClB,OAAO,YAAY,CAuBpB,CAAC"}
+{"version":3,"file":"planVideo.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/planVideo.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAQ/D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAExD;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEhB,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,cAAc,CACxC,OAAO,WAAW,EAClB,OAAO,YAAY,CAuBpB,CAAC"}

package/lib/services/agent/tools/planVideo.tool.js

@@ -8,9 +8,9 @@ const videoPlan_schema_1 = require("../../../schemas/videoPlan.schema");
 const planner_1 = require("../planner");
 const toolRegistry_1 = require("../toolRegistry");
 /**
- * The Planner needs an LlmCaller, which is host-wired (Vercel AI Gateway /
- * OpenRouter). The tool layer is host-agnostic, so we expose a setter that
- * the host calls once at boot. Until set, the tool errors loudly.
+ * The Planner needs an LlmCaller, which is host-wired (the native
+ * ProviderRoutingLlmCaller). The tool layer is host-agnostic, so we expose a
+ * setter that the host calls once at boot. Until set, the tool errors loudly.
  */
 let injectedLlm = null;
 function setPlannerLlmCaller(llm) {

package/lib/services/agent/tools/render.tool.d.ts

@@ -44,9 +44,9 @@ declare const InputSchema: z.ZodObject<{
         tracks: z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             kind: z.ZodEnum<{
-                text: "text";
                 audio: "audio";
                 video: "video";
+                text: "text";
                 caption: "caption";
                 fx: "fx";
             }>;
@@ -98,6 +98,10 @@ declare const InputSchema: z.ZodObject<{
                 assetHash: z.ZodOptional<z.ZodString>;
                 creditsSpent: z.ZodOptional<z.ZodNumber>;
                 generationId: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>;
             effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -154,6 +158,10 @@ declare const InputSchema: z.ZodObject<{
                 assetHash: z.ZodOptional<z.ZodString>;
                 creditsSpent: z.ZodOptional<z.ZodNumber>;
                 generationId: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>;
             effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -202,6 +210,10 @@ declare const InputSchema: z.ZodObject<{
                 assetHash: z.ZodOptional<z.ZodString>;
                 creditsSpent: z.ZodOptional<z.ZodNumber>;
                 generationId: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>;
             effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -253,6 +265,10 @@ declare const InputSchema: z.ZodObject<{
                 assetHash: z.ZodOptional<z.ZodString>;
                 creditsSpent: z.ZodOptional<z.ZodNumber>;
                 generationId: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>;
             effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;
@@ -280,6 +296,7 @@ declare const InputSchema: z.ZodObject<{
             }, z.core.$strip>>>;
             fontFamily: z.ZodDefault<z.ZodString>;
             fontSize: z.ZodDefault<z.ZodNumber>;
+            fontWeight: z.ZodOptional<z.ZodNumber>;
             color: z.ZodDefault<z.ZodString>;
             highlightColor: z.ZodOptional<z.ZodString>;
             language: z.ZodDefault<z.ZodString>;
@@ -303,6 +320,10 @@ declare const InputSchema: z.ZodObject<{
                 assetHash: z.ZodOptional<z.ZodString>;
                 creditsSpent: z.ZodOptional<z.ZodNumber>;
                 generationId: z.ZodOptional<z.ZodString>;
+                attribution: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    url: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
             }, z.core.$strip>>;
             effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
                 id: z.ZodString;

package/lib/services/agent/tools/render.tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"render.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/render.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IACvC,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;CAC3C,KAAK,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAGvC,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,CAE5D;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQf,CAAC;AAEH,QAAA,MAAM,YAAY;;;iBAGhB,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,cAAc,CACrC,OAAO,WAAW,EAClB,OAAO,YAAY,CA2BpB,CAAC"}
+{"version":3,"file":"render.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/render.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IACvC,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;CAC3C,KAAK,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAGvC,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,CAE5D;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQf,CAAC;AAEH,QAAA,MAAM,YAAY;;;iBAGhB,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,cAAc,CACrC,OAAO,WAAW,EAClB,OAAO,YAAY,CA2BpB,CAAC"}

package/lib/services/aiGen/aiGenFactory.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aiGenFactory.service.d.ts","sourceRoot":"","sources":["../../../src/services/aiGen/aiGenFactory.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EACL,iBAAiB,EAEjB,eAAe,EACf,aAAa,EACb,cAAc,EACd,eAAe,EACf,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAahC,KAAK,uBAAuB,GAAG,UAAU,wBAAwB,CAAC;AAElE,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,eAAe,EACf,uBAAuB,CA+DxB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,iBAAiB,EACjB,uBAAuB,CA2CxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,eAAe,EACf,uBAAuB,CAMxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,aAAa,EACb,uBAAuB,CAGxB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,uBAAuB,CAQzE,CAAC;AAEJ,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,WAAW,GACpB,wBAAwB,CAkB1B"}
+{"version":3,"file":"aiGenFactory.service.d.ts","sourceRoot":"","sources":["../../../src/services/aiGen/aiGenFactory.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EACL,iBAAiB,EAEjB,eAAe,EACf,aAAa,EACb,cAAc,EACd,eAAe,EACf,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAchC,KAAK,uBAAuB,GAAG,UAAU,wBAAwB,CAAC;AAElE,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,eAAe,EACf,uBAAuB,CA+DxB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,iBAAiB,EACjB,uBAAuB,CA2CxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,eAAe,EACf,uBAAuB,CAMxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,aAAa,EACb,uBAAuB,CAGxB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,uBAAuB,CAsBzE,CAAC;AAEJ,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,WAAW,GACpB,wBAAwB,CAkB1B"}