vidspotai-shared 1.0.69-dev.0 → 1.0.69

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,352 +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";
-            "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

@@ -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<{
-        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

@@ -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;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"}