vidspotai-shared 1.0.55 → 1.0.56

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

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

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

@@ -1,342 +0,0 @@
-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

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

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

@@ -1,32 +0,0 @@
-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

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

@@ -1,112 +0,0 @@
-"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);