@contentgrowth/llm-service 0.6.7 → 0.6.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentgrowth/llm-service",
-  "version": "0.6.7",
+  "version": "0.6.8",
   "description": "Unified LLM Service for Content Growth",
   "main": "src/index.js",
   "type": "module",

package/src/llm/providers/base-provider.js

@@ -46,4 +46,26 @@ export class BaseLLMProvider {
     async imageGeneration(prompt, modelName, systemPrompt, options) {
         throw new Error('Image generation not supported by this provider');
     }
+
+    /**
+     * Start video generation (returns operation name for polling)
+     * @param {string} prompt
+     * @param {Array} images
+     * @param {string} modelName
+     * @param {string} systemPrompt
+     * @param {Object} options
+     * @returns {Promise<{operationName: string}>}
+     */
+    async startVideoGeneration(prompt, images, modelName, systemPrompt, options) {
+        throw new Error('Video generation not supported by this provider');
+    }
+
+    /**
+     * Get video generation status (poll operation)
+     * @param {string} operationName
+     * @returns {Promise<{done: boolean, progress: number, state: string, videoUri?: string, error?: object}>}
+     */
+    async getVideoGenerationStatus(operationName) {
+        throw new Error('Video generation not supported by this provider');
+    }
 }

package/src/llm/providers/gemini-provider.js

@@ -354,47 +354,45 @@ export class GeminiProvider extends BaseLLMProvider {
         return this.models[tier] || this.models.default;
     }
 
-    async videoGeneration(prompt, images, modelName, systemPrompt, options = {}) {
-        const model = this.client.getGenerativeModel({
+    async startVideoGeneration(prompt, images, modelName, systemPrompt, options = {}) {
+        // 1. Initiate the request
+        const operation = await this.client.models.generateVideos({
             model: modelName,
-            systemInstruction: systemPrompt,
-        });
-
-        // Prepare image parts
-        const imageParts = images.map(img => ({
-            inlineData: {
-                data: img.data, // Base64 string
-                mimeType: img.mimeType
+            prompt: prompt,
+            config: {
+                referenceImages: images,
             }
-        }));
-
-        const result = await model.generateContent({
-            contents: [{
-                role: "user",
-                parts: [
-                    { text: prompt },
-                    ...imageParts
-                ]
-            }]
         });
 
-        const response = result.response;
-
-        // Check for video attachment/URI in the response
-        // This structure depends on the specific API response for Veo
-        // Assuming it might return a file URI or a specific part type
+        return { operationName: operation.name };
+    }
 
-        // Fallback: Return text if no specific video part is found, 
-        // but try to find a URI in the text if possible.
-        const text = response.text();
+    async getVideoGenerationStatus(operationName) {
+        // 2. Get operation status
+        // Assuming the SDK supports retrieving operation by name via this.client.models.getOperation
+        // If not, we might need to adjust based on the specific SDK version.
+        const operation = await this.client.models.getOperation(operationName);
 
-        // TODO: Update this once Veo API response structure is fully documented/available
-        // For now, we return the text which might contain the URI or status.
+        // Refresh status
+        await operation.get();
 
-        return {
-            content: text,
-            // potential video URI extraction
-            videoUri: text.match(/https?:\/\/[^\s]+/) ? text.match(/https?:\/\/[^\s]+/)[0] : null
+        const result = {
+            done: operation.done,
+            // Extract progress if available in metadata
+            progress: operation.metadata?.progressPercent || 0,
+            state: operation.metadata?.state || (operation.done ? 'COMPLETED' : 'PROCESSING'),
         };
+
+        if (operation.done) {
+            if (operation.error) {
+                result.error = operation.error;
+            } else {
+                const videoResult = operation.response;
+                result.videoUri = videoResult.uri || (videoResult.generatedAssets && videoResult.generatedAssets[0] && videoResult.generatedAssets[0].uri);
+                result.content = "Video generation completed.";
+            }
+        }
+
+        return result;
     }
 }

package/src/llm-service.js

@@ -205,11 +205,43 @@ export class LLMService {
     }
 
     /**
-     * Generate a video
+     * Generate a video (async wrapper with polling - backward compatibility)
      */
     async videoGeneration(prompt, images, tenantId, modelName, systemPrompt, options = {}) {
+        const { operationName } = await this.startVideoGeneration(prompt, images, tenantId, modelName, systemPrompt, options);
+
+        let status = await this.getVideoGenerationStatus(operationName, tenantId);
+
+        while (!status.done) {
+            console.log(`Waiting for video generation... Progress: ${status.progress}%`);
+            await new Promise(resolve => setTimeout(resolve, 10000)); // Wait 10 seconds
+            status = await this.getVideoGenerationStatus(operationName, tenantId);
+        }
+
+        if (status.error) {
+            throw new Error(`Video generation failed: ${status.error.message || JSON.stringify(status.error)}`);
+        }
+
+        return {
+            content: status.content || "Video generation completed.",
+            videoUri: status.videoUri
+        };
+    }
+
+    /**
+     * Start video generation (returns operation name for polling)
+     */
+    async startVideoGeneration(prompt, images, tenantId, modelName, systemPrompt, options = {}) {
+        const provider = await this._getProvider(tenantId);
+        return provider.startVideoGeneration(prompt, images, modelName, systemPrompt, options);
+    }
+
+    /**
+     * Get video generation status
+     */
+    async getVideoGenerationStatus(operationName, tenantId) {
         const provider = await this._getProvider(tenantId);
-        return provider.videoGeneration(prompt, images, modelName, systemPrompt, options);
+        return provider.getVideoGenerationStatus(operationName);
     }
 
     /**