vidspotai-shared 1.0.124 → 1.0.125

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

@@ -5,6 +5,8 @@ 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 cameraDirection_1 = require("../../aiGen/canonicalAdapters/cameraDirection");
+const videoPlan_schema_1 = require("../../../schemas/videoPlan.schema");
 const rateLimiter_1 = require("../../rateLimiter");
 const toolRegistry_1 = require("../toolRegistry");
 const chains_1 = require("../providerFallback/chains");
@@ -14,8 +16,9 @@ function pickChain(modelKey, isI2V) {
         modelKey === aiModels_1.EVideoGenModels.KLING_V2_6 ||
         modelKey === aiModels_1.EVideoGenModels.RUNWAY_GEN4_5 ||
         modelKey === aiModels_1.EVideoGenModels.BYTEDANCE_SEEDANCE_2_5 ||
-        modelKey === aiModels_1.EVideoGenModels.BYTEDANCE_SEEDANCE_2_0 ||
-        modelKey.startsWith("openai-sora");
+        modelKey === aiModels_1.EVideoGenModels.BYTEDANCE_SEEDANCE_2_0;
+    // REMOVED FOR v2 — kept for reference: Sora 2 shut down upstream 2026-09-24.
+    // || 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;
@@ -51,11 +54,20 @@ const InputSchema = zod_1.z.object({
         "animates FROM inputImageUrl (first frame) TO this image (last frame), the " +
         "cleanest way to get reliable directed motion between two specific " +
         "compositions. REQUIRES inputImageUrl (the first frame). Only " +
-        "FLF-capable models accept it (google-veo-3.1/-fast, kling, runway-gen4-turbo, " +
-        "alibaba-wan); the capability gate skips models that don't, and the chain " +
+        "FLF-capable models accept it (google-veo-3.1/-fast, kling, alibaba-wan); the capability gate skips models that don't, and the chain " +
         "falls back. Omit for normal single-image animation."),
     audio: zod_1.z.boolean().optional().describe("Whether the model should generate audio."),
     negativePrompt: zod_1.z.string().optional(),
+    cameraControl: videoPlan_schema_1.CameraControlSchema.optional().describe("Camera move (preset like dolly_in / pan_left / orbit_right / static, optional 0..1 intensity). " +
+        "Translated per model: MiniMax [Pan left] commands, a camera sentence in the prompt elsewhere."),
+    referenceImageUrls: zod_1.z
+        .array(zod_1.z.string().url())
+        .max(9)
+        .optional()
+        .describe("Identity / style reference images (NOT the first frame) — a character or product the clip " +
+        "must show. Models that take refs natively (google-veo-3.1 ≤3, kling-video-o1 / kling-v3-omni-video ≤7) " +
+        "are tried first; a fallback without ref support drops them."),
+    seed: zod_1.z.number().int().optional(),
 });
 const OutputSchema = zod_1.z.object({
     status: zod_1.z.literal("triggered"),
@@ -84,8 +96,9 @@ exports.generateVideoTool = {
     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");
+            input.modelKey.startsWith("runway-gen4");
+        // REMOVED FOR v2 — kept for reference: Sora 2 shut down upstream 2026-09-24.
+        // || input.modelKey.startsWith("openai-sora");
         return Math.ceil(input.durationSec * (isPremium ? 12 : 4));
     },
     handler: async (input) => {
@@ -97,7 +110,10 @@ exports.generateVideoTool = {
             logger_1.logger.warn("generate_video: lastFrameImageUrl ignored — no inputImageUrl (first frame) supplied", { modelKey: input.modelKey });
         }
         const lastFrameImageUrl = isI2V ? input.lastFrameImageUrl : undefined;
-        const chain = (0, chains_1.buildVideoChain)(input.modelKey, pickChain(input.modelKey, isI2V));
+        const refs = input.referenceImageUrls ?? [];
+        // Reference images are a soft capability: a model that takes them goes
+        // first, one that doesn't stays in the chain as a last resort.
+        const chain = (0, chains_1.rankVideoChainByPreference)((0, chains_1.buildVideoChain)(input.modelKey, pickChain(input.modelKey, isI2V)), { referenceImages: refs.length });
         const outcome = await (0, withFallback_1.withProviderFallback)({
             providers: chain,
             capable: (m) => (0, chains_1.isVideoModelCapable)(m, {
@@ -130,7 +146,14 @@ exports.generateVideoTool = {
                 let heldSlot = true;
                 try {
                     const provider = (0, aiGenFactory_service_1.getAiGenProviderService)(modelKey);
-                    const result = await provider.generateVideo({
+                    const refLimit = (0, chains_1.modelReferenceImageLimit)(modelKey);
+                    if (refs.length && refLimit === 0) {
+                        logger_1.logger.warn("generate_video: model takes no reference images — dropping them", {
+                            modelKey,
+                            dropped: refs.length,
+                        });
+                    }
+                    const result = await provider.generateVideo((0, cameraDirection_1.applyCameraDirection)({
                         prompt: input.prompt,
                         modelKey,
                         duration: input.durationSec,
@@ -140,8 +163,13 @@ exports.generateVideoTool = {
                         lastFrameImageUrl,
                         audio: input.audio,
                         negativePrompt: input.negativePrompt,
+                        seed: input.seed,
+                        cameraControl: input.cameraControl,
+                        ...(refs.length && refLimit > 0
+                            ? { referenceImageUrls: refs.slice(0, refLimit) }
+                            : {}),
                         type: isI2V ? "image-to-video" : "text-to-video",
-                    });
+                    }));
                     const taskId = result.task?.taskId ??
                         result.task?.id ??
                         (typeof result.task === "string" ? result.task : "unknown");

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

@@ -315,6 +315,25 @@ declare const OutputSchema: z.ZodObject<{
             characterAnchorSceneIndex: z.ZodOptional<z.ZodNumber>;
             bibleEntityIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
             lastFramePrompt: z.ZodOptional<z.ZodString>;
+            cameraPreset: z.ZodOptional<z.ZodEnum<{
+                static: "static";
+                pan_left: "pan_left";
+                pan_right: "pan_right";
+                tilt_up: "tilt_up";
+                tilt_down: "tilt_down";
+                zoom_in: "zoom_in";
+                zoom_out: "zoom_out";
+                dolly_in: "dolly_in";
+                dolly_out: "dolly_out";
+                orbit_left: "orbit_left";
+                orbit_right: "orbit_right";
+                roll_left: "roll_left";
+                roll_right: "roll_right";
+                tracking: "tracking";
+                handheld: "handheld";
+                push_in: "push_in";
+                pull_out: "pull_out";
+            }>>;
             allowTrailingSilence: z.ZodOptional<z.ZodBoolean>;
             layout: z.ZodOptional<z.ZodObject<{
                 composition: z.ZodEnum<{

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

@@ -1 +1 @@
-{"version":3,"file":"planVideo.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/planVideo.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAQ/D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAExD;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEhB,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,cAAc,CACxC,OAAO,WAAW,EAClB,OAAO,YAAY,CAuBpB,CAAC"}
+{"version":3,"file":"planVideo.tool.d.ts","sourceRoot":"","sources":["../../../../src/services/agent/tools/planVideo.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAEzC,OAAO,EAAgB,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAQ/D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAExD;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIf,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAEhB,CAAC;AAEH,eAAO,MAAM,aAAa,EAAE,cAAc,CACxC,OAAO,WAAW,EAClB,OAAO,YAAY,CAuBpB,CAAC"}

package/lib/services/aiGen/aiGenFactory.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aiGenFactory.service.d.ts","sourceRoot":"","sources":["../../../src/services/aiGen/aiGenFactory.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EACL,iBAAiB,EAEjB,eAAe,EACf,aAAa,EACb,cAAc,EACd,qBAAqB,EAErB,qBAAqB,EAErB,eAAe,EACf,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAehC,KAAK,uBAAuB,GAAG,UAAU,wBAAwB,CAAC;AASlE,eAAO,MAAM,gBAAgB,EAAE,OAAO,CACpC,MAAM,CAAC,eAAe,EAAE,uBAAuB,CAAC,CAkEjD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,iBAAiB,EACjB,uBAAuB,CA2CxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,eAAe,EACf,uBAAuB,CAMxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,aAAa,EACb,uBAAuB,CAGxB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,uBAAuB,CAsBzE,CAAC;AAEJ;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,qBAAqB,EACrB,uBAAuB,CAGxB,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,qBAAqB,EACrB,uBAAuB,CAGxB,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,qBAAqB,GAC9B,wBAAwB,CAM1B;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,qBAAqB,GAC9B,wBAAwB,CAM1B;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,WAAW,GACpB,wBAAwB,CAmB1B"}
+{"version":3,"file":"aiGenFactory.service.d.ts","sourceRoot":"","sources":["../../../src/services/aiGen/aiGenFactory.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACjF,OAAO,EACL,iBAAiB,EAEjB,eAAe,EACf,aAAa,EACb,cAAc,EACd,qBAAqB,EAErB,qBAAqB,EAErB,eAAe,EACf,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAgBhC,KAAK,uBAAuB,GAAG,UAAU,wBAAwB,CAAC;AASlE,eAAO,MAAM,gBAAgB,EAAE,OAAO,CACpC,MAAM,CAAC,eAAe,EAAE,uBAAuB,CAAC,CA+FjD,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,iBAAiB,EACjB,uBAAuB,CAsDxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CACnC,eAAe,EACf,uBAAuB,CAMxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CACjC,aAAa,EACb,uBAAuB,CAGxB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,cAAc,EAAE,uBAAuB,CAsBzE,CAAC;AAEJ;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,qBAAqB,EACrB,uBAAuB,CAGxB,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAC1C,qBAAqB,EACrB,uBAAuB,CAGxB,CAAC;AAEF,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,qBAAqB,GAC9B,wBAAwB,CAM1B;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,qBAAqB,GAC9B,wBAAwB,CAM1B;AAED,wBAAgB,uBAAuB,CACrC,QAAQ,EAAE,WAAW,GACpB,wBAAwB,CAmB1B"}

package/lib/services/aiGen/aiGenFactory.service.js

@@ -17,6 +17,7 @@ const bytedance_service_1 = require("./providers/bytedance/bytedance.service");
 const elevenlabs_service_1 = require("./providers/elevenlabs/elevenlabs.service");
 const anthropic_service_1 = require("./providers/anthropic/anthropic.service");
 const falUpscale_service_1 = require("./providers/fal/falUpscale.service");
+const xai_service_1 = require("./providers/xai/xai.service");
 // Partial, intentionally: hosted avatar engines (heygen-avatar, tavus-avatar)
 // are NOT generic video models — they're handled by the dedicated avatar seam
 // (getAvatarVideoProvider / IAvatarVideoProvider). getAiGenProviderService gates
@@ -26,10 +27,12 @@ const falUpscale_service_1 = require("./providers/fal/falUpscale.service");
 // KlingAvatarProvider adapter.)
 exports.videoServicesMap = {
     // --- Pixverse ---
+    "pixverse-c1": pixverse_service_1.PixVerseService,
     "pixverse-v6": pixverse_service_1.PixVerseService,
     "pixverse-v5.6": pixverse_service_1.PixVerseService,
     "pixverse-v5.5": pixverse_service_1.PixVerseService,
     "pixverse-v5": pixverse_service_1.PixVerseService,
+    "pixverse-lipsync": pixverse_service_1.PixVerseService,
     // --- ByteDance ---
     "bytedance-seedance-1.5-pro": bytedance_service_1.ByteDanceService,
     "bytedance-seedance-1.0-pro-fast": bytedance_service_1.ByteDanceService,
@@ -39,9 +42,12 @@ exports.videoServicesMap = {
     "bytedance-seedance-2.0-fast": bytedance_service_1.ByteDanceService,
     "bytedance-seedance-2.0-mini": bytedance_service_1.ByteDanceService,
     // --- Google ---
+    "google-gemini-omni-flash": google_service_1.GoogleService,
     "google-veo-3.1": google_service_1.GoogleService,
     "google-veo-3.1-fast": google_service_1.GoogleService,
     "google-veo-3.1-lite": google_service_1.GoogleService,
+    // Veo 3.0 shut down 2026-06-30 (no config → rejected at the API edge); the
+    // mapping stays only so historical job docs still resolve a provider.
     "google-veo-3": google_service_1.GoogleService,
     "google-veo-3-fast": google_service_1.GoogleService,
     "google-veo-2": google_service_1.GoogleService,
@@ -49,6 +55,18 @@ exports.videoServicesMap = {
     "runway-gen4.5": runway_service_1.RunwayService,
     "runway-gen4-turbo": runway_service_1.RunwayService,
     "runway-gen4-aleph": runway_service_1.RunwayService,
+    "runway-wan3": runway_service_1.RunwayService,
+    "runway-seedance2.5": runway_service_1.RunwayService,
+    "runway-seedance2": runway_service_1.RunwayService,
+    "runway-seedance2-fast": runway_service_1.RunwayService,
+    "runway-seedance2-mini": runway_service_1.RunwayService,
+    "runway-grok-imagine-1.5": runway_service_1.RunwayService,
+    "runway-h3-max": runway_service_1.RunwayService,
+    "runway-hailuo3": runway_service_1.RunwayService,
+    "runway-veo3.1": runway_service_1.RunwayService,
+    "runway-veo3.1-fast": runway_service_1.RunwayService,
+    "runway-happyhorse-1.0": runway_service_1.RunwayService,
+    "runway-gemini-omni-flash": runway_service_1.RunwayService,
     // --- Kling ---
     "kling-v2.6": kling_service_1.KlingService,
     "kling-v2.5-turbo": kling_service_1.KlingService,
@@ -57,6 +75,7 @@ exports.videoServicesMap = {
     "kling-v2.1-master": kling_service_1.KlingService,
     "kling-v3.0": kling_service_1.KlingService,
     "kling-v3.0-turbo": kling_service_1.KlingService,
+    "kling-v3.0-omni": kling_service_1.KlingService,
     "kling-avatar": kling_service_1.KlingService,
     "kling-video-o1": kling_service_1.KlingService,
     "kling-v3-omni-video": kling_service_1.KlingService,
@@ -71,8 +90,19 @@ exports.videoServicesMap = {
     "openai-sora-2": openai_service_1.OpenaiService,
     "openai-sora-2-pro": openai_service_1.OpenaiService,
     // --- Alibaba ---
+    "alibaba-wan-3.0": alibaba_1.AlibabaService,
+    "alibaba-wan-3.0-prime": alibaba_1.AlibabaService,
+    "alibaba-happyhorse-1.1-t2v": alibaba_1.AlibabaService,
+    "alibaba-happyhorse-1.1-i2v": alibaba_1.AlibabaService,
+    "alibaba-happyhorse-1.1-r2v": alibaba_1.AlibabaService,
+    "alibaba-happyhorse-1.0-t2v": alibaba_1.AlibabaService,
+    "alibaba-happyhorse-1.0-i2v": alibaba_1.AlibabaService,
+    "alibaba-happyhorse-1.0-r2v": alibaba_1.AlibabaService,
+    "alibaba-happyhorse-1.0-video-edit": alibaba_1.AlibabaService,
     "alibaba-wan-2.7-t2v": alibaba_1.AlibabaService,
     "alibaba-wan-2.7-i2v": alibaba_1.AlibabaService,
+    "alibaba-wan-2.7-r2v": alibaba_1.AlibabaService,
+    "alibaba-wan-2.7-videoedit": alibaba_1.AlibabaService,
     "alibaba-wan-2.6-t2v": alibaba_1.AlibabaService,
     "alibaba-wan-2.6-i2v": alibaba_1.AlibabaService,
     "alibaba-wan-2.6-i2v-flash": alibaba_1.AlibabaService,
@@ -102,13 +132,18 @@ exports.imageServicesMap = {
     [aiModels_1.EImageGenModels.GOOGLE_IMAGEN_4_FAST]: google_service_1.GoogleService,
     [aiModels_1.EImageGenModels.GOOGLE_NANO_BANANA_PRO]: google_service_1.GoogleService,
     [aiModels_1.EImageGenModels.GOOGLE_NANO_BANANA]: google_service_1.GoogleService,
+    [aiModels_1.EImageGenModels.GOOGLE_NANO_BANANA_2]: google_service_1.GoogleService,
     // --- OpenAI gpt-image ---
     [aiModels_1.EImageGenModels.OPENAI_GPT_IMAGE_2]: openai_service_1.OpenaiService,
     [aiModels_1.EImageGenModels.OPENAI_GPT_IMAGE_1_5]: openai_service_1.OpenaiService,
     [aiModels_1.EImageGenModels.OPENAI_GPT_IMAGE_1]: openai_service_1.OpenaiService,
     [aiModels_1.EImageGenModels.OPENAI_GPT_IMAGE_1_MINI]: openai_service_1.OpenaiService,
     // --- ByteDance Seedream 5 (Lite only — pro/edit unreleased) ---
+    [aiModels_1.EImageGenModels.BYTEDANCE_SEEDREAM_5_PRO]: bytedance_service_1.ByteDanceService,
+    [aiModels_1.EImageGenModels.BYTEDANCE_SEEDREAM_5_FLASH]: bytedance_service_1.ByteDanceService,
     [aiModels_1.EImageGenModels.BYTEDANCE_SEEDREAM_5_LITE]: bytedance_service_1.ByteDanceService,
+    [aiModels_1.EImageGenModels.BYTEDANCE_SEEDREAM_4_5]: bytedance_service_1.ByteDanceService,
+    [aiModels_1.EImageGenModels.BYTEDANCE_SEEDREAM_4_0]: bytedance_service_1.ByteDanceService,
     // --- Kling first-party image API (KlingImageService) ---
     [aiModels_1.EImageGenModels.KLING_IMAGE_O1]: klingImage_service_1.KlingImageService,
     [aiModels_1.EImageGenModels.KLING_V3_OMNI_IMAGE]: klingImage_service_1.KlingImageService,
@@ -116,6 +151,8 @@ exports.imageServicesMap = {
     // --- Kling Kolors (DashScope-hosted, legacy) ---
     [aiModels_1.EImageGenModels.KLING_KOLORS]: alibaba_1.AlibabaService,
     // --- Alibaba Qwen-Image ---
+    [aiModels_1.EImageGenModels.ALIBABA_QWEN_IMAGE_3_PRO]: alibaba_1.AlibabaService,
+    [aiModels_1.EImageGenModels.ALIBABA_QWEN_IMAGE_3]: alibaba_1.AlibabaService,
     [aiModels_1.EImageGenModels.ALIBABA_QWEN_IMAGE_2_PRO]: alibaba_1.AlibabaService,
     [aiModels_1.EImageGenModels.ALIBABA_QWEN_IMAGE_2]: alibaba_1.AlibabaService,
     [aiModels_1.EImageGenModels.ALIBABA_QWEN_IMAGE_EDIT_MAX]: alibaba_1.AlibabaService,
@@ -126,6 +163,9 @@ exports.imageServicesMap = {
     [aiModels_1.EImageGenModels.ALIBABA_WAN_2_7_IMAGE]: alibaba_1.AlibabaService,
     // --- MiniMax image-01 ---
     [aiModels_1.EImageGenModels.MINIMAX_IMAGE_01]: minimax_service_1.MinimaxService,
+    // --- xAI Grok Imagine ---
+    [aiModels_1.EImageGenModels.XAI_GROK_IMAGINE_IMAGE_2]: xai_service_1.XaiService,
+    [aiModels_1.EImageGenModels.XAI_GROK_IMAGINE_IMAGE]: xai_service_1.XaiService,
     // --- RunwayML Gen-4 Image ---
     [aiModels_1.EImageGenModels.RUNWAYML_GEN4_IMAGE]: runway_service_1.RunwayService,
     [aiModels_1.EImageGenModels.RUNWAYML_GEN4_IMAGE_TURBO]: runway_service_1.RunwayService,

package/lib/services/aiGen/canonicalAdapters/cameraControl.types.d.ts

@@ -5,10 +5,13 @@
  * motion intensity), MiniMax Director (in-prompt commands), Seedance (in-prompt),
  * and Pixverse V6 (lens-control prompt vocabulary).
  *
- * Providers that don't expose camera control (Veo, OpenAI, Wan T2V) ignore the
- * field with a logged warning rather than throwing.
+ * Every video model gets it: `applyCameraDirection` (./cameraDirection.ts)
+ * turns it into whatever the model documents — MiniMax `[Pan left]` commands,
+ * Seedance 1.x `camera_fixed`, or a plain camera sentence in the prompt.
  */
-export type CameraPreset = "static" | "pan_left" | "pan_right" | "tilt_up" | "tilt_down" | "zoom_in" | "zoom_out" | "dolly_in" | "dolly_out" | "orbit_left" | "orbit_right" | "roll_left" | "roll_right" | "tracking" | "handheld" | "push_in" | "pull_out";
+export declare const CAMERA_PRESETS: readonly ["static", "pan_left", "pan_right", "tilt_up", "tilt_down", "zoom_in", "zoom_out", "dolly_in", "dolly_out", "orbit_left", "orbit_right", "roll_left", "roll_right", "tracking", "handheld", "push_in", "pull_out"];
+export type CameraPreset = (typeof CAMERA_PRESETS)[number];
+export declare function isCameraPreset(v: unknown): v is CameraPreset;
 /**
  * Six-axis vector control (mirrors Kling's `camera_control.config` shape).
  * Each axis is in [-10, 10]. Adapters that don't support fine-grained vector

package/lib/services/aiGen/canonicalAdapters/cameraControl.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cameraControl.types.d.ts","sourceRoot":"","sources":["../../../../src/services/aiGen/canonicalAdapters/cameraControl.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,MAAM,YAAY,GACpB,QAAQ,GACR,UAAU,GACV,WAAW,GACX,SAAS,GACT,WAAW,GACX,SAAS,GACT,UAAU,GACV,UAAU,GACV,WAAW,GACX,YAAY,GACZ,aAAa,GACb,WAAW,GACX,YAAY,GACZ,UAAU,GACV,UAAU,GACV,SAAS,GACT,UAAU,CAAC;AAEf;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB"}
+{"version":3,"file":"cameraControl.types.d.ts","sourceRoot":"","sources":["../../../../src/services/aiGen/canonicalAdapters/cameraControl.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,6NAkBjB,CAAC;AAEX,MAAM,MAAM,YAAY,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAE3D,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,YAAY,CAE5D;AAED;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC3B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,2DAA2D;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/lib/services/aiGen/canonicalAdapters/cameraControl.types.js

@@ -1,2 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAMERA_PRESETS = void 0;
+exports.isCameraPreset = isCameraPreset;
+/**
+ * Canonical camera-control schema. Translated per-provider by adapters that
+ * live alongside each provider's service. The set is the union of camera
+ * primitives across Kling (typed presets + vector), Runway (named presets +
+ * motion intensity), MiniMax Director (in-prompt commands), Seedance (in-prompt),
+ * and Pixverse V6 (lens-control prompt vocabulary).
+ *
+ * Every video model gets it: `applyCameraDirection` (./cameraDirection.ts)
+ * turns it into whatever the model documents — MiniMax `[Pan left]` commands,
+ * Seedance 1.x `camera_fixed`, or a plain camera sentence in the prompt.
+ */
+exports.CAMERA_PRESETS = [
+    "static",
+    "pan_left",
+    "pan_right",
+    "tilt_up",
+    "tilt_down",
+    "zoom_in",
+    "zoom_out",
+    "dolly_in",
+    "dolly_out",
+    "orbit_left",
+    "orbit_right",
+    "roll_left",
+    "roll_right",
+    "tracking",
+    "handheld",
+    "push_in",
+    "pull_out",
+];
+function isCameraPreset(v) {
+    return typeof v === "string" && exports.CAMERA_PRESETS.includes(v);
+}

package/lib/services/aiGen/canonicalAdapters/cameraDirection.d.ts

@@ -0,0 +1,36 @@
+import type { CameraControl, CameraPreset } from "./cameraControl.types";
+/**
+ * Canonical camera control → what each video model actually documents.
+ *
+ * Almost no current model takes a structured camera parameter any more — Kling
+ * dropped `camera_control` from its 2.5-turbo / 2.6 / v3 / Omni APIs (its docs
+ * steer camera through the prompt: "Camera zooms out, the girl smiles"), and
+ * Veo, Sora, Wan, Pixverse, Seedance 2.x and Grok Imagine read camera direction
+ * from the prompt too. So the default is a plain camera sentence ahead of the
+ * prompt, and only models with a documented syntax get something else:
+ *
+ *   - MiniMax H3 / H3 Max / Hailuo-02 / 2.3 / 2.3-Fast: `[Pan left]`-style
+ *     commands, 15 of them, combinable inside one bracket (platform.minimax.io
+ *     video-generation-t2v, "Supported 15 camera commands"; the H3 guide asks
+ *     for the same bracketed moves after key descriptions).
+ *   - Runway: its own bracketed clause (providers/runway/cameraAdapter).
+ *   - Seedance 1.x: a "static" camera becomes `camera_fixed: true` (the only
+ *     camera parameter ModelArk documents) on models that declare
+ *     `cameraFixed`; other moves go in the prompt.
+ *
+ * Call it once, right before `provider.generateVideo`. It clears
+ * `cameraControl` from the params it returns so a service that still maps the
+ * field itself (Kling, Runway) can't apply the move twice.
+ */
+export interface CameraDirectable {
+    modelKey?: string;
+    prompt?: string;
+    cameraControl?: CameraControl;
+    cameraFixed?: boolean;
+}
+/** Resolve the canonical control to a single preset (vector wins, like Kling's adapter). */
+export declare function resolveCameraPreset(c: CameraControl | undefined): CameraPreset | undefined;
+/** The camera clause for a model, or undefined when there's nothing to add. */
+export declare function cameraPromptClause(modelKey: string | undefined, c: CameraControl, prompt: string | undefined): string | undefined;
+export declare function applyCameraDirection<T extends CameraDirectable>(params: T): T;
+//# sourceMappingURL=cameraDirection.d.ts.map

package/lib/services/aiGen/canonicalAdapters/cameraDirection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cameraDirection.d.ts","sourceRoot":"","sources":["../../../../src/services/aiGen/canonicalAdapters/cameraDirection.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAgB,MAAM,uBAAuB,CAAC;AAEvF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAoHD,4FAA4F;AAC5F,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,YAAY,GAAG,SAAS,CAI1F;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,CAAC,EAAE,aAAa,EAChB,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,MAAM,GAAG,SAAS,CAcpB;AAED,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,gBAAgB,EAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAmB7E"}

package/lib/services/aiGen/canonicalAdapters/cameraDirection.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCameraPreset = resolveCameraPreset;
+exports.cameraPromptClause = cameraPromptClause;
+exports.applyCameraDirection = applyCameraDirection;
+const aiModels_1 = require("../../../globals/aiModels");
+const cameraAdapter_1 = require("../providers/runway/cameraAdapter");
+/** Prompt sentence per preset — standard cinematography wording. */
+const PRESET_SENTENCE = {
+    static: "Static camera, locked off, no camera movement",
+    pan_left: "The camera pans left",
+    pan_right: "The camera pans right",
+    tilt_up: "The camera tilts up",
+    tilt_down: "The camera tilts down",
+    zoom_in: "The camera zooms in",
+    zoom_out: "The camera zooms out",
+    dolly_in: "The camera dollies in toward the subject",
+    dolly_out: "The camera dollies back away from the subject",
+    orbit_left: "The camera orbits left around the subject",
+    orbit_right: "The camera orbits right around the subject",
+    roll_left: "The camera rolls counter-clockwise",
+    roll_right: "The camera rolls clockwise",
+    tracking: "Tracking shot, the camera follows the subject",
+    handheld: "Handheld camera with natural shake",
+    push_in: "Slow push-in toward the subject",
+    pull_out: "Slow pull-out revealing the scene",
+};
+/**
+ * Words that mean the prompt already carries this move (the planner copies a
+ * motion ref's direction into scene.prompt), so we don't say it twice.
+ */
+const PRESET_KEYWORDS = {
+    static: /\bstatic (shot|camera)\b|\blocked[- ]off\b/i,
+    pan_left: /\bpans? (to the )?left\b/i,
+    pan_right: /\bpans? (to the )?right\b/i,
+    tilt_up: /\btilts? up\b/i,
+    tilt_down: /\btilts? down\b/i,
+    zoom_in: /\bzooms? in\b/i,
+    zoom_out: /\bzooms? out\b/i,
+    dolly_in: /\bdoll(y|ies) in\b/i,
+    dolly_out: /\bdoll(y|ies) (out|back)\b/i,
+    orbit_left: /\borbits? (to the )?left\b|\bcounter-?clockwise orbit\b/i,
+    orbit_right: /\borbits? (to the )?right\b|\bclockwise orbit\b/i,
+    roll_left: /\brolls? (counter-?clockwise|left)\b/i,
+    roll_right: /\brolls? (clockwise|right)\b/i,
+    tracking: /\btracking shot\b|\bfollows? the subject\b/i,
+    handheld: /\bhand-?held\b/i,
+    push_in: /\bpush(es)?[- ]in\b/i,
+    pull_out: /\bpull(s)?[- ](out|back)\b/i,
+};
+/** MiniMax's documented commands (one or more per bracket, max 3). */
+const PRESET_MINIMAX = {
+    static: ["Static shot"],
+    pan_left: ["Pan left"],
+    pan_right: ["Pan right"],
+    tilt_up: ["Tilt up"],
+    tilt_down: ["Tilt down"],
+    zoom_in: ["Zoom in"],
+    zoom_out: ["Zoom out"],
+    dolly_in: ["Push in"],
+    dolly_out: ["Pull out"],
+    // An orbit is a truck one way while panning back the other way to keep
+    // the subject centred (orbit left = camera travels left, pans right).
+    orbit_left: ["Truck left", "Pan right"],
+    orbit_right: ["Truck right", "Pan left"],
+    roll_left: null,
+    roll_right: null,
+    tracking: ["Tracking shot"],
+    handheld: ["Shake"],
+    push_in: ["Push in"],
+    pull_out: ["Pull out"],
+};
+const MINIMAX_COMMAND_MODELS = new Set([
+    // H3 docs: "add camera motion instructions (e.g. [pan], [zoom], [static])
+    // directly after key descriptions" (guides/video-generation).
+    "minimax-h3",
+    "minimax-h3-max",
+    "minimax-hailuo-02",
+    "minimax-hailuo-2.3",
+    "minimax-hailuo-2.3-fast",
+]);
+/** Dominant axis of a six-axis vector → the preset it reads as. */
+function vectorToPreset(v) {
+    let best;
+    for (const axis of ["horizontal", "vertical", "pan", "tilt", "roll", "zoom"]) {
+        const value = v[axis];
+        if (typeof value === "number" && value !== 0 && (!best || Math.abs(value) > Math.abs(best.value))) {
+            best = { axis, value };
+        }
+    }
+    if (!best)
+        return "static";
+    const pos = best.value > 0;
+    switch (best.axis) {
+        case "horizontal":
+            return "tracking";
+        case "vertical":
+            return pos ? "tilt_up" : "tilt_down";
+        case "pan":
+            return pos ? "pan_right" : "pan_left";
+        case "tilt":
+            return pos ? "tilt_up" : "tilt_down";
+        case "roll":
+            return pos ? "roll_right" : "roll_left";
+        case "zoom":
+            return pos ? "zoom_in" : "zoom_out";
+    }
+}
+function intensityPrefix(i) {
+    if (i === undefined)
+        return undefined;
+    if (i <= 0.33)
+        return "subtle";
+    if (i >= 0.67)
+        return "strong";
+    return undefined;
+}
+/** Resolve the canonical control to a single preset (vector wins, like Kling's adapter). */
+function resolveCameraPreset(c) {
+    if (!c)
+        return undefined;
+    if (c.vector)
+        return vectorToPreset(c.vector);
+    return c.preset;
+}
+/** The camera clause for a model, or undefined when there's nothing to add. */
+function cameraPromptClause(modelKey, c, prompt) {
+    const preset = resolveCameraPreset(c);
+    if (!preset)
+        return undefined;
+    if (prompt && PRESET_KEYWORDS[preset].test(prompt))
+        return undefined;
+    const strength = intensityPrefix(c.intensity);
+    if (modelKey && MINIMAX_COMMAND_MODELS.has(modelKey)) {
+        const cmds = PRESET_MINIMAX[preset];
+        if (cmds)
+            return `[${cmds.join(",")}]`;
+    }
+    const sentence = PRESET_SENTENCE[preset];
+    if (!strength || preset === "static")
+        return `${sentence}.`;
+    return strength === "subtle"
+        ? `${sentence}, subtle and slow.`
+        : `${sentence}, fast and pronounced.`;
+}
+function applyCameraDirection(params) {
+    const c = params.cameraControl;
+    if (!c || (!c.preset && !c.vector))
+        return params;
+    const provider = params.modelKey ? (0, aiModels_1.getProviderKey)(params.modelKey) : "";
+    const fields = params.modelKey
+        ? aiModels_1.aiModelConfigs[params.modelKey]?.fields
+        : undefined;
+    if (fields && "cameraFixed" in fields && resolveCameraPreset(c) === "static") {
+        return { ...params, cameraFixed: true, cameraControl: undefined };
+    }
+    let prompt = params.prompt;
+    if (provider === "runway") {
+        const preset = resolveCameraPreset(c);
+        prompt = preset ? (0, cameraAdapter_1.applyRunwayCameraControl)(prompt, { ...c, preset }) : prompt;
+    }
+    else {
+        const clause = cameraPromptClause(params.modelKey, c, prompt);
+        if (clause)
+            prompt = prompt ? `${clause} ${prompt}` : clause;
+    }
+    return { ...params, prompt, cameraControl: undefined };
+}

package/lib/services/aiGen/canonicalAdapters/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./cameraControl.types";
 export * from "./multiShot.types";
+export * from "./cameraDirection";
 //# sourceMappingURL=index.d.ts.map

package/lib/services/aiGen/canonicalAdapters/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/aiGen/canonicalAdapters/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/aiGen/canonicalAdapters/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC"}

package/lib/services/aiGen/canonicalAdapters/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./cameraControl.types"), exports);
 __exportStar(require("./multiShot.types"), exports);
+__exportStar(require("./cameraDirection"), exports);

package/lib/services/aiGen/canonicalAdapters/multiShot.types.d.ts

@@ -1,7 +1,8 @@
 /**
  * Canonical multi-shot schema. Per-provider adapters translate this into:
- *   Kling v3.0 → `multi_prompt[]` (per-shot prompts) + companion `shot_type`
- *                (v3.0 only — v2.x has no public multi-shot API)
+ *   Kling omni-video (O1 / v3-omni) → `multi_prompt[]` + `shot_type`
+ *   Kling v3.0 / 3.0 Turbo → prompt-encoded "shot n, m, words;" storyboard
+ *                (toKlingShotPrompt; v2.x has no public multi-shot API)
  *   Seedance   → concatenated prompt with "--- CUT ---" separators
  *   Pixverse   → `generate_multi_clip_switch=true` + concatenated prompt (≤2 shots)
  *   others     → throw UnsupportedCapabilityError (gated by IModelSchema.fields.multiShot)

package/lib/services/aiGen/canonicalAdapters/multiShot.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiShot.types.d.ts","sourceRoot":"","sources":["../../../../src/services/aiGen/canonicalAdapters/multiShot.types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uFAAuF;IACvF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,mEAAmE;AACnE,MAAM,MAAM,SAAS,GAAG,IAAI,EAAE,CAAC;AAE/B,qBAAa,0BAA2B,SAAQ,KAAK;aAEjC,UAAU,EAAE,MAAM;aAClB,QAAQ,EAAE,MAAM;gBADhB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM;CAKnC"}
+{"version":3,"file":"multiShot.types.d.ts","sourceRoot":"","sources":["../../../../src/services/aiGen/canonicalAdapters/multiShot.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,WAAW,IAAI;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uFAAuF;IACvF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,mEAAmE;AACnE,MAAM,MAAM,SAAS,GAAG,IAAI,EAAE,CAAC;AAE/B,qBAAa,0BAA2B,SAAQ,KAAK;aAEjC,UAAU,EAAE,MAAM;aAClB,QAAQ,EAAE,MAAM;gBADhB,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM;CAKnC"}

package/lib/services/aiGen/helpers.d.ts

@@ -22,5 +22,45 @@ export declare function getModelsSupportingLastFrame(): string[];
  * supported by this model"). Same pattern as modelSupportsLastFrame, generalized.
  */
 export declare function modelDeclaresField(modelKey: string, field: string): boolean;
+/** Whether the provider has shut this model down (config carries `retired`). */
+/** Where the input-video seconds of a request come from (request body, job doc or scene). */
+export interface InputVideoBillingSource {
+    inputVideoUrl?: string;
+    /** Measured length of `inputVideoUrl` (client reads it from the <video> element). */
+    inputVideoDurationSec?: number;
+    referenceVideoUrls?: string[];
+    /** Measured lengths of `referenceVideoUrls`, same order. */
+    referenceVideoDurationsSec?: number[];
+    /** Output duration — the stand-in for any clip the client didn't measure. */
+    duration?: number;
+    inputImageUrl?: string;
+    lastFrameImageUrl?: string;
+    referenceImageUrls?: string[];
+    /** Counted for providers that bill per audio reference (Runway Grok Imagine). */
+    referenceAudioUrls?: string[];
+}
+/**
+ * Input-video billing for getCreditUsed. Providers that bill input seconds
+ * (Wan 3.0, HappyHorse edit, MiniMax, Seedance 2.0) charge for EVERY video the
+ * request carries — the source clip and each reference clip — so both count.
+ * An unmeasured clip falls back to the output duration (the same conservative
+ * proxy the source clip always used). Every billing call site (precheck,
+ * upfront deduction, multi-scene true-up, reconcile) must go through this so
+ * the estimate and the reconcile agree.
+ */
+export declare function getInputVideoBilling(src: InputVideoBillingSource): {
+    hasInputVideo: boolean;
+    inputVideoDurationSec?: number;
+    /**
+     * First frame + last frame + reference images. Some providers bill per
+     * input image (MiniMax H3 beyond a free allowance, Runway-hosted Hailuo /
+     * Grok / Gemini Omni Flash); the rest ignore it. Rides along here so every
+     * billing call site that already spreads this result passes it too.
+     */
+    numInputImages: number;
+    /** Reference audio clips (Runway-hosted Grok Imagine bills 1 credit each). */
+    numInputAudios: number;
+};
+export declare function isModelRetired(modelKey: string): boolean;
 export declare function validateParams(params: VideoGenerationParams): boolean;
 //# sourceMappingURL=helpers.d.ts.map

package/lib/services/aiGen/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/services/aiGen/helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGhE;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,IAAI,MAAM,EAAE,CAEvD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAG3E;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAiKrE"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/services/aiGen/helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAE1D;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGhE;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,IAAI,MAAM,EAAE,CAEvD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAG3E;AAED,gFAAgF;AAChF,6FAA6F;AAC7F,MAAM,WAAW,uBAAuB;IACtC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qFAAqF;IACrF,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,4DAA4D;IAC5D,0BAA0B,CAAC,EAAE,MAAM,EAAE,CAAC;IACtC,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC9B,iFAAiF;IACjF,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,uBAAuB,GAAG;IAClE,aAAa,EAAE,OAAO,CAAC;IACvB,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB,8EAA8E;IAC9E,cAAc,EAAE,MAAM,CAAC;CACxB,CAqBA;AAED,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAGxD;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CA6KrE"}