vidspotai-shared 1.0.67 → 1.0.69-dev.0

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

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { EVideoGenModels } from "../../../globals/aiModels";
+import { ToolDefinition } from "../toolRegistry";
+declare const InputSchema: z.ZodObject<{
+    prompt: z.ZodString;
+    modelKey: z.ZodEnum<typeof EVideoGenModels>;
+    durationSec: z.ZodDefault<z.ZodNumber>;
+    aspectRatio: z.ZodDefault<z.ZodEnum<{
+        "9:16": "9:16";
+        "1:1": "1:1";
+        "16:9": "16:9";
+    }>>;
+    resolution: z.ZodOptional<z.ZodEnum<{
+        "720p": "720p";
+        "1080p": "1080p";
+        "4k": "4k";
+    }>>;
+    inputImageUrl: z.ZodOptional<z.ZodString>;
+    audio: z.ZodOptional<z.ZodBoolean>;
+    negativePrompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    status: z.ZodLiteral<"triggered">;
+    taskId: z.ZodString;
+    raw: z.ZodUnknown;
+    modelKeyUsed: z.ZodOptional<z.ZodString>;
+    attemptedProviders: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export declare const generateVideoTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=generateVideo.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateVideo.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/generateVideo.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAI5D,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AA4B/D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;iBA+Bf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;iBAOhB,CAAC;AAEH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAC5C,OAAO,WAAW,EAClB,OAAO,YAAY,CA0GpB,CAAC"}

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

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVideoTool = void 0;
+const zod_1 = require("zod");
+const aiModels_1 = require("../../../globals/aiModels");
+const logger_1 = require("../../../utils/logger");
+const aiGenFactory_service_1 = require("../../aiGen/aiGenFactory.service");
+const rateLimiter_1 = require("../../rateLimiter");
+const toolRegistry_1 = require("../toolRegistry");
+const chains_1 = require("../providerFallback/chains");
+const withFallback_1 = require("../providerFallback/withFallback");
+function pickChain(modelKey, isI2V) {
+    const isPremium = modelKey.startsWith("google-veo-3.1") ||
+        modelKey === aiModels_1.EVideoGenModels.KLING_V2_6 ||
+        modelKey === aiModels_1.EVideoGenModels.RUNWAY_GEN4_5 ||
+        modelKey === aiModels_1.EVideoGenModels.BYTEDANCE_SEEDANCE_2_0 ||
+        modelKey.startsWith("openai-sora");
+    if (isI2V)
+        return isPremium ? chains_1.T3_IMAGE_TO_VIDEO_CHAIN : chains_1.T2_IMAGE_TO_VIDEO_CHAIN;
+    return isPremium ? chains_1.T3_TEXT_TO_VIDEO_CHAIN : chains_1.T2_TEXT_TO_VIDEO_CHAIN;
+}
+const InputSchema = zod_1.z.object({
+    prompt: zod_1.z
+        .string()
+        .min(1)
+        .describe("Detailed motion + visual prompt. Describe subject, camera move, mood, lighting."),
+    modelKey: zod_1.z
+        .nativeEnum(aiModels_1.EVideoGenModels)
+        .describe("Pick by tier: T3 cinematic = google-veo-3.1, runway-gen4.5; balanced = kling-v2.6, bytedance-seedance-1.5-pro; cheap fast = minimax-hailuo-2.3-fast, pixverse-v5.6."),
+    durationSec: zod_1.z
+        .number()
+        .int()
+        .min(2)
+        .max(20)
+        .default(5)
+        .describe("Clip length in seconds (model-capped)."),
+    // AG-16: 4:5 removed — no video provider supports it.
+    aspectRatio: zod_1.z.enum(["9:16", "16:9", "1:1"]).default("9:16"),
+    resolution: zod_1.z.enum(["720p", "1080p", "4k"]).optional(),
+    inputImageUrl: zod_1.z
+        .string()
+        .url()
+        .optional()
+        .describe("Source image for image-to-video. If set, this is an animate_image-style call."),
+    audio: zod_1.z.boolean().optional().describe("Whether the model should generate audio."),
+    negativePrompt: zod_1.z.string().optional(),
+});
+const OutputSchema = zod_1.z.object({
+    status: zod_1.z.literal("triggered"),
+    taskId: zod_1.z.string().describe("Provider task id — pass to monitor/poll layer."),
+    raw: zod_1.z.unknown(),
+    /** Provider actually used (may differ from input.modelKey if fallback fired). */
+    modelKeyUsed: zod_1.z.string().optional(),
+    attemptedProviders: zod_1.z.array(zod_1.z.string()).optional(),
+});
+exports.generateVideoTool = {
+    name: "generate_video",
+    description: [
+        "Trigger AI video generation (T2 image-to-video or T3 text-to-video tier).",
+        "Returns immediately with a provider task id; the executor must poll status",
+        "via the existing job monitor — DO NOT block on completion in the tool.",
+        "Use sparingly: this is the most expensive tool. Prefer search_stock for",
+        "generic b-roll and animate_image (image-to-video) for product/scene shots",
+        "where a still + motion is enough.",
+        "Examples:",
+        '  { prompt: "slow dolly into a steaming espresso cup, warm light", modelKey: "kling-v2.6", durationSec: 5 }',
+        '  { prompt: "subject turns to camera, smiles", modelKey: "runway-gen4-turbo", inputImageUrl: "https://...", durationSec: 5 }',
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: false,
+    estimateCost: async (input) => {
+        // Rough per-second tier estimate; precise pricing comes from aiModelConfigs.
+        const isPremium = input.modelKey.startsWith("google-veo-3") ||
+            input.modelKey.startsWith("runway-gen4") ||
+            input.modelKey.startsWith("openai-sora");
+        return Math.ceil(input.durationSec * (isPremium ? 12 : 4));
+    },
+    handler: async (input) => {
+        const isI2V = Boolean(input.inputImageUrl);
+        const chain = (0, chains_1.buildVideoChain)(input.modelKey, pickChain(input.modelKey, isI2V));
+        const outcome = await (0, withFallback_1.withProviderFallback)({
+            providers: chain,
+            capable: (m) => (0, chains_1.isVideoModelCapable)(m, {
+                aspect: input.aspectRatio,
+                durationSec: input.durationSec,
+                type: isI2V ? "image-to-video" : "text-to-video",
+                lastFrame: false,
+                audio: input.audio,
+                hasInputImage: isI2V,
+            }),
+            onAttempt: (a) => {
+                if (a.classification) {
+                    logger_1.logger.warn("generate_video provider attempt failed", {
+                        provider: String(a.provider),
+                        classification: a.classification.classification,
+                        needsReplan: a.classification.needsReplan,
+                        err: a.classification.message,
+                        durationMs: a.durationMs,
+                    });
+                }
+            },
+            call: async (modelKey) => {
+                // Three-gate quota: in-process concurrent + Redis per-min + Redis
+                // per-day. Hold the slot through return — release happens in the
+                // host's TaskPoller when the task settles. On submit error / no
+                // taskId we release here so the fallback chain can re-acquire for
+                // the next provider attempt.
+                const limiter = (0, rateLimiter_1.getAiGenModelRateLimiter)(modelKey);
+                await limiter.waitUntilAvailable();
+                let heldSlot = true;
+                try {
+                    const provider = (0, aiGenFactory_service_1.getAiGenProviderService)(modelKey);
+                    const result = await provider.generateVideo({
+                        prompt: input.prompt,
+                        modelKey,
+                        duration: input.durationSec,
+                        aspectRatio: input.aspectRatio,
+                        resolution: input.resolution,
+                        inputImageUrl: input.inputImageUrl,
+                        audio: input.audio,
+                        negativePrompt: input.negativePrompt,
+                        type: isI2V ? "image-to-video" : "text-to-video",
+                    });
+                    const taskId = result.task?.taskId ??
+                        result.task?.id ??
+                        (typeof result.task === "string" ? result.task : "unknown");
+                    if (taskId === "unknown") {
+                        limiter.releaseSlot();
+                        heldSlot = false;
+                    }
+                    return { taskId, raw: result.task, modelKey };
+                }
+                catch (err) {
+                    if (heldSlot)
+                        limiter.releaseSlot();
+                    throw err;
+                }
+            },
+        });
+        if (!outcome.ok) {
+            throw new withFallback_1.ProviderFallbackExhaustedError(outcome.classification.classification, outcome.needsReplan, outcome.attempts.map((a) => String(a.provider)), `generate_video: chain exhausted (${outcome.classification.classification}): ${outcome.classification.message}`);
+        }
+        return {
+            status: "triggered",
+            taskId: outcome.value.taskId,
+            raw: outcome.value.raw,
+            modelKeyUsed: outcome.value.modelKey,
+            attemptedProviders: outcome.attempts.map((a) => String(a.provider)),
+        };
+    },
+};
+(0, toolRegistry_1.registerTool)(exports.generateVideoTool);

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

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { ToolDefinition } from "../toolRegistry";
+declare const InputSchema: z.ZodObject<{
+    text: z.ZodString;
+    provider: z.ZodDefault<z.ZodEnum<{
+        elevenlabs: "elevenlabs";
+        minimax: "minimax";
+        openai: "openai";
+    }>>;
+    voiceId: z.ZodOptional<z.ZodString>;
+    modelId: z.ZodOptional<z.ZodEnum<{
+        eleven_v3: "eleven_v3";
+        eleven_multilingual_v2: "eleven_multilingual_v2";
+        eleven_turbo_v2_5: "eleven_turbo_v2_5";
+        eleven_flash_v2_5: "eleven_flash_v2_5";
+    }>>;
+    languageCode: z.ZodOptional<z.ZodString>;
+    outputFormat: z.ZodOptional<z.ZodString>;
+    stability: z.ZodOptional<z.ZodNumber>;
+    similarityBoost: z.ZodOptional<z.ZodNumber>;
+    style: z.ZodOptional<z.ZodNumber>;
+    useSpeakerBoost: z.ZodOptional<z.ZodBoolean>;
+    speed: z.ZodOptional<z.ZodNumber>;
+    seed: z.ZodOptional<z.ZodNumber>;
+    previousText: z.ZodOptional<z.ZodString>;
+    nextText: z.ZodOptional<z.ZodString>;
+    previousRequestIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    nextRequestIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    applyTextNormalization: z.ZodOptional<z.ZodEnum<{
+        on: "on";
+        off: "off";
+        auto: "auto";
+    }>>;
+    applyLanguageTextNormalization: z.ZodOptional<z.ZodBoolean>;
+    optimizeStreamingLatency: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<0>, z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
+}, z.core.$strip>;
+declare const OutputSchema: z.ZodObject<{
+    audioBase64: z.ZodString;
+    mimeType: z.ZodString;
+    extension: z.ZodString;
+}, z.core.$strip>;
+export declare const generateVoiceoverTool: ToolDefinition<typeof InputSchema, typeof OutputSchema>;
+export {};
+//# sourceMappingURL=generateVoiceover.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"generateVoiceover.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/generateVoiceover.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAe/D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyHf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;iBAMhB,CAAC;AAEH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAChD,OAAO,WAAW,EAClB,OAAO,YAAY,CAwFpB,CAAC"}

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

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateVoiceoverTool = void 0;
+const zod_1 = require("zod");
+const voices_1 = require("../../../globals/ttsModels/voices");
+const assetCache_service_1 = require("../../assetCache.service");
+const rateLimiter_1 = require("../../rateLimiter");
+const ttsFactory_service_1 = require("../../tts/ttsFactory.service");
+const toolRegistry_1 = require("../toolRegistry");
+// Firestore docs are capped at ~1MB. Base64 inflates ~33%, so a 700KB
+// payload limit keeps us safely under for the doc + metadata. Anything
+// larger (long monologues at high bitrate) skips the cache write.
+const VO_CACHE_MAX_BYTES = 700000;
+// Surface the curated catalog inline so the LLM sees the full voice menu
+// (id + name + accent + persona) in the tool description without having to
+// call a separate listing tool. Cheap on tokens — ~20 voices, ~1 line each.
+const ELEVENLABS_VOICE_MENU = voices_1.ELEVENLABS_VOICES.map((v) => `  ${v.id}  — ${v.name} (${v.gender}, ${v.accent}${v.age ? `, ${v.age}` : ""}) — ${v.persona ?? ""}`).join("\n");
+const InputSchema = zod_1.z.object({
+    text: zod_1.z.string().min(1).describe("VO line to synthesize. One scene's worth."),
+    provider: zod_1.z
+        .enum(["elevenlabs", "openai", "minimax"])
+        .default("elevenlabs")
+        .describe("TTS provider. elevenlabs = best quality + style control; openai = cheap/fast; minimax = strong multilingual."),
+    voiceId: zod_1.z
+        .string()
+        .optional()
+        .describe("Provider-specific voice id. Omit to use the project default; the brand kit's voice id is auto-injected by the executor. " +
+        `Available ElevenLabs voice ids:\n${ELEVENLABS_VOICE_MENU}`),
+    modelId: zod_1.z
+        .enum([
+        "eleven_v3",
+        "eleven_multilingual_v2",
+        "eleven_turbo_v2_5",
+        "eleven_flash_v2_5",
+    ])
+        .optional()
+        .describe("ElevenLabs model. v3 = best quality + style + 70+ langs (slower); multilingual_v2 = stable workhorse; turbo_v2_5 = ~3-5× faster (preview/draft); flash_v2_5 = lowest latency for real-time."),
+    languageCode: zod_1.z
+        .string()
+        .optional()
+        .describe('Locale, e.g. "en", "fr-FR". Omit to let the model auto-detect.'),
+    outputFormat: zod_1.z
+        .string()
+        .optional()
+        .describe('ElevenLabs output container/codec, e.g. "mp3_44100_192" (best mp3), "pcm_24000" (raw 24kHz pcm), "opus_48000_128". Default: mp3_44100_128.'),
+    // ── voice_settings ──────────────────────────────────────────────────
+    stability: zod_1.z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("ElevenLabs voice_settings.stability (0–1). Lower = more emotive/varied; higher = more consistent/monotone. Default 0.5."),
+    similarityBoost: zod_1.z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("ElevenLabs voice_settings.similarity_boost (0–1). Higher = closer to source voice's timbre. Default 0.75."),
+    style: zod_1.z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe("ElevenLabs voice_settings.style — exaggeration (0–1). 0 = neutral; >0 amplifies the voice's signature delivery (use sparingly above 0.5 — can introduce artifacts)."),
+    useSpeakerBoost: zod_1.z
+        .boolean()
+        .optional()
+        .describe("ElevenLabs voice_settings.use_speaker_boost — boosts perceived similarity (small latency cost)."),
+    speed: zod_1.z
+        .number()
+        .min(0.7)
+        .max(1.2)
+        .optional()
+        .describe("ElevenLabs voice_settings.speed (0.7–1.2). 1.0 = natural pace. <1 slows down, >1 speeds up."),
+    // ── continuity / determinism ────────────────────────────────────────
+    seed: zod_1.z
+        .number()
+        .int()
+        .min(0)
+        .max(4294967295)
+        .optional()
+        .describe("Deterministic re-render seed when supported (ElevenLabs)."),
+    previousText: zod_1.z
+        .string()
+        .optional()
+        .describe("Preceding scene's VO text — prosody continuity hint (ElevenLabs)."),
+    nextText: zod_1.z
+        .string()
+        .optional()
+        .describe("Following scene's VO text — prosody continuity hint (ElevenLabs)."),
+    previousRequestIds: zod_1.z
+        .array(zod_1.z.string())
+        .max(3)
+        .optional()
+        .describe("Up to 3 ElevenLabs request ids of preceding generations. Strongest cross-scene continuity (better than previousText)."),
+    nextRequestIds: zod_1.z
+        .array(zod_1.z.string())
+        .max(3)
+        .optional()
+        .describe("Up to 3 ElevenLabs request ids of following generations."),
+    // ── text normalization ──────────────────────────────────────────────
+    applyTextNormalization: zod_1.z
+        .enum(["auto", "on", "off"])
+        .optional()
+        .describe('Whether to spell out numbers / symbols. "auto" (default) lets the model decide; "off" passes text verbatim (use for SSML-style tags or pre-normalised input).'),
+    applyLanguageTextNormalization: zod_1.z
+        .boolean()
+        .optional()
+        .describe("Apply language-specific normalisation. Currently effective for Japanese only."),
+    // ── streaming / latency ─────────────────────────────────────────────
+    optimizeStreamingLatency: zod_1.z
+        .union([zod_1.z.literal(0), zod_1.z.literal(1), zod_1.z.literal(2), zod_1.z.literal(3), zod_1.z.literal(4)])
+        .optional()
+        .describe("0 (default, best quality) → 4 (max speed, disables normaliser). Use 3–4 only for live/preview where latency dominates."),
+});
+const OutputSchema = zod_1.z.object({
+    audioBase64: zod_1.z
+        .string()
+        .describe("Base64-encoded audio bytes — host uploads to GCS and swaps for url."),
+    mimeType: zod_1.z.string(),
+    extension: zod_1.z.string(),
+});
+exports.generateVoiceoverTool = {
+    name: "generate_voiceover",
+    description: [
+        "Generate a TTS voiceover line. One call per scene; do NOT batch multi-scene",
+        "scripts in one call — per-scene calls give the editor clean cut points and",
+        "the asset cache deduplicates retries.",
+        "Examples:",
+        '  { text: "Try our new vitamin C serum — visibly brighter in 7 days." }',
+        '  { text: "Bonjour", languageCode: "fr-FR" }',
+    ].join(" "),
+    inputSchema: InputSchema,
+    outputSchema: OutputSchema,
+    idempotent: true,
+    estimateCost: async (input) => Math.max(1, Math.ceil(input.text.length / 200)),
+    handler: async (input) => {
+        const cacheParts = {
+            provider: `tts:${input.provider}`,
+            kind: "voiceover",
+            input: {
+                text: input.text,
+                voiceId: input.voiceId,
+                modelId: input.modelId,
+                languageCode: input.languageCode,
+                outputFormat: input.outputFormat,
+                stability: input.stability,
+                similarityBoost: input.similarityBoost,
+                style: input.style,
+                useSpeakerBoost: input.useSpeakerBoost,
+                speed: input.speed,
+                seed: input.seed,
+                applyTextNormalization: input.applyTextNormalization,
+                applyLanguageTextNormalization: input.applyLanguageTextNormalization,
+            },
+            // Continuity hints (previousText/nextText, request ids) and streaming
+            // latency are deliberately excluded from the cache key — they don't
+            // change deterministic output meaningfully and keying on them would
+            // evict otherwise-identical generations.
+        };
+        const hit = await assetCache_service_1.RawAssetCacheService.lookup(cacheParts);
+        if (hit)
+            return hit;
+        const provider = (0, ttsFactory_service_1.getTtsProviderService)(input.provider);
+        // Synchronous TTS call — slot released on return. Per-min consumption
+        // is durable in Redis so the per-minute cap holds across restarts.
+        const limiter = (0, rateLimiter_1.getTtsProviderRateLimiter)(input.provider);
+        await limiter.waitUntilAvailable();
+        let result;
+        try {
+            result = await provider.generate({
+                text: input.text,
+                voiceId: input.voiceId,
+                modelIdOverride: input.modelId,
+                languageCode: input.languageCode,
+                outputFormat: input.outputFormat,
+                stability: input.stability,
+                similarityBoost: input.similarityBoost,
+                style: input.style,
+                useSpeakerBoost: input.useSpeakerBoost,
+                speed: input.speed,
+                seed: input.seed,
+                previousText: input.previousText,
+                nextText: input.nextText,
+                previousRequestIds: input.previousRequestIds,
+                nextRequestIds: input.nextRequestIds,
+                applyTextNormalization: input.applyTextNormalization,
+                applyLanguageTextNormalization: input.applyLanguageTextNormalization,
+                optimizeStreamingLatency: input.optimizeStreamingLatency,
+            });
+        }
+        finally {
+            limiter.releaseSlot();
+        }
+        const payload = {
+            audioBase64: result.audioBuffer.toString("base64"),
+            mimeType: result.mimeType,
+            extension: result.extension,
+        };
+        if (payload.audioBase64.length <= VO_CACHE_MAX_BYTES) {
+            void assetCache_service_1.RawAssetCacheService.store(cacheParts, payload).catch(() => undefined);
+        }
+        return payload;
+    },
+};
+(0, toolRegistry_1.registerTool)(exports.generateVoiceoverTool);

package/lib/services/agent/tools/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Importing this file registers every built-in tool with the toolRegistry.
+ * Host apps (Express server, Firebase Functions) import this once at boot.
+ */
+export * from "./searchStock.tool";
+export * from "./generateImage.tool";
+export * from "./generateVideo.tool";
+export * from "./generateVoiceover.tool";
+export * from "./generateCaptions.tool";
+export * from "./animateImage.tool";
+export * from "./animateImageWithMotionBrush.tool";
+export * from "./generateAvatarVideo.tool";
+export * from "./planVideo.tool";
+export * from "./composeScene.tool";
+export * from "./render.tool";
+export * from "./analyzeReference.tool";
+export * from "./searchUserLibrary.tool";
+export * from "./searchMusic.tool";
+export * from "./estimateCost.tool";
+//# sourceMappingURL=index.d.ts.map

package/lib/services/agent/tools/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC"}

package/lib/services/agent/tools/index.js

@@ -0,0 +1,35 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Importing this file registers every built-in tool with the toolRegistry.
+ * Host apps (Express server, Firebase Functions) import this once at boot.
+ */
+__exportStar(require("./searchStock.tool"), exports);
+__exportStar(require("./generateImage.tool"), exports);
+__exportStar(require("./generateVideo.tool"), exports);
+__exportStar(require("./generateVoiceover.tool"), exports);
+__exportStar(require("./generateCaptions.tool"), exports);
+__exportStar(require("./animateImage.tool"), exports);
+__exportStar(require("./animateImageWithMotionBrush.tool"), exports);
+__exportStar(require("./generateAvatarVideo.tool"), exports);
+__exportStar(require("./planVideo.tool"), exports);
+__exportStar(require("./composeScene.tool"), exports);
+__exportStar(require("./render.tool"), exports);
+__exportStar(require("./analyzeReference.tool"), exports);
+__exportStar(require("./searchUserLibrary.tool"), exports);
+__exportStar(require("./searchMusic.tool"), exports);
+__exportStar(require("./estimateCost.tool"), exports);