@contentgrowth/llm-service 0.6.91 → 0.6.94

package/package.json

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

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

@@ -127,58 +127,60 @@ export class GeminiProvider extends BaseLLMProvider {
         }
 
         // Use the new @google/genai API
-        const result = await this.client.models.generateContent({
+        // Use the new @google/genai API
+        const requestOptions = {
             model: modelName,
             contents: contents,
-            systemInstruction: systemPrompt,
-            generationConfig: generationConfig,
-            tools: tools ? [{ functionDeclarations: tools.map(t => t.function) }] : undefined,
-        });
+            config: generationConfig,
+        };
 
-        // 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));
+        if (systemPrompt) {
+            requestOptions.systemInstruction = systemPrompt;
+        }
 
-        // Handle both old (result.response) and new (direct result) structures
-        const response = result.response || result;
+        if (tools && tools.length > 0) {
+            requestOptions.tools = [{ functionDeclarations: tools.map(t => t.function) }];
+        }
 
-        // 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);
-            }
+        console.log('[GeminiProvider] generateContent request:', JSON.stringify(requestOptions, null, 2));
+
+        let response;
+        try {
+            response = await this.client.models.generateContent(requestOptions);
+        } catch (error) {
+            console.error('[GeminiProvider] generateContent failed:', error);
+            throw error;
+        }
+
+        // In @google/genai, the response is returned directly (no .response property)
+        // And helper methods like .text() or .functionCalls() might not exist on the raw object
+        // So we extract manually from candidates
+
+        const candidate = response.candidates?.[0];
+        if (!candidate) {
+            throw new LLMServiceException('No candidates returned from model', 500);
         }
 
-        // Extract text content - try multiple possible locations
+        const parts = candidate.content?.parts || [];
+
+        // Extract text and function calls
         let textContent = '';
-        try {
-            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('');
+        let toolCalls = null;
+
+        for (const part of parts) {
+            if (part.text) {
+                textContent += part.text;
+            }
+            if (part.functionCall) {
+                if (!toolCalls) toolCalls = [];
+                toolCalls.push(part.functionCall);
             }
-        } 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] Full result:', JSON.stringify(result, 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
@@ -211,15 +213,17 @@ export class GeminiProvider extends BaseLLMProvider {
 
             const schema = typeof options.responseFormat === 'object'
                 ? options.responseFormat.schema
-                : null;
+                : options.responseSchema || null;
 
             if (formatType === 'json' || formatType === 'json_schema') {
                 config.responseMimeType = 'application/json';
 
                 // CRITICAL: Must provide schema for "Strict Mode" to avoid markdown wrappers
                 if (schema) {
+                    // Use responseSchema for strict structured output
+                    // Must convert to Gemini Schema format (Uppercase types)
                     config.responseSchema = this._convertToGeminiSchema(schema);
-                    console.log('[GeminiProvider] Using Strict JSON mode with schema');
+                    console.log('[GeminiProvider] Using Strict JSON mode with schema (responseSchema)');
                 } else {
                     console.warn('[GeminiProvider] Using legacy JSON mode without schema - may produce markdown wrappers');
                 }
@@ -230,25 +234,15 @@ export class GeminiProvider extends BaseLLMProvider {
     }
 
     _convertToGeminiSchema(jsonSchema) {
-        // SchemaType constants for Gemini schema conversion
-        const SchemaType = {
-            STRING: 'STRING',
-            NUMBER: 'NUMBER',
-            INTEGER: 'INTEGER',
-            BOOLEAN: 'BOOLEAN',
-            ARRAY: 'ARRAY',
-            OBJECT: 'OBJECT'
-        };
-
         const convertType = (type) => {
             switch (type) {
-                case 'string': return SchemaType.STRING;
-                case 'number': return SchemaType.NUMBER;
-                case 'integer': return SchemaType.INTEGER;
-                case 'boolean': return SchemaType.BOOLEAN;
-                case 'array': return SchemaType.ARRAY;
-                case 'object': return SchemaType.OBJECT;
-                default: return SchemaType.STRING;
+                case 'string': return 'STRING';
+                case 'number': return 'NUMBER';
+                case 'integer': return 'INTEGER';
+                case 'boolean': return 'BOOLEAN';
+                case 'array': return 'ARRAY';
+                case 'object': return 'OBJECT';
+                default: return 'STRING';
             }
         };
 
@@ -362,22 +356,33 @@ export class GeminiProvider extends BaseLLMProvider {
         }
 
         // Use the new @google/genai API
-        const result = await this.client.models.generateContent({
+        const requestOptions = {
             model: modelName,
             contents: [{
                 role: "user",
                 parts: parts
             }],
-            systemInstruction: systemPrompt,
-            generationConfig
-        });
+            config: generationConfig
+        };
+
+        if (systemPrompt) {
+            requestOptions.systemInstruction = systemPrompt;
+        }
+
+        console.log('[GeminiProvider] imageGeneration request:', JSON.stringify(requestOptions, null, 2));
+
+        const response = await this.client.models.generateContent(requestOptions);
 
-        const response = result.response;
         const imagePart = response.candidates?.[0]?.content?.parts?.find(
             part => part.inlineData && part.inlineData.mimeType?.startsWith('image/')
         );
 
         if (!imagePart || !imagePart.inlineData) {
+            // Fallback: Check if it returned a URI or other format, or just text
+            const textPart = response.candidates?.[0]?.content?.parts?.find(p => p.text);
+            if (textPart) {
+                console.warn('[GeminiProvider] Model returned text instead of image:', textPart.text);
+            }
             throw new Error('No image data in response');
         }
 

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

@@ -93,7 +93,7 @@ export class OpenAIProvider extends BaseLLMProvider {
 
         const schema = typeof options.responseFormat === 'object'
             ? options.responseFormat.schema
-            : null;
+            : options.responseSchema || null;
 
         switch (formatType) {
             case 'json':
@@ -115,7 +115,7 @@ export class OpenAIProvider extends BaseLLMProvider {
 
             case 'json_schema':
                 if (!schema) {
-                    throw new Error('schema required when using json_schema format');
+                    throw new Error('responseSchema required when using json_schema format');
                 }
                 console.log('[OpenAIProvider] Using Strict JSON mode with schema');
                 return {