@contentgrowth/llm-service 0.6.8 → 0.6.91

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentgrowth/llm-service",
-  "version": "0.6.8",
+  "version": "0.6.91",
   "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/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,67 @@ 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();
+        // New SDK returns result directly, not result.response
+        // Debug log to understand structure
+        console.log('[GeminiProvider] Result structure:', JSON.stringify(Object.keys(result), null, 2));
+
+        // Handle both old (result.response) and new (direct result) structures
+        const response = result.response || result;
+
+        // Extract function calls - try multiple possible locations
+        let toolCalls = null;
+        if (typeof response.functionCalls === 'function') {
+            toolCalls = response.functionCalls();
+        } else if (response.functionCalls) {
+            toolCalls = response.functionCalls;
+        } else if (response.candidates?.[0]?.content?.parts) {
+            // Check parts for function calls
+            const functionCallParts = response.candidates[0].content.parts.filter(p => p.functionCall);
+            if (functionCallParts.length > 0) {
+                toolCalls = functionCallParts.map(p => p.functionCall);
+            }
+        }
 
+        // Extract text content - try multiple possible locations
         let textContent = '';
         try {
-            textContent = response.text();
+            if (typeof response.text === 'function') {
+                textContent = response.text();
+            } else if (typeof response.text === 'string') {
+                textContent = response.text;
+            } else if (response.candidates?.[0]?.content?.parts) {
+                // Concatenate text from parts
+                textContent = response.candidates[0].content.parts
+                    .filter(p => p.text)
+                    .map(p => p.text)
+                    .join('');
+            }
         } 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] Full result:', JSON.stringify(result, null, 2));
             throw new LLMServiceException(
                 'Model returned empty response. This usually means the prompt or schema is confusing the model.',
                 500
@@ -150,7 +188,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 +196,7 @@ export class GeminiProvider extends BaseLLMProvider {
         };
     }
 
+
     _buildGenerationConfig(options, maxTokens, temperature) {
         const config = {
             temperature: options.temperature ?? temperature,
@@ -299,11 +338,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 +361,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
         });
 
@@ -355,40 +392,58 @@ export class GeminiProvider extends BaseLLMProvider {
     }
 
     async startVideoGeneration(prompt, images, modelName, systemPrompt, options = {}) {
-        // 1. Initiate the request
+        // Use unified client for video generation
         const operation = await this.client.models.generateVideos({
             model: modelName,
             prompt: prompt,
             config: {
-                referenceImages: images,
+                durationSeconds: options.durationSeconds || 6,
+                aspectRatio: options.aspectRatio || '16:9',
+                numberOfVideos: 1,
+                // Pass reference images if provided
+                ...(images && images.length > 0 ? { referenceImages: images } : {}),
             }
         });
 
+        // Store operation for later polling
+        this._pendingOperations.set(operation.name, operation);
+
         return { operationName: operation.name };
     }
 
     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);
+        // Get the operation from cache or fetch it
+        let operation = this._pendingOperations.get(operationName);
+
+        if (!operation) {
+            // If not in cache, we need to fetch it by name
+            operation = await this.client.models.getOperation(operationName);
+        }
 
         // Refresh status
-        await operation.get();
+        operation = await operation.get();
+
+        // Update cache
+        this._pendingOperations.set(operationName, operation);
 
         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) {
+            // Clean up from cache
+            this._pendingOperations.delete(operationName);
+
             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);
+                // Extract video URI from response
+                result.videoUri = videoResult.videos?.[0]?.gcsUri ||
+                    videoResult.uri ||
+                    (videoResult.generatedAssets?.[0]?.uri);
                 result.content = "Video generation completed.";
             }
         }