vidspotai-shared 1.0.68 → 1.0.69-dev.0

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,352 @@
+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";
+            "1:1": "1:1";
+            "4:5": "4:5";
+            "16:9": "16:9";
+        }>;
+        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<{
+                text: "text";
+                audio: "audio";
+                video: "video";
+                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";
+                right: "right";
+                center: "center";
+            }>>;
+            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;
+            direction: z.ZodOptional<z.ZodEnum<{
+                "from-left": "from-left";
+                "from-top-left": "from-top-left";
+                "from-top": "from-top";
+                "from-top-right": "from-top-right";
+                "from-right": "from-right";
+                "from-bottom-right": "from-bottom-right";
+                "from-bottom": "from-bottom";
+                "from-bottom-left": "from-bottom-left";
+            }>>;
+        }, 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<{
+        pro: "pro";
+        std: "std";
+    }>>;
+    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;AAUxB,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,CAoFpB,CAAC"}