vidspotai-shared 1.0.82-dev.0 → 1.0.83

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

@@ -29,9 +29,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";
             }>;
@@ -83,6 +83,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;
@@ -139,6 +143,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;
@@ -187,6 +195,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;
@@ -238,6 +250,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;
@@ -265,6 +281,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>;
@@ -288,6 +305,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;
@@ -344,7 +365,13 @@ declare const OutputSchema: z.ZodObject<{
         clipId: z.ZodString;
         tier: z.ZodString;
         source: z.ZodString;
+        modelKey: z.ZodOptional<z.ZodString>;
         credits: z.ZodNumber;
+        basis: z.ZodEnum<{
+            tier: "tier";
+            model: "model";
+            actual: "actual";
+        }>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const estimateCostTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;

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

@@ -1 +1 @@
-{"version":3,"file":"estimateCost.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/estimateCost.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;iBAUhB,CAAC;AAEH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAC3C,OAAO,WAAW,EAClB,OAAO,YAAY,CA0BpB,CAAC"}
+{"version":3,"file":"estimateCost.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/estimateCost.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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;iBAmBhB,CAAC;AAEH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAC3C,OAAO,WAAW,EAClB,OAAO,YAAY,CAgEpB,CAAC"}

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.estimateCostTool = void 0;
 const zod_1 = require("zod");
+const aiModels_1 = require("../../../globals/aiModels");
 const project_schema_1 = require("../../../schemas/project.schema");
 const toolRegistry_1 = require("../toolRegistry");
 const InputSchema = zod_1.z.object({
@@ -13,16 +14,27 @@ const OutputSchema = zod_1.z.object({
         clipId: zod_1.z.string(),
         tier: zod_1.z.string(),
         source: zod_1.z.string(),
+        /** Model the clip was (or will be) generated with, when known. */
+        modelKey: zod_1.z.string().optional(),
         credits: zod_1.z.number().nonnegative(),
+        /**
+         * How `credits` was derived:
+         *   actual — clip already generated; provenance.creditsSpent is exact.
+         *   model  — AG-6 real per-model rate from aiModelConfigs[modelKey].
+         *   tier   — coarse per-tier coefficient (no/unknown modelKey or no cost block).
+         */
+        basis: zod_1.z.enum(["actual", "model", "tier"]),
     })),
 });
 exports.estimateCostTool = {
     name: "estimate_cost",
     description: [
         "Estimate the credit cost of rendering a Project JSON without spending any",
-        "credits. Reads each clip's provenance.creditsSpent (if already generated)",
-        "or estimates from tier when not yet generated. Always call before",
-        "executing a plan so the planner can stay within budget.",
+        "credits. Per clip, in order: uses provenance.creditsSpent if already",
+        "generated (exact); else the real per-model rate from the clip's",
+        "provenance.modelKey (AG-6); else a coarse per-tier coefficient when the",
+        "model is unknown. Always call before executing a plan so the planner can",
+        "stay within budget.",
     ].join(" "),
     inputSchema: InputSchema,
     outputSchema: OutputSchema,
@@ -31,8 +43,42 @@ exports.estimateCostTool = {
         const breakdown = project.clips.map((clip) => {
             const tier = clip.provenance?.tier ?? "T0";
             const source = clip.provenance?.source ?? "user-upload";
-            const credits = clip.provenance?.creditsSpent ?? estimateFromTier(tier, clip.display);
-            return { clipId: clip.id, tier, source, credits };
+            const modelKey = clip.provenance?.modelKey;
+            // 1. Already generated → provenance.creditsSpent is the exact charge.
+            if (clip.provenance?.creditsSpent != null) {
+                return {
+                    clipId: clip.id,
+                    tier,
+                    source,
+                    modelKey,
+                    credits: clip.provenance.creditsSpent,
+                    basis: "actual",
+                };
+            }
+            // 2. AG-6: real per-model rate keyed on the planned modelKey.
+            const seconds = Math.max(0, (clip.display.to - clip.display.from) / 1000);
+            if (modelKey) {
+                const modelCredits = (0, aiModels_1.estimateModelCredits)(modelKey, seconds);
+                if (modelCredits != null) {
+                    return {
+                        clipId: clip.id,
+                        tier,
+                        source,
+                        modelKey,
+                        credits: modelCredits,
+                        basis: "model",
+                    };
+                }
+            }
+            // 3. Fall back to the coarse per-tier coefficient.
+            return {
+                clipId: clip.id,
+                tier,
+                source,
+                modelKey,
+                credits: estimateFromTier(tier, clip.display),
+                basis: "tier",
+            };
         });
         return {
             totalCredits: breakdown.reduce((s, b) => s + b.credits, 0),
@@ -41,8 +87,10 @@ exports.estimateCostTool = {
     },
 };
 /**
- * Rough per-second per-tier estimate, in credits. Refined later via aiModelConfigs
- * lookups once tier annotations are backfilled across providers.
+ * Coarse per-second per-tier estimate, in credits. Fallback ONLY — used when a
+ * clip has no modelKey or the model has no usable cost block. Generated clips
+ * with a known modelKey now go through estimateModelCredits() (AG-6) for real
+ * per-model rates.
  */
 function estimateFromTier(tier, display) {
     const seconds = Math.max(0, (display.to - display.from) / 1000);

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

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import { EVideoGenModels } from "../../../globals/aiModels";
+import { ToolDefinition } from "../toolRegistry";
+/** Whether a model key can be extended via its provider's extend endpoint. */
+export declare function modelSupportsExtend(modelKey: string): boolean;
+declare const InputSchema: z.ZodObject<{
+    previousTaskId: z.ZodString;
+    modelKey: z.ZodEnum<typeof EVideoGenModels>;
+    extraDurationSec: z.ZodDefault<z.ZodNumber>;
+    prompt: z.ZodOptional<z.ZodString>;
+    negativePrompt: z.ZodOptional<z.ZodString>;
+    resolution: z.ZodOptional<z.ZodEnum<{
+        "720p": "720p";
+        "1080p": "1080p";
+        "4k": "4k";
+    }>>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    status: z.ZodLiteral<"triggered">;
+    taskId: z.ZodString;
+    raw: z.ZodUnknown;
+    modelKeyUsed: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const extendVideoTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=extendVideo.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extendVideo.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/extendVideo.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;AAyB/D,8EAA8E;AAC9E,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;iBAsCf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;iBAMhB,CAAC;AAEH,eAAO,MAAM,eAAe,EAAE,cAAc,CAC1C,OAAO,WAAW,EAClB,OAAO,YAAY,CA6EpB,CAAC"}

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendVideoTool = void 0;
+exports.modelSupportsExtend = modelSupportsExtend;
+const zod_1 = require("zod");
+const aiModels_1 = require("../../../globals/aiModels");
+const logger_1 = require("../../../utils/logger");
+const aiGenFactory_service_1 = require("../../aiGen/aiGenFactory.service");
+const rateLimiter_1 = require("../../rateLimiter");
+const toolRegistry_1 = require("../toolRegistry");
+/**
+ * AG-2: models whose provider exposes a native video-extension endpoint
+ * (`endpoint: "extend"` + `sourceTaskId`). Extension continues a SPECIFIC prior
+ * provider task, so — unlike generate_video — there is NO cross-provider
+ * fallback: the source clip physically lives on the originating provider's
+ * account. Kling video-extend (/v1/videos/video-extend) and Pixverse
+ * (/video/extend/generate) are the two implemented today. Special-endpoint
+ * Kling variants (avatar, omni-video, motion-control, lip-sync) are excluded —
+ * the generic video-extend endpoint does not accept their tasks.
+ */
+const EXTEND_CAPABLE_MODELS = new Set([
+    aiModels_1.EVideoGenModels.KLING_V2_MASTER,
+    aiModels_1.EVideoGenModels.KLING_V2_1,
+    aiModels_1.EVideoGenModels.KLING_V2_1_MASTER,
+    aiModels_1.EVideoGenModels.KLING_V2_5_TURBO,
+    aiModels_1.EVideoGenModels.KLING_V2_6,
+    aiModels_1.EVideoGenModels.KLING_V3_0,
+    aiModels_1.EVideoGenModels.PIXVERSE_V5,
+    aiModels_1.EVideoGenModels.PIXVERSE_V5_5,
+    aiModels_1.EVideoGenModels.PIXVERSE_V5_6,
+    aiModels_1.EVideoGenModels.PIXVERSE_V6,
+]);
+/** Whether a model key can be extended via its provider's extend endpoint. */
+function modelSupportsExtend(modelKey) {
+    return EXTEND_CAPABLE_MODELS.has(modelKey);
+}
+const InputSchema = zod_1.z.object({
+    previousTaskId: zod_1.z
+        .string()
+        .min(1)
+        .describe("Provider task id of the clip to continue FROM — the taskId returned by a " +
+        "prior generate_video/animate_image call on the SAME provider/model. " +
+        "Extension physically continues that clip; it cannot reference a task " +
+        "from a different provider."),
+    modelKey: zod_1.z
+        .nativeEnum(aiModels_1.EVideoGenModels)
+        .describe("MUST be the same extend-capable model that produced previousTaskId. " +
+        "Only Kling (v2-master/v2.1/v2.1-master/v2.5-turbo/v2.6/v3.0) and " +
+        "Pixverse (v5/v5.5/v5.6/v6) support extension."),
+    extraDurationSec: zod_1.z
+        .number()
+        .int()
+        .min(2)
+        .max(10)
+        .default(5)
+        .describe("Requested additional seconds. NOTE: providers extend by a fixed native " +
+        "increment (Kling ~4-5s, Pixverse ~5-8s) and may not honour an arbitrary " +
+        "value exactly — this drives cost estimation and the provider's quality " +
+        "tier, not a precise cut length."),
+    prompt: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional motion/visual prompt for the continuation. Omit to let the " +
+        "extension continue the source clip's motion naturally."),
+    negativePrompt: zod_1.z.string().optional(),
+    resolution: zod_1.z.enum(["720p", "1080p", "4k"]).optional(),
+});
+const OutputSchema = zod_1.z.object({
+    status: zod_1.z.literal("triggered"),
+    taskId: zod_1.z.string().describe("New provider task id for the extension clip — poll like any other."),
+    raw: zod_1.z.unknown(),
+    /** Echoes the model used (extension never falls back, so == input.modelKey). */
+    modelKeyUsed: zod_1.z.string().optional(),
+});
+exports.extendVideoTool = {
+    name: "extend_video",
+    description: [
+        "Continue an EXISTING video clip past a model's per-clip max by calling the",
+        "provider's native extension endpoint, instead of falling back to a different",
+        "provider (which would visibly change look/identity). Returns a new provider",
+        "task id for the continuation clip — poll it like any other; the stitcher",
+        "concatenates the source clip + extension(s) in order.",
+        "Use when a single scene needs more seconds than the chosen model allows:",
+        "first generate_video/animate_image for the initial clip, then N extend_video",
+        "calls each continuing the PREVIOUS task. Only Kling and Pixverse video models",
+        "support this; the same model that produced previousTaskId must be passed.",
+        "Example:",
+        '  { previousTaskId: "<kling task id>", modelKey: "kling-v2.6", extraDurationSec: 5 }',
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: false,
+    estimateCost: async (input) => {
+        // Same per-second tier coefficient as generate_video; extension is billed
+        // per added second at the base model's rate.
+        const isPremium = input.modelKey === aiModels_1.EVideoGenModels.KLING_V3_0 ||
+            input.modelKey === aiModels_1.EVideoGenModels.KLING_V2_6;
+        return Math.ceil(input.extraDurationSec * (isPremium ? 12 : 4));
+    },
+    handler: async (input) => {
+        if (!modelSupportsExtend(input.modelKey)) {
+            throw new Error(`extend_video: model "${input.modelKey}" has no extension endpoint. ` +
+                "Extend-capable: Kling (v2-master/v2.1/v2.1-master/v2.5-turbo/v2.6/v3.0), " +
+                "Pixverse (v5/v5.5/v5.6/v6).");
+        }
+        // No provider fallback: the source task lives on this provider only. Hold a
+        // rate-limit slot through return (the host's TaskPoller releases it when the
+        // task settles); release here on submit error / missing taskId.
+        const limiter = (0, rateLimiter_1.getAiGenModelRateLimiter)(input.modelKey);
+        await limiter.waitUntilAvailable();
+        let heldSlot = true;
+        try {
+            const provider = (0, aiGenFactory_service_1.getAiGenProviderService)(input.modelKey);
+            const result = await provider.generateVideo({
+                modelKey: input.modelKey,
+                endpoint: "extend",
+                sourceTaskId: input.previousTaskId,
+                duration: input.extraDurationSec,
+                prompt: input.prompt,
+                negativePrompt: input.negativePrompt,
+                resolution: input.resolution,
+            });
+            const taskId = result.task?.taskId ??
+                result.task?.id ??
+                (typeof result.task === "string" ? result.task : "unknown");
+            if (taskId === "unknown") {
+                limiter.releaseSlot();
+                heldSlot = false;
+            }
+            logger_1.logger.info("extend_video: extension submitted", {
+                modelKey: input.modelKey,
+                previousTaskId: input.previousTaskId,
+                taskId,
+            });
+            return {
+                status: "triggered",
+                taskId,
+                raw: result.task,
+                modelKeyUsed: input.modelKey,
+            };
+        }
+        catch (err) {
+            if (heldSlot)
+                limiter.releaseSlot();
+            throw err;
+        }
+    },
+};
+(0, toolRegistry_1.registerTool)(exports.extendVideoTool);

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

@@ -0,0 +1,184 @@
+import { z } from "zod";
+import { VideoBrief } from "../../../schemas/brief.schema";
+import { Script } from "../../../schemas/videoPlan.schema";
+import { LlmCaller } from "../llmCaller";
+import { ToolDefinition } from "../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.
+ */
+declare const InputSchema: z.ZodObject<{
+    brief: z.ZodObject<{
+        rawPrompt: z.ZodString;
+        goal: z.ZodOptional<z.ZodString>;
+        niche: z.ZodOptional<z.ZodEnum<{
+            other: "other";
+            news: "news";
+            "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";
+        }>>;
+        audience: z.ZodOptional<z.ZodString>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            professional: "professional";
+            energetic: "energetic";
+            calm: "calm";
+            cinematic: "cinematic";
+            casual: "casual";
+            playful: "playful";
+            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";
+            "1:1": "1:1";
+            "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";
+                female: "female";
+                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>;
+            style: z.ZodOptional<z.ZodEnum<{
+                energetic: "energetic";
+                calm: "calm";
+                casual: "casual";
+                warm: "warm";
+                neutral: "neutral";
+                excited: "excited";
+                happy: "happy";
+                serious: "serious";
+                dramatic: "dramatic";
+                whisper: "whisper";
+            }>>;
+        }, z.core.$strip>>;
+        music: z.ZodOptional<z.ZodObject<{
+            moods: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                energetic: "energetic";
+                calm: "calm";
+                cinematic: "cinematic";
+                playful: "playful";
+                uplifting: "uplifting";
+                tense: "tense";
+                dreamy: "dreamy";
+                dark: "dark";
+            }>>>;
+            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>>>;
+        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";
+            indirect: "indirect";
+        }>>;
+        consistencyTier: z.ZodOptional<z.ZodEnum<{
+            C0: "C0";
+            C1: "C1";
+            C2: "C2";
+        }>>;
+        confidence: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, z.core.$strip>;
+    wpm: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    script: z.ZodObject<{
+        fullText: z.ZodString;
+        wordCount: z.ZodOptional<z.ZodNumber>;
+        estimatedDurationMs: z.ZodOptional<z.ZodNumber>;
+        wpm: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>;
+    suggestedTitle: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * 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.
+ */
+export declare function generateScriptCore(llm: LlmCaller, brief: VideoBrief, wpmOverride?: number): Promise<{
+    script: Script;
+    suggestedTitle?: string;
+}>;
+export declare const generateScriptTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=generateScript.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateScript.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/generateScript.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,UAAU,EAAoB,MAAM,+BAA+B,CAAC;AAC7E,OAAO,EAAE,MAAM,EAAgB,MAAM,mCAAmC,CAAC;AACzE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAIzC,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;;;;;;;;;;;;GAeG;AAEH,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUf,CAAC;AAeH,QAAA,MAAM,YAAY;;;;;;;;iBAGhB,CAAC;AAEH;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,SAAS,EACd,KAAK,EAAE,UAAU,EACjB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAyDtD;AAED,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAC7C,OAAO,WAAW,EAClB,OAAO,YAAY,CAcpB,CAAC"}