@contentgrowth/llm-service 0.6.7 → 0.6.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentgrowth/llm-service",
-  "version": "0.6.7",
+  "version": "0.6.9",
   "description": "Unified LLM Service for Content Growth",
   "main": "src/index.js",
   "type": "module",
@@ -14,7 +14,7 @@
   "author": "Content Growth",
   "license": "MIT",
   "dependencies": {
-    "@google/generative-ai": "^0.24.1",
+    "@google/genai": "^1.31.0",
     "openai": "^6.9.1"
   },
   "devDependencies": {

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

@@ -1,4 +1,4 @@
-import { GoogleGenerativeAI } from '@google/generative-ai';
+import { GoogleGenAI } from '@google/genai';
 import { BaseLLMProvider } from './base-provider.js';
 import { LLMServiceException } from '../../llm-service.js';
 import { extractJsonFromResponse } from '../json-utils.js';
@@ -6,11 +6,21 @@ import { extractJsonFromResponse } from '../json-utils.js';
 export class GeminiProvider extends BaseLLMProvider {
     constructor(config) {
         super(config);
-        this.client = new GoogleGenerativeAI(config.apiKey);
+
+        // Unified client for all operations (text, image, video)
+        // Uses apiKey for Gemini, and automatically handles Vertex AI env vars for Veo
+        this.client = new GoogleGenAI({
+            apiKey: config.apiKey,
+        });
+
         this.models = config.models;
         this.defaultModel = config.models.default;
+
+        // Store pending operations for polling
+        this._pendingOperations = new Map();
     }
 
+
     async chat(userMessage, systemPrompt = '', options = {}) {
         const messages = [{ role: 'user', content: userMessage }];
         const tier = options.tier || 'default';
@@ -42,25 +52,18 @@ export class GeminiProvider extends BaseLLMProvider {
     }
 
     async _chatCompletionWithModel(messages, systemPrompt, tools, modelName, maxTokens, temperature, options = {}) {
-        const modelConfig = {
-            model: modelName,
-            systemInstruction: systemPrompt,
-            tools: tools ? [{ functionDeclarations: tools.map(t => t.function) }] : undefined,
+        // Build generation config
+        const generationConfig = {
+            temperature: options.temperature ?? temperature,
+            maxOutputTokens: options.maxTokens ?? maxTokens,
         };
 
-        // Add JSON mode support for Gemini (only used when NO tools are present)
+        // Add JSON mode support
         if (options.responseFormat) {
-            modelConfig.generationConfig = this._buildGenerationConfig(options, maxTokens, temperature);
-        } else if (options.temperature !== undefined || options.maxTokens !== undefined) {
-            // Apply temperature/maxTokens overrides even without JSON mode
-            modelConfig.generationConfig = {
-                temperature: options.temperature ?? temperature,
-                maxOutputTokens: options.maxTokens ?? maxTokens,
-            };
+            const formatConfig = this._buildGenerationConfig(options, maxTokens, temperature);
+            Object.assign(generationConfig, formatConfig);
         }
 
-        const model = this.client.getGenerativeModel(modelConfig);
-
         // Pre-process messages to handle the 'system' role for Gemini
         const geminiMessages = [];
         let systemContentBuffer = [];
@@ -79,7 +82,7 @@ export class GeminiProvider extends BaseLLMProvider {
             }
         }
 
-        const history = geminiMessages.map((msg, index) => {
+        const contents = geminiMessages.map((msg, index) => {
             let role = '';
             let parts;
 
@@ -115,32 +118,38 @@ export class GeminiProvider extends BaseLLMProvider {
             return { role, parts };
         }).filter(Boolean);
 
-        while (history.length > 0 && history[0].role !== 'user') {
-            history.shift();
+        while (contents.length > 0 && contents[0].role !== 'user') {
+            contents.shift();
         }
 
-        if (history.length === 0) {
+        if (contents.length === 0) {
             throw new LLMServiceException('Cannot process a conversation with no user messages.', 400);
         }
 
-        const lastMessage = history.pop();
-        const chat = model.startChat({ history });
+        // Use the new @google/genai API
+        const result = await this.client.models.generateContent({
+            model: modelName,
+            contents: contents,
+            systemInstruction: systemPrompt,
+            generationConfig: generationConfig,
+            tools: tools ? [{ functionDeclarations: tools.map(t => t.function) }] : undefined,
+        });
 
-        const result = await chat.sendMessage(lastMessage.parts);
         const response = result.response;
-        const toolCalls = response.functionCalls();
+        const toolCalls = response.functionCalls?.() || response.functionCalls || null;
 
         let textContent = '';
         try {
-            textContent = response.text();
+            textContent = typeof response.text === 'function' ? response.text() : (response.text || '');
         } catch (e) {
             // response.text() throws if there is no text content (e.g. only tool calls)
             // This is expected behavior for tool-only responses
         }
+
         // Validate that we have EITHER content OR tool calls
         if (!textContent && (!toolCalls || toolCalls.length === 0)) {
             console.error('[GeminiProvider] Model returned empty response (no text, no tool calls)');
-            console.error('[GeminiProvider] Last message:', JSON.stringify(lastMessage, null, 2));
+            console.error('[GeminiProvider] Contents:', JSON.stringify(contents, null, 2));
             throw new LLMServiceException(
                 'Model returned empty response. This usually means the prompt or schema is confusing the model.',
                 500
@@ -150,7 +159,7 @@ export class GeminiProvider extends BaseLLMProvider {
         // Return with parsed JSON if applicable
         return {
             content: textContent,
-            tool_calls: toolCalls ? toolCalls.map(fc => ({ type: 'function', function: fc })) : null,
+            tool_calls: toolCalls ? (Array.isArray(toolCalls) ? toolCalls : [toolCalls]).map(fc => ({ type: 'function', function: fc })) : null,
             _responseFormat: options.responseFormat,
             ...(options.responseFormat && this._shouldAutoParse(options) ? {
                 parsedContent: this._safeJsonParse(textContent)
@@ -158,6 +167,7 @@ export class GeminiProvider extends BaseLLMProvider {
         };
     }
 
+
     _buildGenerationConfig(options, maxTokens, temperature) {
         const config = {
             temperature: options.temperature ?? temperature,
@@ -299,11 +309,6 @@ export class GeminiProvider extends BaseLLMProvider {
     }
 
     async imageGeneration(prompt, modelName, systemPrompt, options = {}) {
-        const model = this.client.getGenerativeModel({
-            model: modelName,
-            systemInstruction: systemPrompt,
-        });
-
         const generationConfig = {
             responseModalities: ["IMAGE"],
         };
@@ -327,11 +332,14 @@ export class GeminiProvider extends BaseLLMProvider {
             });
         }
 
-        const result = await model.generateContent({
+        // Use the new @google/genai API
+        const result = await this.client.models.generateContent({
+            model: modelName,
             contents: [{
                 role: "user",
                 parts: parts
             }],
+            systemInstruction: systemPrompt,
             generationConfig
         });
 
@@ -354,47 +362,63 @@ 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 = {}) {
+        // Use unified client for video generation
+        const operation = await this.client.models.generateVideos({
             model: modelName,
-            systemInstruction: systemPrompt,
+            prompt: prompt,
+            config: {
+                durationSeconds: options.durationSeconds || 6,
+                aspectRatio: options.aspectRatio || '16:9',
+                numberOfVideos: 1,
+                // Pass reference images if provided
+                ...(images && images.length > 0 ? { referenceImages: images } : {}),
+            }
         });
 
-        // Prepare image parts
-        const imageParts = images.map(img => ({
-            inlineData: {
-                data: img.data, // Base64 string
-                mimeType: img.mimeType
-            }
-        }));
+        // Store operation for later polling
+        this._pendingOperations.set(operation.name, operation);
 
-        const result = await model.generateContent({
-            contents: [{
-                role: "user",
-                parts: [
-                    { text: prompt },
-                    ...imageParts
-                ]
-            }]
-        });
+        return { operationName: operation.name };
+    }
 
-        const response = result.response;
+    async getVideoGenerationStatus(operationName) {
+        // Get the operation from cache or fetch it
+        let operation = this._pendingOperations.get(operationName);
 
-        // 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
+        if (!operation) {
+            // If not in cache, we need to fetch it by name
+            operation = await this.client.models.getOperation(operationName);
+        }
 
-        // 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();
+        // Refresh status
+        operation = await operation.get();
 
-        // 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.
+        // Update cache
+        this._pendingOperations.set(operationName, operation);
 
-        return {
-            content: text,
-            // potential video URI extraction
-            videoUri: text.match(/https?:\/\/[^\s]+/) ? text.match(/https?:\/\/[^\s]+/)[0] : null
+        const result = {
+            done: operation.done,
+            progress: operation.metadata?.progressPercent || 0,
+            state: operation.metadata?.state || (operation.done ? 'COMPLETED' : 'PROCESSING'),
         };
+
+        if (operation.done) {
+            // Clean up from cache
+            this._pendingOperations.delete(operationName);
+
+            if (operation.error) {
+                result.error = operation.error;
+            } else {
+                const videoResult = operation.response;
+                // Extract video URI from response
+                result.videoUri = videoResult.videos?.[0]?.gcsUri ||
+                    videoResult.uri ||
+                    (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);
     }
 
     /**