@contentgrowth/llm-service 0.6.92 → 0.6.95

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentgrowth/llm-service",
-  "version": "0.6.92",
+  "version": "0.6.95",
   "description": "Unified LLM Service for Content Growth",
   "main": "src/index.js",
   "type": "module",
@@ -8,6 +8,7 @@
     "test": "echo \"Error: no test specified\" && exit 1",
     "test:live": "node test-live.js",
     "test:json": "node test-json-mode.js",
+    "test:jsonutil": "node test-extraction.js",
     "examples:json": "node examples-json-mode.js",
     "prepublishOnly": "echo '\n📦 Package contents:\n' && npm pack --dry-run && echo '\n⚠️  Review the files above before publishing!\n'"
   },

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

@@ -127,50 +127,67 @@ 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 candidates directly on result
-        // Extract function calls from parts
-        let toolCalls = null;
-        if (result.candidates?.[0]?.content?.parts) {
-            const functionCallParts = result.candidates[0].content.parts.filter(p => p.functionCall);
-            if (functionCallParts.length > 0) {
-                toolCalls = functionCallParts.map(p => p.functionCall);
-            }
+        if (systemPrompt) {
+            requestOptions.systemInstruction = systemPrompt;
         }
 
-        // Extract text content from parts
-        let textContent = '';
+        if (tools && tools.length > 0) {
+            requestOptions.tools = [{ functionDeclarations: tools.map(t => t.function) }];
+        }
+
+        console.log('[GeminiProvider] generateContent request:', JSON.stringify(requestOptions, null, 2));
+
+        let response;
         try {
-            if (result.candidates?.[0]?.content?.parts) {
-                // Concatenate text from parts
-                textContent = result.candidates[0].content.parts
-                    .filter(p => p.text)
-                    .map(p => p.text)
-                    .join('');
-            } else if (result.text) {
-                textContent = typeof result.text === 'function' ? result.text() : result.text;
+            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);
+        }
+
+        const parts = candidate.content?.parts || [];
+
+        // Extract text and function calls
+        let textContent = '';
+        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) {
-            // 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
             );
         }
 
+        console.log('Gemini returns:', textContent);
         // Return with parsed JSON if applicable
         return {
             content: textContent,
@@ -197,15 +214,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');
                 }
@@ -216,25 +235,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';
             }
         };
 
@@ -348,23 +357,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;
+        }
 
-        // New SDK returns candidates directly on result, not result.response
-        const imagePart = result.candidates?.[0]?.content?.parts?.find(
+        console.log('[GeminiProvider] imageGeneration request:', JSON.stringify(requestOptions, null, 2));
+
+        const response = await this.client.models.generateContent(requestOptions);
+
+        const imagePart = response.candidates?.[0]?.content?.parts?.find(
             part => part.inlineData && part.inlineData.mimeType?.startsWith('image/')
         );
 
         if (!imagePart || !imagePart.inlineData) {
-            console.error('[GeminiProvider] No image in response. Result:', JSON.stringify(result, null, 2));
+            // 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 {