vidspotai-shared 1.0.67 → 1.0.69-dev.0

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

@@ -0,0 +1,367 @@
+import { z } from "zod";
+import { ProjectSchema } from "../../../schemas/project.schema";
+import { ToolDefinition } from "../toolRegistry";
+/**
+ * The actual render enqueue logic lives in the host (BullMQ + Remotion Lambda
+ * / local renderer). The tool layer is host-agnostic, so the host injects an
+ * enqueue function at boot.
+ */
+export type RenderEnqueueFn = (input: {
+    userId: string;
+    agentRunId: string;
+    project: z.infer<typeof ProjectSchema>;
+    quality: "draft" | "standard" | "premium";
+}) => Promise<{
+    renderJobId: string;
+}>;
+export declare function setRenderEnqueueFn(fn: RenderEnqueueFn): void;
+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>;
+    quality: z.ZodDefault<z.ZodEnum<{
+        standard: "standard";
+        draft: "draft";
+        premium: "premium";
+    }>>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    renderJobId: z.ZodString;
+    status: z.ZodLiteral<"queued">;
+}, z.core.$strip>;
+export declare const renderTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=render.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"render.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/render.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAC;AAChE,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D;;;;GAIG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IACvC,OAAO,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CAAC;CAC3C,KAAK,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAGvC,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,eAAe,GAAG,IAAI,CAE5D;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQf,CAAC;AAEH,QAAA,MAAM,YAAY;;;iBAGhB,CAAC;AAEH,eAAO,MAAM,UAAU,EAAE,cAAc,CACrC,OAAO,WAAW,EAClB,OAAO,YAAY,CA2BpB,CAAC"}

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTool = void 0;
+exports.setRenderEnqueueFn = setRenderEnqueueFn;
+const zod_1 = require("zod");
+const project_schema_1 = require("../../../schemas/project.schema");
+const toolRegistry_1 = require("../toolRegistry");
+let injectedEnqueue = null;
+function setRenderEnqueueFn(fn) {
+    injectedEnqueue = fn;
+}
+const InputSchema = zod_1.z.object({
+    project: project_schema_1.ProjectSchema,
+    quality: zod_1.z
+        .enum(["draft", "standard", "premium"])
+        .default("standard")
+        .describe("draft = 720p fast preview, standard = 1080p normal, premium = 1080p with denoise + audio polish."),
+});
+const OutputSchema = zod_1.z.object({
+    renderJobId: zod_1.z.string(),
+    status: zod_1.z.literal("queued"),
+});
+exports.renderTool = {
+    name: "render",
+    description: [
+        "Enqueue a final render of the Project JSON. Returns a renderJobId; the",
+        "host UI subscribes for status. Call ONCE per agent run, only after the",
+        "critic has approved the project (or the user has explicitly accepted it).",
+        "Do NOT call render after compose_scene as a way to preview — use a",
+        "thumbnail/preview tool for that (separate, cheaper).",
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: false,
+    handler: async (input, ctx) => {
+        if (!injectedEnqueue) {
+            throw new Error("render: no enqueue fn wired. Host must call setRenderEnqueueFn() at boot.");
+        }
+        const { renderJobId } = await injectedEnqueue({
+            userId: ctx.userId,
+            agentRunId: ctx.agentRunId,
+            project: input.project,
+            quality: input.quality,
+        });
+        return { renderJobId, status: "queued" };
+    },
+};
+(0, toolRegistry_1.registerTool)(exports.renderTool);

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

@@ -0,0 +1,49 @@
+import { z } from "zod";
+import { ToolDefinition } from "../toolRegistry";
+declare const InputSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    mood: z.ZodOptional<z.ZodEnum<{
+        energetic: "energetic";
+        calm: "calm";
+        cinematic: "cinematic";
+        uplifting: "uplifting";
+        dark: "dark";
+        acoustic: "acoustic";
+        retro: "retro";
+        quirky: "quirky";
+    }>>;
+    bpmTarget: z.ZodOptional<z.ZodNumber>;
+    bpmMin: z.ZodOptional<z.ZodNumber>;
+    bpmMax: z.ZodOptional<z.ZodNumber>;
+    durationSecMin: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodOptional<z.ZodEnum<{
+        curated: "curated";
+        jamendo: "jamendo";
+        mubert: "mubert";
+    }>>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    tracks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        url: z.ZodString;
+        durationSec: z.ZodNumber;
+        bpm: z.ZodOptional<z.ZodNumber>;
+        mood: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        attribution: z.ZodOptional<z.ZodString>;
+        source: z.ZodEnum<{
+            curated: "curated";
+            jamendo: "jamendo";
+            mubert: "mubert";
+        }>;
+    }, z.core.$strip>>;
+    sourceUsed: z.ZodOptional<z.ZodEnum<{
+        curated: "curated";
+        jamendo: "jamendo";
+        mubert: "mubert";
+    }>>;
+}, z.core.$strip>;
+export declare const searchMusicTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=searchMusic.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"searchMusic.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/searchMusic.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE/D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;iBA0Bf,CAAC;AAaH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;iBAGhB,CAAC;AAEH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,WAAW,EAAE,OAAO,YAAY,CA2BnF,CAAC"}

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchMusicTool = void 0;
+const zod_1 = require("zod");
+const musicGen_1 = require("../../musicGen");
+const toolRegistry_1 = require("../toolRegistry");
+const InputSchema = zod_1.z.object({
+    query: zod_1.z.string().optional().describe("Free-text query — track name, vibe, or instrument."),
+    mood: zod_1.z
+        .enum(["energetic", "cinematic", "calm", "uplifting", "dark", "acoustic", "retro", "quirky"])
+        .optional()
+        .describe("Mood tag — maps to provider-specific tag bundles."),
+    bpmTarget: zod_1.z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe("Soft target — providers prefer matches near this BPM. Set when persona uses beat-cut pacing."),
+    bpmMin: zod_1.z.number().int().positive().optional(),
+    bpmMax: zod_1.z.number().int().positive().optional(),
+    durationSecMin: zod_1.z
+        .number()
+        .positive()
+        .optional()
+        .describe("Track must be at least this long so it covers the whole video."),
+    source: zod_1.z
+        .enum(["curated", "jamendo", "mubert"])
+        .optional()
+        .describe("Force a specific source. Omit to walk priority order (curated → jamendo → mubert). Use 'mubert' only when the user pays for premium tier — it generates and bills per call."),
+    limit: zod_1.z.number().int().min(1).max(20).default(5),
+});
+const TrackSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    url: zod_1.z.string().url(),
+    durationSec: zod_1.z.number(),
+    bpm: zod_1.z.number().optional(),
+    mood: zod_1.z.string().optional(),
+    tags: zod_1.z.array(zod_1.z.string()).optional(),
+    attribution: zod_1.z.string().optional(),
+    source: zod_1.z.enum(["curated", "jamendo", "mubert"]),
+});
+const OutputSchema = zod_1.z.object({
+    tracks: zod_1.z.array(TrackSchema),
+    sourceUsed: zod_1.z.enum(["curated", "jamendo", "mubert"]).optional(),
+});
+exports.searchMusicTool = {
+    name: "search_music",
+    description: [
+        "Find a music track for the video. Returns URL + BPM + duration so the",
+        "beat-snap pass and onset-detection pass have something concrete to work with.",
+        "Three sources behind one tool:",
+        "  - curated: ~50 hand-picked CC0 tracks (zero-cost, always available)",
+        "  - jamendo: huge library, BPM-tagged; commercial use needs Pro license",
+        "  - mubert: generates a custom track from prompt+BPM (paid per call)",
+        "Default: walk priority order (curated → jamendo → mubert) and return first hit.",
+        "Examples:",
+        '  { mood: "energetic", bpmTarget: 120, durationSecMin: 30 }',
+        '  { query: "warm acoustic guitar", source: "curated" }',
+        '  { mood: "cinematic", bpmTarget: 90, source: "mubert" }  // premium only',
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    estimateCost: async (input) => (input.source === "mubert" ? 5 : 0),
+    handler: async (input) => {
+        if (input.source) {
+            const provider = (0, musicGen_1.getMusicSearchProvider)(input.source);
+            const result = await provider.search(input);
+            return { tracks: result.tracks, sourceUsed: input.source };
+        }
+        const result = await (0, musicGen_1.searchAllMusicSources)(input);
+        return result;
+    },
+};
+(0, toolRegistry_1.registerTool)(exports.searchMusicTool);

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

@@ -0,0 +1,41 @@
+import { z } from "zod";
+import { ToolDefinition } from "../toolRegistry";
+/** Test-only: clear all per-run dedup state. */
+export declare function _clearStockDedupForTesting(): void;
+declare const InputSchema: z.ZodObject<{
+    query: z.ZodString;
+    kind: z.ZodEnum<{
+        image: "image";
+        video: "video";
+    }>;
+    aspectRatio: z.ZodOptional<z.ZodEnum<{
+        "9:16": "9:16";
+        "1:1": "1:1";
+        "4:5": "4:5";
+        "16:9": "16:9";
+    }>>;
+    minDurationSec: z.ZodOptional<z.ZodNumber>;
+    maxDurationSec: z.ZodOptional<z.ZodNumber>;
+    perPage: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    assets: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        url: z.ZodString;
+        thumbnailUrl: z.ZodOptional<z.ZodString>;
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+        durationSec: z.ZodOptional<z.ZodNumber>;
+        source: z.ZodString;
+        attribution: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            url: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        trackingUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    totalAvailable: z.ZodOptional<z.ZodNumber>;
+    attemptedProviders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const searchStockTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=searchStock.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"searchStock.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/searchStock.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,OAAO,EAA6B,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAgE5E,gDAAgD;AAChD,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;iBAuBf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;iBAuChB,CAAC;AA8EH,eAAO,MAAM,eAAe,EAAE,cAAc,CAC1C,OAAO,WAAW,EAClB,OAAO,YAAY,CA8JpB,CAAC"}