vidspotai-shared 1.0.53 → 1.0.55

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

@@ -0,0 +1,28 @@
+import { z } from "zod";
+import { ToolDefinition } from "../toolRegistry";
+declare const InputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    modelKey: z.ZodDefault<z.ZodEnum<{
+        "fal-flux-1.1-pro": "fal-flux-1.1-pro";
+        "fal-flux-1.1-pro-ultra": "fal-flux-1.1-pro-ultra";
+        "fal-flux-schnell": "fal-flux-schnell";
+    }>>;
+    aspectRatio: z.ZodDefault<z.ZodEnum<{
+        "9:16": "9:16";
+        "16:9": "16:9";
+        "1:1": "1:1";
+        "4:5": "4:5";
+    }>>;
+    dimensions: z.ZodOptional<z.ZodString>;
+    inputImageUrl: z.ZodOptional<z.ZodString>;
+    negativePrompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    imageUrl: z.ZodString;
+    width: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    providerRequestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const generateImageTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=generateImage.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateImage.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/generateImage.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;iBAyBf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;iBAKhB,CAAC;AAQH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAC5C,OAAO,WAAW,EAClB,OAAO,YAAY,CAwDpB,CAAC"}

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateImageTool = void 0;
+const zod_1 = require("zod");
+const falImage_service_1 = require("../../aiGen/providers/fal/falImage.service");
+const assetCache_service_1 = require("../../assetCache.service");
+const toolRegistry_1 = require("../toolRegistry");
+const InputSchema = zod_1.z.object({
+    prompt: zod_1.z
+        .string()
+        .min(1)
+        .describe("Detailed visual prompt. Lighting, lens, camera angle, mood — the more specific, the more on-brief the result."),
+    modelKey: zod_1.z
+        .enum(["fal-flux-1.1-pro", "fal-flux-1.1-pro-ultra", "fal-flux-schnell"])
+        .default("fal-flux-1.1-pro")
+        .describe("fal-flux-schnell: cheapest, ~1s. fal-flux-1.1-pro: balanced. fal-flux-1.1-pro-ultra: highest quality, slowest."),
+    aspectRatio: zod_1.z.enum(["9:16", "1:1", "4:5", "16:9"]).default("9:16"),
+    dimensions: zod_1.z
+        .string()
+        .regex(/^\d+x\d+$/)
+        .optional()
+        .describe('Explicit "WxH" override. Overrides aspectRatio.'),
+    inputImageUrl: zod_1.z
+        .string()
+        .url()
+        .optional()
+        .describe("Optional source image for image-to-image edits."),
+    negativePrompt: zod_1.z.string().optional(),
+});
+const OutputSchema = zod_1.z.object({
+    imageUrl: zod_1.z.string().url(),
+    width: zod_1.z.number().optional(),
+    height: zod_1.z.number().optional(),
+    providerRequestId: zod_1.z.string().optional(),
+});
+const COST_BY_MODEL = {
+    "fal-flux-schnell": 1,
+    "fal-flux-1.1-pro": 4,
+    "fal-flux-1.1-pro-ultra": 6,
+};
+exports.generateImageTool = {
+    name: "generate_image",
+    description: [
+        "Generate a still image from a text prompt (T1 tier — costs credits but",
+        "much cheaper than video generation). Use for scene b-roll, product shots,",
+        "or as the source frame for animate_image / animate-to-video.",
+        "Do NOT use for: stock-grade generic visuals (use search_stock — free) or",
+        "scenes that fundamentally need motion (use generate_video).",
+        "Examples:",
+        '  { prompt: "cinematic golden-hour ocean cliff, slow dolly", aspectRatio: "9:16" }',
+        '  { prompt: "minimalist white skincare bottle on marble", modelKey: "fal-flux-1.1-pro-ultra" }',
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: true,
+    estimateCost: async (input) => COST_BY_MODEL[input.modelKey] ?? 4,
+    handler: async (input, ctx) => {
+        const cacheParts = {
+            provider: `fal:${input.modelKey}`,
+            input: {
+                prompt: input.prompt,
+                aspectRatio: input.aspectRatio,
+                dimensions: input.dimensions,
+                inputImageUrl: input.inputImageUrl,
+                negativePrompt: input.negativePrompt,
+            },
+        };
+        const hit = await assetCache_service_1.AssetCacheService.lookup(cacheParts);
+        if (hit) {
+            return {
+                imageUrl: hit.url,
+                width: hit.width,
+                height: hit.height,
+            };
+        }
+        const provider = new falImage_service_1.FalImageProviderService();
+        const result = await provider.generateImage({
+            prompt: input.prompt,
+            modelKey: input.modelKey,
+            aspectRatio: input.aspectRatio,
+            dimensions: input.dimensions,
+            inputImageUrl: input.inputImageUrl,
+            negativePrompt: input.negativePrompt,
+            idempotencyKey: ctx.idempotencyKey,
+        });
+        await assetCache_service_1.AssetCacheService.store(cacheParts, {
+            provider: `fal:${input.modelKey}`,
+            kind: "image",
+            url: result.imageUrl,
+            width: result.width,
+            height: result.height,
+            originalCreditsSpent: COST_BY_MODEL[input.modelKey],
+        });
+        return result;
+    },
+};
+(0, toolRegistry_1.registerTool)(exports.generateImageTool);

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

@@ -0,0 +1,30 @@
+import { z } from "zod";
+import { EVideoGenModels } from "../../../globals/aiModels";
+import { ToolDefinition } from "../toolRegistry";
+declare const InputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    modelKey: z.ZodEnum<typeof EVideoGenModels>;
+    durationSec: z.ZodDefault<z.ZodNumber>;
+    aspectRatio: z.ZodDefault<z.ZodEnum<{
+        "9:16": "9:16";
+        "16:9": "16:9";
+        "1:1": "1:1";
+        "4:5": "4:5";
+    }>>;
+    resolution: z.ZodOptional<z.ZodEnum<{
+        "720p": "720p";
+        "1080p": "1080p";
+        "4k": "4k";
+    }>>;
+    inputImageUrl: z.ZodOptional<z.ZodString>;
+    audio: z.ZodOptional<z.ZodBoolean>;
+    negativePrompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    status: z.ZodLiteral<"triggered">;
+    taskId: z.ZodString;
+    raw: z.ZodUnknown;
+}, z.core.$strip>;
+export declare const generateVideoTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=generateVideo.tool.d.ts.map

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

