vidspotai-shared 1.0.69-dev.0 → 1.0.69

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

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

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

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

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

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

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

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

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