vidspotai-shared 1.0.53 → 1.0.55

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

@@ -0,0 +1 @@
+{"version":3,"file":"composeScene.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/composeScene.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAiC/D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIhB,CAAC;AAEH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAC3C,OAAO,WAAW,EAClB,OAAO,YAAY,CA4DpB,CAAC"}

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composeSceneTool = void 0;
+const zod_1 = require("zod");
+const project_schema_1 = require("../../../schemas/project.schema");
+const toolRegistry_1 = require("../toolRegistry");
+/**
+ * compose_scene — pure Project JSON mutation.
+ *
+ * Insert / replace / remove clips for a single scene index, optionally append a
+ * transition into the next scene. Pure function: input project + ops → output
+ * project. Persistence is the host's job (separate render/save tools).
+ */
+const SceneSpecSchema = zod_1.z.object({
+    sceneIndex: zod_1.z
+        .number()
+        .int()
+        .nonnegative()
+        .describe("0-based scene position the clips belong to."),
+    insertAtMs: zod_1.z
+        .number()
+        .nonnegative()
+        .describe("Absolute project timestamp (ms) where the scene starts."),
+    clips: zod_1.z
+        .array(project_schema_1.ClipSchema)
+        .min(1)
+        .describe("Clips that make up the scene. display.from/to must be relative to project t=0, not the scene."),
+    transitionIn: project_schema_1.TransitionSchema.optional().describe("Transition from previous scene's last clip into this scene's first clip."),
+    /** If true, replaces any existing clips that overlap this scene's time range. */
+    replaceOverlapping: zod_1.z.boolean().default(false),
+});
+const InputSchema = zod_1.z.object({
+    project: project_schema_1.ProjectSchema.describe("Current project JSON. Will be mutated by spec."),
+    spec: SceneSpecSchema,
+});
+const OutputSchema = zod_1.z.object({
+    project: project_schema_1.ProjectSchema,
+    insertedClipIds: zod_1.z.array(zod_1.z.string()),
+    removedClipIds: zod_1.z.array(zod_1.z.string()),
+});
+exports.composeSceneTool = {
+    name: "compose_scene",
+    description: [
+        "Apply a scene-level edit to the Project JSON: insert clips, optionally",
+        "replace overlapping ones, attach an inbound transition. Pure function —",
+        "returns a new project; does NOT persist or render.",
+        "Call once per scene as the executor lands assets. Do NOT batch multi-scene",
+        "edits in a single call; one-scene-at-a-time keeps undo and provenance clean.",
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: true,
+    handler: async (input) => {
+        const { project, spec } = input;
+        const sceneStart = spec.insertAtMs;
+        const sceneEnd = Math.max(...spec.clips.map((c) => c.display.to));
+        let removedClipIds = [];
+        let nextClips = project.clips;
+        if (spec.replaceOverlapping) {
+            const overlaps = (from, to) => from < sceneEnd && to > sceneStart;
+            removedClipIds = project.clips
+                .filter((c) => overlaps(c.display.from, c.display.to))
+                .map((c) => c.id);
+            nextClips = project.clips.filter((c) => !removedClipIds.includes(c.id));
+        }
+        const insertedClipIds = spec.clips.map((c) => c.id);
+        nextClips = [...nextClips, ...spec.clips];
+        let nextTransitions = project.transitions;
+        if (spec.transitionIn) {
+            // Drop any existing transition pointing to the same toClipId.
+            nextTransitions = project.transitions.filter((t) => t.toClipId !== spec.transitionIn.toClipId);
+            nextTransitions = [...nextTransitions, spec.transitionIn];
+        }
+        const nextDuration = Math.max(project.durationMs, sceneEnd);
+        const nextProject = {
+            ...project,
+            clips: nextClips,
+            transitions: nextTransitions,
+            durationMs: nextDuration,
+            updatedAt: new Date().toISOString(),
+        };
+        // Re-validate to catch any drift.
+        return {
+            project: project_schema_1.ProjectSchema.parse(nextProject),
+            insertedClipIds,
+            removedClipIds,
+        };
+    },
+};
+(0, toolRegistry_1.registerTool)(exports.composeSceneTool);

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

@@ -0,0 +1,342 @@
+import { z } from "zod";
+import { ToolDefinition } from "../toolRegistry";
+declare const InputSchema: z.ZodObject<{
+    project: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<1>;
+        id: z.ZodString;
+        name: z.ZodString;
+        durationMs: z.ZodNumber;
+        fps: z.ZodDefault<z.ZodNumber>;
+        size: z.ZodObject<{
+            width: z.ZodNumber;
+            height: z.ZodNumber;
+        }, z.core.$strip>;
+        aspect: z.ZodEnum<{
+            "9:16": "9:16";
+            "16:9": "16:9";
+            "1:1": "1:1";
+            "4:5": "4:5";
+        }>;
+        background: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"color">;
+            value: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            src: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"transparent">;
+        }, z.core.$strip>], "type">>;
+        tracks: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodEnum<{
+                audio: "audio";
+                video: "video";
+                text: "text";
+                caption: "caption";
+                fx: "fx";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            index: z.ZodNumber;
+            muted: z.ZodDefault<z.ZodBoolean>;
+            hidden: z.ZodDefault<z.ZodBoolean>;
+            locked: z.ZodDefault<z.ZodBoolean>;
+            gainDb: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        clips: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"video">;
+            src: z.ZodString;
+            trim: z.ZodOptional<z.ZodObject<{
+                from: z.ZodNumber;
+                to: z.ZodNumber;
+            }, z.core.$strip>>;
+            volume: z.ZodDefault<z.ZodNumber>;
+            playbackRate: z.ZodDefault<z.ZodNumber>;
+            colorGrade: z.ZodOptional<z.ZodObject<{
+                exposure: z.ZodDefault<z.ZodNumber>;
+                contrast: z.ZodDefault<z.ZodNumber>;
+                saturation: z.ZodDefault<z.ZodNumber>;
+                warmth: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            crop: z.ZodOptional<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strip>>;
+            id: z.ZodString;
+            trackId: z.ZodString;
+            display: z.ZodObject<{
+                from: z.ZodNumber;
+                to: z.ZodNumber;
+            }, z.core.$strip>;
+            name: z.ZodOptional<z.ZodString>;
+            provenance: z.ZodOptional<z.ZodObject<{
+                tier: z.ZodEnum<{
+                    T0: "T0";
+                    T1: "T1";
+                    T2: "T2";
+                    T3: "T3";
+                }>;
+                source: z.ZodString;
+                modelKey: z.ZodOptional<z.ZodString>;
+                prompt: z.ZodOptional<z.ZodString>;
+                assetHash: z.ZodOptional<z.ZodString>;
+                creditsSpent: z.ZodOptional<z.ZodNumber>;
+                generationId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+            transform: z.ZodDefault<z.ZodObject<{
+                x: z.ZodDefault<z.ZodNumber>;
+                y: z.ZodDefault<z.ZodNumber>;
+                scaleX: z.ZodDefault<z.ZodNumber>;
+                scaleY: z.ZodDefault<z.ZodNumber>;
+                rotation: z.ZodDefault<z.ZodNumber>;
+                opacity: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            locked: z.ZodDefault<z.ZodBoolean>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            src: z.ZodString;
+            motion: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    kenBurnsIn: "kenBurnsIn";
+                    kenBurnsOut: "kenBurnsOut";
+                    panLeft: "panLeft";
+                    panRight: "panRight";
+                    parallax: "parallax";
+                }>;
+                intensity: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            colorGrade: z.ZodOptional<z.ZodObject<{
+                exposure: z.ZodDefault<z.ZodNumber>;
+                contrast: z.ZodDefault<z.ZodNumber>;
+                saturation: z.ZodDefault<z.ZodNumber>;
+                warmth: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            id: z.ZodString;
+            trackId: z.ZodString;
+            display: z.ZodObject<{
+                from: z.ZodNumber;
+                to: z.ZodNumber;
+            }, z.core.$strip>;
+            name: z.ZodOptional<z.ZodString>;
+            provenance: z.ZodOptional<z.ZodObject<{
+                tier: z.ZodEnum<{
+                    T0: "T0";
+                    T1: "T1";
+                    T2: "T2";
+                    T3: "T3";
+                }>;
+                source: z.ZodString;
+                modelKey: z.ZodOptional<z.ZodString>;
+                prompt: z.ZodOptional<z.ZodString>;
+                assetHash: z.ZodOptional<z.ZodString>;
+                creditsSpent: z.ZodOptional<z.ZodNumber>;
+                generationId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+            transform: z.ZodDefault<z.ZodObject<{
+                x: z.ZodDefault<z.ZodNumber>;
+                y: z.ZodDefault<z.ZodNumber>;
+                scaleX: z.ZodDefault<z.ZodNumber>;
+                scaleY: z.ZodDefault<z.ZodNumber>;
+                rotation: z.ZodDefault<z.ZodNumber>;
+                opacity: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            locked: z.ZodDefault<z.ZodBoolean>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"audio">;
+            src: z.ZodString;
+            trim: z.ZodOptional<z.ZodObject<{
+                from: z.ZodNumber;
+                to: z.ZodNumber;
+            }, z.core.$strip>>;
+            volume: z.ZodDefault<z.ZodNumber>;
+            duckAgainstTrackId: z.ZodOptional<z.ZodString>;
+            fadeInMs: z.ZodDefault<z.ZodNumber>;
+            fadeOutMs: z.ZodDefault<z.ZodNumber>;
+            id: z.ZodString;
+            trackId: z.ZodString;
+            display: z.ZodObject<{
+                from: z.ZodNumber;
+                to: z.ZodNumber;
+            }, z.core.$strip>;
+            name: z.ZodOptional<z.ZodString>;
+            provenance: z.ZodOptional<z.ZodObject<{
+                tier: z.ZodEnum<{
+                    T0: "T0";
+                    T1: "T1";
+                    T2: "T2";
+                    T3: "T3";
+                }>;
+                source: z.ZodString;
+                modelKey: z.ZodOptional<z.ZodString>;
+                prompt: z.ZodOptional<z.ZodString>;
+                assetHash: z.ZodOptional<z.ZodString>;
+                creditsSpent: z.ZodOptional<z.ZodNumber>;
+                generationId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+            transform: z.ZodDefault<z.ZodObject<{
+                x: z.ZodDefault<z.ZodNumber>;
+                y: z.ZodDefault<z.ZodNumber>;
+                scaleX: z.ZodDefault<z.ZodNumber>;
+                scaleY: z.ZodDefault<z.ZodNumber>;
+                rotation: z.ZodDefault<z.ZodNumber>;
+                opacity: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            locked: z.ZodDefault<z.ZodBoolean>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+            fontFamily: z.ZodDefault<z.ZodString>;
+            fontSize: z.ZodDefault<z.ZodNumber>;
+            fontWeight: z.ZodDefault<z.ZodNumber>;
+            color: z.ZodDefault<z.ZodString>;
+            align: z.ZodDefault<z.ZodEnum<{
+                left: "left";
+                center: "center";
+                right: "right";
+            }>>;
+            backgroundColor: z.ZodOptional<z.ZodString>;
+            shadow: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            trackId: z.ZodString;
+            display: z.ZodObject<{
+                from: z.ZodNumber;
+                to: z.ZodNumber;
+            }, z.core.$strip>;
+            name: z.ZodOptional<z.ZodString>;
+            provenance: z.ZodOptional<z.ZodObject<{
+                tier: z.ZodEnum<{
+                    T0: "T0";
+                    T1: "T1";
+                    T2: "T2";
+                    T3: "T3";
+                }>;
+                source: z.ZodString;
+                modelKey: z.ZodOptional<z.ZodString>;
+                prompt: z.ZodOptional<z.ZodString>;
+                assetHash: z.ZodOptional<z.ZodString>;
+                creditsSpent: z.ZodOptional<z.ZodNumber>;
+                generationId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+            transform: z.ZodDefault<z.ZodObject<{
+                x: z.ZodDefault<z.ZodNumber>;
+                y: z.ZodDefault<z.ZodNumber>;
+                scaleX: z.ZodDefault<z.ZodNumber>;
+                scaleY: z.ZodDefault<z.ZodNumber>;
+                rotation: z.ZodDefault<z.ZodNumber>;
+                opacity: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            locked: z.ZodDefault<z.ZodBoolean>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"caption">;
+            text: z.ZodString;
+            words: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                word: z.ZodString;
+                start: z.ZodNumber;
+                end: z.ZodNumber;
+            }, z.core.$strip>>>;
+            fontFamily: z.ZodDefault<z.ZodString>;
+            fontSize: z.ZodDefault<z.ZodNumber>;
+            color: z.ZodDefault<z.ZodString>;
+            highlightColor: z.ZodOptional<z.ZodString>;
+            language: z.ZodDefault<z.ZodString>;
+            id: z.ZodString;
+            trackId: z.ZodString;
+            display: z.ZodObject<{
+                from: z.ZodNumber;
+                to: z.ZodNumber;
+            }, z.core.$strip>;
+            name: z.ZodOptional<z.ZodString>;
+            provenance: z.ZodOptional<z.ZodObject<{
+                tier: z.ZodEnum<{
+                    T0: "T0";
+                    T1: "T1";
+                    T2: "T2";
+                    T3: "T3";
+                }>;
+                source: z.ZodString;
+                modelKey: z.ZodOptional<z.ZodString>;
+                prompt: z.ZodOptional<z.ZodString>;
+                assetHash: z.ZodOptional<z.ZodString>;
+                creditsSpent: z.ZodOptional<z.ZodNumber>;
+                generationId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            effects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodString;
+                enabled: z.ZodDefault<z.ZodBoolean>;
+                params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>>;
+            transform: z.ZodDefault<z.ZodObject<{
+                x: z.ZodDefault<z.ZodNumber>;
+                y: z.ZodDefault<z.ZodNumber>;
+                scaleX: z.ZodDefault<z.ZodNumber>;
+                scaleY: z.ZodDefault<z.ZodNumber>;
+                rotation: z.ZodDefault<z.ZodNumber>;
+                opacity: z.ZodDefault<z.ZodNumber>;
+            }, z.core.$strip>>;
+            locked: z.ZodDefault<z.ZodBoolean>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>], "type">>;
+        transitions: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            fromClipId: z.ZodString;
+            toClipId: z.ZodString;
+            kind: z.ZodEnum<{
+                none: "none";
+                fade: "fade";
+                crossfade: "crossfade";
+                wipe: "wipe";
+                slide: "slide";
+                whipPan: "whipPan";
+                dipToBlack: "dipToBlack";
+                dipToWhite: "dipToWhite";
+            }>;
+            durationMs: z.ZodNumber;
+        }, z.core.$strip>>>;
+        agentRunId: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    totalCredits: z.ZodNumber;
+    breakdown: z.ZodArray<z.ZodObject<{
+        clipId: z.ZodString;
+        tier: z.ZodString;
+        source: z.ZodString;
+        credits: z.ZodNumber;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const estimateCostTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=estimateCost.tool.d.ts.map

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

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

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.estimateCostTool = void 0;
+const zod_1 = require("zod");
+const project_schema_1 = require("../../../schemas/project.schema");
+const toolRegistry_1 = require("../toolRegistry");
+const InputSchema = zod_1.z.object({
+    project: project_schema_1.ProjectSchema,
+});
+const OutputSchema = zod_1.z.object({
+    totalCredits: zod_1.z.number().nonnegative(),
+    breakdown: zod_1.z.array(zod_1.z.object({
+        clipId: zod_1.z.string(),
+        tier: zod_1.z.string(),
+        source: zod_1.z.string(),
+        credits: zod_1.z.number().nonnegative(),
+    })),
+});
+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.",
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    estimateCost: async () => 0,
+    handler: async ({ project }) => {
+        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 };
+        });
+        return {
+            totalCredits: breakdown.reduce((s, b) => s + b.credits, 0),
+            breakdown,
+        };
+    },
+};
+/**
+ * Rough per-second per-tier estimate, in credits. Refined later via aiModelConfigs
+ * lookups once tier annotations are backfilled across providers.
+ */
+function estimateFromTier(tier, display) {
+    const seconds = Math.max(0, (display.to - display.from) / 1000);
+    switch (tier) {
+        case "T0":
+            return 0;
+        case "T1":
+            return Math.ceil(seconds * 1);
+        case "T2":
+            return Math.ceil(seconds * 4);
+        case "T3":
+            return Math.ceil(seconds * 12);
+        default:
+            return Math.ceil(seconds * 4);
+    }
+}
+(0, toolRegistry_1.registerTool)(exports.estimateCostTool);

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

@@ -0,0 +1,32 @@
+import { z } from "zod";
+import { ToolDefinition } from "../toolRegistry";
+/**
+ * generate_avatar_video — wraps the existing kling-avatar pipeline so the
+ * planner's `talking-head-avatar` scene strategy is executable. Accepts a
+ * presenter face image URL plus either a pre-uploaded audio URL or raw TTS
+ * text (in which case the tool synthesizes via ElevenLabs and uploads to GCS
+ * before handing off, since Kling avatar requires a public sound_file URL).
+ *
+ * Returns a provider task id; the executor / monitor layer polls completion
+ * exactly as it does for generate_video.
+ */
+declare const InputSchema: z.ZodObject<{
+    inputImageUrl: z.ZodString;
+    ttsText: z.ZodOptional<z.ZodString>;
+    inputAudioUrl: z.ZodOptional<z.ZodString>;
+    voiceId: z.ZodOptional<z.ZodString>;
+    languageCode: z.ZodOptional<z.ZodString>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        std: "std";
+        pro: "pro";
+    }>>;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    status: z.ZodLiteral<"triggered">;
+    taskId: z.ZodString;
+    audioUrl: z.ZodString;
+}, z.core.$strip>;
+export declare const generateAvatarVideoTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=generateAvatarVideo.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateAvatarVideo.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/generateAvatarVideo.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;;;;;;GASG;AAEH,QAAA,MAAM,WAAW;;;;;;;;;;;iBAiCb,CAAC;AAEL,QAAA,MAAM,YAAY;;;;iBAIhB,CAAC;AAEH,eAAO,MAAM,uBAAuB,EAAE,cAAc,CAClD,OAAO,WAAW,EAClB,OAAO,YAAY,CA0DpB,CAAC"}

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

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAvatarVideoTool = void 0;
+const zod_1 = require("zod");
+const aiModels_1 = require("../../../globals/aiModels");
+const firebase_1 = require("../../../libs/firebase");
+const aiGenFactory_service_1 = require("../../aiGen/aiGenFactory.service");
+const types_1 = require("../../aiGen/types");
+const ttsFactory_service_1 = require("../../tts/ttsFactory.service");
+const toolRegistry_1 = require("../toolRegistry");
+/**
+ * generate_avatar_video — wraps the existing kling-avatar pipeline so the
+ * planner's `talking-head-avatar` scene strategy is executable. Accepts a
+ * presenter face image URL plus either a pre-uploaded audio URL or raw TTS
+ * text (in which case the tool synthesizes via ElevenLabs and uploads to GCS
+ * before handing off, since Kling avatar requires a public sound_file URL).
+ *
+ * Returns a provider task id; the executor / monitor layer polls completion
+ * exactly as it does for generate_video.
+ */
+const InputSchema = zod_1.z
+    .object({
+    inputImageUrl: zod_1.z
+        .string()
+        .url()
+        .describe("Presenter face still — Kling animates this image to lipsync the audio."),
+    ttsText: zod_1.z
+        .string()
+        .min(1)
+        .optional()
+        .describe("VO line to synthesize. Either ttsText or inputAudioUrl must be set; if both are set, inputAudioUrl wins."),
+    inputAudioUrl: zod_1.z
+        .string()
+        .url()
+        .optional()
+        .describe("Pre-uploaded audio URL (mp3/wav). Skips internal TTS+upload."),
+    voiceId: zod_1.z.string().optional(),
+    languageCode: zod_1.z.string().optional(),
+    mode: zod_1.z.enum(["std", "pro"]).default("std"),
+    prompt: zod_1.z
+        .string()
+        .optional()
+        .describe("Optional motion/emotion hint passed through to Kling."),
+})
+    .superRefine((v, ctx) => {
+    if (!v.ttsText && !v.inputAudioUrl) {
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: "Either ttsText or inputAudioUrl is required.",
+        });
+    }
+});
+const OutputSchema = zod_1.z.object({
+    status: zod_1.z.literal("triggered"),
+    taskId: zod_1.z.string(),
+    audioUrl: zod_1.z.string().url().describe("Audio URL fed to Kling — host can reuse for caption sync."),
+});
+exports.generateAvatarVideoTool = {
+    name: "generate_avatar_video",
+    description: [
+        "Generate a talking-head avatar video by animating a presenter face still",
+        "to lipsync a voiceover. Wraps the kling-avatar provider.",
+        "Use this for the `talking-head-avatar` scene strategy. Do NOT use it for",
+        "general motion shots — generate_video is cheaper and more flexible there.",
+        "Examples:",
+        '  { inputImageUrl: "https://.../face.png", ttsText: "Hi, today we\'re testing the new serum." }',
+        '  { inputImageUrl: "https://.../face.png", inputAudioUrl: "https://.../vo.mp3", mode: "pro" }',
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: false,
+    estimateCost: async (input) => {
+        // Kling avatar bills per audio second. Without a length we assume 6s (typical scene).
+        const approxSec = input.ttsText ? Math.max(2, Math.ceil(input.ttsText.length / 15)) : 6;
+        const perSec = input.mode === "pro" ? 0.028 : 0.014;
+        return Math.ceil(approxSec * perSec * 100); // rough credit conversion
+    },
+    handler: async (input, ctx) => {
+        let audioUrl = input.inputAudioUrl;
+        if (!audioUrl) {
+            const tts = (0, ttsFactory_service_1.getTtsProviderService)("elevenlabs");
+            const result = await tts.generate({
+                text: input.ttsText,
+                voiceId: input.voiceId,
+                languageCode: input.languageCode,
+            });
+            const filePath = `agent-avatar-audio/${ctx.userId}/${ctx.agentRunId}-${Date.now()}.${result.extension}`;
+            const file = (0, firebase_1.getBucket)().file(filePath);
+            await file.save(result.audioBuffer, { contentType: result.mimeType });
+            const [signedUrl] = await file.getSignedUrl({ action: "read", expires: "03-09-2491" });
+            audioUrl = signedUrl;
+        }
+        const provider = (0, aiGenFactory_service_1.getAiGenProviderService)(aiModels_1.EVideoGenModels.KLING_AVATAR);
+        const result = await provider.generateVideo({
+            modelKey: aiModels_1.EVideoGenModels.KLING_AVATAR,
+            prompt: input.prompt,
+            inputImageUrl: input.inputImageUrl,
+            inputAudioUrl: audioUrl,
+            mode: input.mode === "pro" ? types_1.EVideoMode.PROFESSIONAL : types_1.EVideoMode.STANDARD,
+            type: "image-to-video",
+        });
+        const taskId = result.task?.taskId ??
+            result.task?.id ??
+            (typeof result.task === "string" ? result.task : "unknown");
+        return {
+            status: "triggered",
+            taskId,
+            audioUrl: audioUrl,
+        };
+    },
+};
+(0, toolRegistry_1.registerTool)(exports.generateAvatarVideoTool);