@@ -0,0 +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;AAE5D,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;iBA8Bf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;iBAIhB,CAAC;AAEH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAC5C,OAAO,WAAW,EAClB,OAAO,YAAY,CAgDpB,CAAC"}

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

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVideoTool = void 0;
+const zod_1 = require("zod");
+const aiModels_1 = require("../../../globals/aiModels");
+const aiGenFactory_service_1 = require("../../aiGen/aiGenFactory.service");
+const toolRegistry_1 = require("../toolRegistry");
+const InputSchema = zod_1.z.object({
+    prompt: zod_1.z
+        .string()
+        .min(1)
+        .describe("Detailed motion + visual prompt. Describe subject, camera move, mood, lighting."),
+    modelKey: zod_1.z
+        .nativeEnum(aiModels_1.EVideoGenModels)
+        .describe("Pick by tier: T3 cinematic = google-veo-3.1, runway-gen4.5; balanced = kling-v2.6, bytedance-seedance-1.5-pro; cheap fast = minimax-hailuo-2.3-fast, pixverse-v5.6."),
+    durationSec: zod_1.z
+        .number()
+        .int()
+        .min(2)
+        .max(20)
+        .default(5)
+        .describe("Clip length in seconds (model-capped)."),
+    aspectRatio: zod_1.z.enum(["9:16", "16:9", "1:1", "4:5"]).default("9:16"),
+    resolution: zod_1.z.enum(["720p", "1080p", "4k"]).optional(),
+    inputImageUrl: zod_1.z
+        .string()
+        .url()
+        .optional()
+        .describe("Source image for image-to-video. If set, this is an animate_image-style call."),
+    audio: zod_1.z.boolean().optional().describe("Whether the model should generate audio."),
+    negativePrompt: zod_1.z.string().optional(),
+});
+const OutputSchema = zod_1.z.object({
+    status: zod_1.z.literal("triggered"),
+    taskId: zod_1.z.string().describe("Provider task id — pass to monitor/poll layer."),
+    raw: zod_1.z.unknown(),
+});
+exports.generateVideoTool = {
+    name: "generate_video",
+    description: [
+        "Trigger AI video generation (T2 image-to-video or T3 text-to-video tier).",
+        "Returns immediately with a provider task id; the executor must poll status",
+        "via the existing job monitor — DO NOT block on completion in the tool.",
+        "Use sparingly: this is the most expensive tool. Prefer search_stock for",
+        "generic b-roll and animate_image (image-to-video) for product/scene shots",
+        "where a still + motion is enough.",
+        "Examples:",
+        '  { prompt: "slow dolly into a steaming espresso cup, warm light", modelKey: "kling-v2.6", durationSec: 5 }',
+        '  { prompt: "subject turns to camera, smiles", modelKey: "runway-gen4-turbo", inputImageUrl: "https://...", durationSec: 5 }',
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: false,
+    estimateCost: async (input) => {
+        // Rough per-second tier estimate; precise pricing comes from aiModelConfigs.
+        const isPremium = input.modelKey.startsWith("google-veo-3") ||
+            input.modelKey.startsWith("runway-gen4") ||
+            input.modelKey.startsWith("openai-sora");
+        return Math.ceil(input.durationSec * (isPremium ? 12 : 4));
+    },
+    handler: async (input) => {
+        const provider = (0, aiGenFactory_service_1.getAiGenProviderService)(input.modelKey);
+        const result = await provider.generateVideo({
+            prompt: input.prompt,
+            modelKey: input.modelKey,
+            duration: input.durationSec,
+            aspectRatio: input.aspectRatio,
+            resolution: input.resolution,
+            inputImageUrl: input.inputImageUrl,
+            audio: input.audio,
+            negativePrompt: input.negativePrompt,
+            type: input.inputImageUrl ? "image-to-video" : "text-to-video",
+        });
+        const taskId = result.task?.taskId ??
+            result.task?.id ??
+            "unknown";
+        return {
+            status: "triggered",
+            taskId,
+            raw: result.task,
+        };
+    },
+};
+(0, toolRegistry_1.registerTool)(exports.generateVideoTool);

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

@@ -0,0 +1,18 @@
+import { z } from "zod";
+import { ToolDefinition } from "../toolRegistry";
+declare const InputSchema: z.ZodObject<{
+    text: z.ZodString;
+    provider: z.ZodDefault<z.ZodEnum<{
+        elevenlabs: "elevenlabs";
+    }>>;
+    voiceId: z.ZodOptional<z.ZodString>;
+    languageCode: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    audioBase64: z.ZodString;
+    mimeType: z.ZodString;
+    extension: z.ZodString;
+}, z.core.$strip>;
+export declare const generateVoiceoverTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=generateVoiceover.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateVoiceover.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/generateVoiceover.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAO/D,QAAA,MAAM,WAAW;;;;;;;iBAUf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;iBAMhB,CAAC;AAEH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAChD,OAAO,WAAW,EAClB,OAAO,YAAY,CAkDpB,CAAC"}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVoiceoverTool = void 0;
+const zod_1 = require("zod");
+const assetCache_service_1 = require("../../assetCache.service");
+const ttsFactory_service_1 = require("../../tts/ttsFactory.service");
+const toolRegistry_1 = require("../toolRegistry");
+// Firestore docs are capped at ~1MB. Base64 inflates ~33%, so a 700KB
+// payload limit keeps us safely under for the doc + metadata. Anything
+// larger (long monologues at high bitrate) skips the cache write.
+const VO_CACHE_MAX_BYTES = 700000;
+const InputSchema = zod_1.z.object({
+    text: zod_1.z.string().min(1).describe("VO line to synthesize. One scene's worth."),
+    provider: zod_1.z.enum(["elevenlabs"]).default("elevenlabs"),
+    voiceId: zod_1.z
+        .string()
+        .optional()
+        .describe("Provider-specific voice id. Omit to use the project default; the brand kit's voice id is auto-injected by the executor."),
+    languageCode: zod_1.z.string().optional().describe('Locale, e.g. "en", "fr-FR".'),
+});
+const OutputSchema = zod_1.z.object({
+    audioBase64: zod_1.z
+        .string()
+        .describe("Base64-encoded audio bytes — host uploads to GCS and swaps for url."),
+    mimeType: zod_1.z.string(),
+    extension: zod_1.z.string(),
+});
+exports.generateVoiceoverTool = {
+    name: "generate_voiceover",
+    description: [
+        "Generate a TTS voiceover line. One call per scene; do NOT batch multi-scene",
+        "scripts in one call — per-scene calls give the editor clean cut points and",
+        "the asset cache deduplicates retries.",
+        "Examples:",
+        '  { text: "Try our new vitamin C serum — visibly brighter in 7 days." }',
+        '  { text: "Bonjour", languageCode: "fr-FR" }',
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: true,
+    estimateCost: async (input) => Math.max(1, Math.ceil(input.text.length / 200)),
+    handler: async (input) => {
+        const cacheParts = {
+            provider: `tts:${input.provider}`,
+            kind: "voiceover",
+            input: {
+                text: input.text,
+                voiceId: input.voiceId,
+                languageCode: input.languageCode,
+            },
+        };
+        const hit = await assetCache_service_1.RawAssetCacheService.lookup(cacheParts);
+        if (hit)
+            return hit;
+        const provider = (0, ttsFactory_service_1.getTtsProviderService)(input.provider);
+        const result = await provider.generate({
+            text: input.text,
+            voiceId: input.voiceId,
+            languageCode: input.languageCode,
+        });
+        const payload = {
+            audioBase64: result.audioBuffer.toString("base64"),
+            mimeType: result.mimeType,
+            extension: result.extension,
+        };
+        if (payload.audioBase64.length <= VO_CACHE_MAX_BYTES) {
+            void assetCache_service_1.RawAssetCacheService.store(cacheParts, payload).catch(() => undefined);
+        }
+        return payload;
+    },
+};
+(0, toolRegistry_1.registerTool)(exports.generateVoiceoverTool);

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

@@ -0,0 +1,19 @@
+/**
+ * Importing this file registers every built-in tool with the toolRegistry.
+ * Host apps (Express server, Firebase Functions) import this once at boot.
+ */
+export * from "./searchStock.tool";
+export * from "./generateImage.tool";
+export * from "./generateVideo.tool";
+export * from "./generateVoiceover.tool";
+export * from "./animateImage.tool";
+export * from "./animateImageWithMotionBrush.tool";
+export * from "./generateAvatarVideo.tool";
+export * from "./planVideo.tool";
+export * from "./composeScene.tool";
+export * from "./render.tool";
+export * from "./analyzeReference.tool";
+export * from "./searchUserLibrary.tool";
+export * from "./searchMusic.tool";
+export * from "./estimateCost.tool";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +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,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"}

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

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Importing this file registers every built-in tool with the toolRegistry.
+ * Host apps (Express server, Firebase Functions) import this once at boot.
+ */
+__exportStar(require("./searchStock.tool"), exports);
+__exportStar(require("./generateImage.tool"), exports);
+__exportStar(require("./generateVideo.tool"), exports);
+__exportStar(require("./generateVoiceover.tool"), exports);
+__exportStar(require("./animateImage.tool"), exports);
+__exportStar(require("./animateImageWithMotionBrush.tool"), exports);
+__exportStar(require("./generateAvatarVideo.tool"), exports);
+__exportStar(require("./planVideo.tool"), exports);
+__exportStar(require("./composeScene.tool"), exports);
+__exportStar(require("./render.tool"), exports);
+__exportStar(require("./analyzeReference.tool"), exports);
+__exportStar(require("./searchUserLibrary.tool"), exports);
+__exportStar(require("./searchMusic.tool"), exports);
+__exportStar(require("./estimateCost.tool"), exports);

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

@@ -0,0 +1,191 @@
+import { z } from "zod";
+import { LlmCaller } from "../llmCaller";
+import { ToolDefinition } from "../toolRegistry";
+export declare function setPlannerLlmCaller(llm: LlmCaller): void;
+declare const InputSchema: z.ZodObject<{
+    brief: z.ZodObject<{
+        rawPrompt: z.ZodString;
+        goal: z.ZodOptional<z.ZodString>;
+        niche: z.ZodOptional<z.ZodEnum<{
+            "ugc-ad": "ugc-ad";
+            "faceless-yt": "faceless-yt";
+            "product-demo": "product-demo";
+            "talking-head": "talking-head";
+            "social-recap": "social-recap";
+            "real-estate": "real-estate";
+            recipe: "recipe";
+            travel: "travel";
+            fitness: "fitness";
+            "podcast-clip": "podcast-clip";
+            education: "education";
+            news: "news";
+            other: "other";
+        }>>;
+        audience: z.ZodOptional<z.ZodString>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            energetic: "energetic";
+            calm: "calm";
+            cinematic: "cinematic";
+            playful: "playful";
+            casual: "casual";
+            professional: "professional";
+            edgy: "edgy";
+            warm: "warm";
+            informational: "informational";
+        }>>;
+        hookStyle: z.ZodOptional<z.ZodEnum<{
+            question: "question";
+            "bold-claim": "bold-claim";
+            "pattern-interrupt": "pattern-interrupt";
+            story: "story";
+            stat: "stat";
+            demo: "demo";
+            "voiceover-only": "voiceover-only";
+        }>>;
+        pacing: z.ZodOptional<z.ZodEnum<{
+            medium: "medium";
+            fast: "fast";
+            slow: "slow";
+            "very-fast": "very-fast";
+        }>>;
+        durationSec: z.ZodOptional<z.ZodNumber>;
+        aspect: z.ZodOptional<z.ZodEnum<{
+            "9:16": "9:16";
+            "16:9": "16:9";
+            "1:1": "1:1";
+            "4:5": "4:5";
+        }>>;
+        voice: z.ZodOptional<z.ZodObject<{
+            gender: z.ZodOptional<z.ZodEnum<{
+                female: "female";
+                male: "male";
+                neutral: "neutral";
+            }>>;
+            ageRange: z.ZodOptional<z.ZodEnum<{
+                child: "child";
+                teen: "teen";
+                "young-adult": "young-adult";
+                adult: "adult";
+                senior: "senior";
+            }>>;
+            accent: z.ZodOptional<z.ZodString>;
+            language: z.ZodDefault<z.ZodString>;
+            voiceId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        music: z.ZodOptional<z.ZodObject<{
+            moods: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                energetic: "energetic";
+                calm: "calm";
+                cinematic: "cinematic";
+                uplifting: "uplifting";
+                tense: "tense";
+                dreamy: "dreamy";
+                dark: "dark";
+                playful: "playful";
+            }>>>;
+            bpmMin: z.ZodOptional<z.ZodNumber>;
+            bpmMax: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        cta: z.ZodOptional<z.ZodString>;
+        claims: z.ZodDefault<z.ZodObject<{
+            allow: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            block: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+        references: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            analyzed: z.ZodOptional<z.ZodObject<{
+                durationMs: z.ZodNumber;
+                sceneCount: z.ZodNumber;
+                hookMs: z.ZodNumber;
+                cutsPerSecond: z.ZodNumber;
+                bpm: z.ZodOptional<z.ZodNumber>;
+                transcriptExcerpt: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>>;
+        tierBudget: z.ZodDefault<z.ZodEnum<{
+            T0: "T0";
+            T1: "T1";
+            T2: "T2";
+            T3: "T3";
+        }>>;
+        confidence: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    plan: z.ZodObject<{
+        briefId: z.ZodOptional<z.ZodString>;
+        persona: z.ZodEnum<{
+            "ugc-ad": "ugc-ad";
+            "faceless-yt": "faceless-yt";
+            "product-demo": "product-demo";
+            "talking-head": "talking-head";
+            "social-recap": "social-recap";
+        }>;
+        aspect: z.ZodEnum<{
+            "9:16": "9:16";
+            "16:9": "16:9";
+            "1:1": "1:1";
+            "4:5": "4:5";
+        }>;
+        totalDurationMs: z.ZodNumber;
+        totalEstimatedCredits: z.ZodNumber;
+        scenes: z.ZodArray<z.ZodObject<{
+            sceneIndex: z.ZodNumber;
+            intent: z.ZodString;
+            strategy: z.ZodEnum<{
+                "stock-video": "stock-video";
+                "stock-image-ken-burns": "stock-image-ken-burns";
+                "ai-image-static": "ai-image-static";
+                "ai-image-motion": "ai-image-motion";
+                "ai-image-to-video": "ai-image-to-video";
+                "ai-text-to-video": "ai-text-to-video";
+                "user-asset": "user-asset";
+                "talking-head-avatar": "talking-head-avatar";
+            }>;
+            tier: z.ZodEnum<{
+                T0: "T0";
+                T1: "T1";
+                T2: "T2";
+                T3: "T3";
+            }>;
+            preferredProvider: z.ZodOptional<z.ZodString>;
+            preferredModel: z.ZodOptional<z.ZodString>;
+            prompt: z.ZodString;
+            durationMs: z.ZodNumber;
+            voiceoverLine: z.ZodOptional<z.ZodString>;
+            onScreenText: z.ZodOptional<z.ZodString>;
+            transitionIn: z.ZodDefault<z.ZodEnum<{
+                none: "none";
+                fade: "fade";
+                crossfade: "crossfade";
+                wipe: "wipe";
+                whipPan: "whipPan";
+                dipToBlack: "dipToBlack";
+                dipToWhite: "dipToWhite";
+                cut: "cut";
+            }>>;
+            estimatedCredits: z.ZodNumber;
+            avatarFaceUrl: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        music: z.ZodOptional<z.ZodObject<{
+            strategy: z.ZodEnum<{
+                none: "none";
+                "stock-track": "stock-track";
+                generated: "generated";
+            }>;
+            query: z.ZodOptional<z.ZodString>;
+            moodTag: z.ZodOptional<z.ZodString>;
+            bpm: z.ZodOptional<z.ZodNumber>;
+            url: z.ZodOptional<z.ZodString>;
+            durationSec: z.ZodOptional<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodString>;
+            attribution: z.ZodOptional<z.ZodString>;
+            onsets: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        }, z.core.$strip>>;
+        voiceId: z.ZodOptional<z.ZodString>;
+        notes: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const planVideoTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=planVideo.tool.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planVideoTool = void 0;
+exports.setPlannerLlmCaller = setPlannerLlmCaller;
+const zod_1 = require("zod");
+const brief_schema_1 = require("../../../schemas/brief.schema");
+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.
+ */
+let injectedLlm = null;
+function setPlannerLlmCaller(llm) {
+    injectedLlm = llm;
+}
+const InputSchema = zod_1.z.object({
+    brief: brief_schema_1.VideoBriefSchema.describe("Structured brief produced by the intent-capture stage."),
+});
+const OutputSchema = zod_1.z.object({
+    plan: videoPlan_schema_1.VideoPlanSchema,
+});
+exports.planVideoTool = {
+    name: "plan_video",
+    description: [
+        "Turn a structured VideoBrief into a scene-by-scene VideoPlan with per-scene",
+        "tier, prompt, voiceover line, and estimated credits. Always run this BEFORE",
+        "any generate_* tool — the storyboard preview gate depends on a valid plan.",
+        "Do NOT call this multiple times for the same brief in one run; if the user",
+        "edits a scene, mutate the existing plan rather than re-planning from scratch.",
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: false,
+    handler: async (input) => {
+        if (!injectedLlm) {
+            throw new Error("plan_video: no LlmCaller wired. Host must call setPlannerLlmCaller() at boot.");
+        }
+        const planner = new planner_1.Planner({ llm: injectedLlm });
+        const plan = await planner.plan(input.brief);
+        return { plan };
+    },
+};
+(0, toolRegistry_1.registerTool)(exports.planVideoTool);