@contentgrowth/llm-service 0.7.1 → 0.7.3

package/package.json

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

package/src/index.js

@@ -5,3 +5,5 @@ export { MODEL_CONFIGS } from './llm/config-manager.js';
 export { OpenAIProvider } from './llm/providers/openai-provider.js';
 export { GeminiProvider } from './llm/providers/gemini-provider.js';
 export { extractJsonFromResponse } from './llm/json-utils.js';
+export { FINISH_REASONS } from './llm/providers/base-provider.js';
+

package/src/llm/config-provider.js

@@ -94,7 +94,7 @@ export class DefaultConfigProvider extends BaseConfigProvider {
             apiKey: tenantConfig.api_key,
             models: MODEL_CONFIGS[tenantConfig.provider],
             temperature: parseFloat(env.DEFAULT_TEMPERATURE || '0.7'),
-            maxTokens: parseInt(env.DEFAULT_MAX_TOKENS || '4096'),
+            maxTokens: parseInt(env.DEFAULT_MAX_TOKENS || '16384'),
             capabilities: tenantConfig.capabilities || { chat: true, image: false, video: false },
             isTenantOwned: true
         };

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

@@ -1,3 +1,15 @@
+/**
+ * Standardized finish reasons across all LLM providers.
+ * Providers map their native values to these standard constants.
+ */
+export const FINISH_REASONS = {
+    COMPLETED: 'completed',      // Normal completion (OpenAI: stop, Gemini: STOP, Anthropic: end_turn)
+    TRUNCATED: 'truncated',      // Hit max tokens (OpenAI: length, Gemini: MAX_TOKENS, Anthropic: max_tokens)
+    CONTENT_FILTER: 'content_filter', // Content was filtered
+    TOOL_CALL: 'tool_call',      // Stopped for tool call
+    UNKNOWN: 'unknown',          // Unknown/unmapped reason
+};
+
 /**
  * Abstract base class for LLM Providers.
  * Defines the standard interface that all providers must implement.
@@ -7,6 +19,39 @@ export class BaseLLMProvider {
         this.config = config;
     }
 
+    /**
+     * Normalize provider-specific finish reason to standard value.
+     * Override in subclass if provider uses different values.
+     * @param {string} providerReason - The provider's native finish reason
+     * @returns {string} Standardized finish reason from FINISH_REASONS
+     */
+    normalizeFinishReason(providerReason) {
+        // Default mappings - providers can override
+        const upperReason = (providerReason || '').toUpperCase();
+
+        // Completed mappings
+        if (['STOP', 'END_TURN'].includes(upperReason)) {
+            return FINISH_REASONS.COMPLETED;
+        }
+
+        // Truncated mappings
+        if (['LENGTH', 'MAX_TOKENS'].includes(upperReason)) {
+            return FINISH_REASONS.TRUNCATED;
+        }
+
+        // Content filter mappings
+        if (['CONTENT_FILTER', 'SAFETY'].includes(upperReason)) {
+            return FINISH_REASONS.CONTENT_FILTER;
+        }
+
+        // Tool call mappings
+        if (['TOOL_CALLS', 'TOOL_USE', 'FUNCTION_CALL'].includes(upperReason)) {
+            return FINISH_REASONS.TOOL_CALL;
+        }
+
+        return FINISH_REASONS.UNKNOWN;
+    }
+
     /**
      * Simple chat interface for single-turn conversations
      * @param {string} userMessage 

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

@@ -180,7 +180,7 @@ export class GeminiProvider extends BaseLLMProvider {
             }
         }
 
-        console.log('[GeminiProvider] generateContent request:', JSON.stringify(requestOptions, null, 2));
+        // console.log('[GeminiProvider] generateContent request:', JSON.stringify(requestOptions, null, 2));
 
         let response;
         try {
@@ -228,11 +228,16 @@ export class GeminiProvider extends BaseLLMProvider {
             );
         }
 
-        console.log('Gemini returns:', textContent);
+        // console.log('Gemini returns:', textContent);
         // Return with parsed JSON if applicable
+        // Normalize the finish reason to standard value for consistent handling
+        const normalizedFinishReason = this.normalizeFinishReason(candidate.finishReason);
+
         return {
             content: textContent,
             tool_calls: toolCalls ? (Array.isArray(toolCalls) ? toolCalls : [toolCalls]).map(fc => ({ type: 'function', function: fc })) : null,
+            finishReason: normalizedFinishReason, // Standardized: 'completed', 'truncated', etc.
+            _rawFinishReason: candidate.finishReason, // Keep original for debugging
             _responseFormat: options.responseFormat,
             ...(options.responseFormat && this._shouldAutoParse(options) ? {
                 parsedContent: this._safeJsonParse(textContent)
@@ -265,7 +270,7 @@ export class GeminiProvider extends BaseLLMProvider {
                     // 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 (responseSchema)');
+                    // console.log('[GeminiProvider] Using Strict JSON mode with schema (responseSchema)');
                 } else {
                     console.warn('[GeminiProvider] Using legacy JSON mode without schema - may produce markdown wrappers');
                 }
@@ -336,9 +341,7 @@ export class GeminiProvider extends BaseLLMProvider {
         // - Brace extraction as fallback
         const parsed = extractJsonFromResponse(content);
 
-        if (parsed) {
-            console.log('[GeminiProvider] Successfully parsed JSON from response');
-        } else {
+        if (!parsed) {
             console.error('[GeminiProvider] Failed to extract valid JSON from response');
             console.error('[GeminiProvider] Content preview:', content.substring(0, 200));
         }
@@ -354,7 +357,7 @@ export class GeminiProvider extends BaseLLMProvider {
                 const tool_call_id = `gemini-tool-call-${index}`;
                 toolCall.id = tool_call_id;
 
-                console.log(`[Tool Call] ${toolName} with arguments:`, toolCall.function.args);
+                // console.log(`[Tool Call] ${toolName} with arguments:`, toolCall.function.args);
 
                 if (!tool) {
                     console.error(`[Tool Error] Tool '${toolName}' not found`);
@@ -362,7 +365,7 @@ export class GeminiProvider extends BaseLLMProvider {
                 }
                 try {
                     const output = await tool(toolCall.function.args, { env, tenantId });
-                    console.log(`[Tool Result] ${toolName} returned:`, output.substring(0, 200) + (output.length > 200 ? '...' : ''));
+                    // console.log(`[Tool Result] ${toolName} returned:`, output.substring(0, 200) + (output.length > 200 ? '...' : ''));
                     return { tool_call_id, output };
                 } catch (error) {
                     console.error(`[Tool Error] ${toolName} failed:`, error.message);
@@ -411,7 +414,7 @@ export class GeminiProvider extends BaseLLMProvider {
             requestOptions.config.systemInstruction = { parts: [{ text: systemPrompt }] };
         }
 
-        console.log('[GeminiProvider] imageGeneration request:', JSON.stringify(requestOptions, null, 2));
+        // console.log('[GeminiProvider] imageGeneration request:', JSON.stringify(requestOptions, null, 2));
 
         const response = await this.client.models.generateContent(requestOptions);
 
@@ -449,9 +452,12 @@ export class GeminiProvider extends BaseLLMProvider {
 
     async startVideoGeneration(prompt, images, modelName, systemPrompt, options = {}) {
         // Use unified client for video generation
-        const operation = await this.client.models.generateVideos({
+        // Prepend system prompt to user prompt if provided, as video models often expect instructions in the prompt
+        const effectivePrompt = systemPrompt ? `${systemPrompt}\n\n${prompt}` : prompt;
+
+        const requestConfig = {
             model: modelName,
-            prompt: prompt,
+            prompt: effectivePrompt,
             config: {
                 durationSeconds: options.durationSeconds || 6,
                 aspectRatio: options.aspectRatio || '16:9',
@@ -459,15 +465,35 @@ export class GeminiProvider extends BaseLLMProvider {
                 // Pass reference images if provided
                 ...(images && images.length > 0 ? { referenceImages: images } : {}),
             }
-        });
+        };
+
+        // Create a loggable copy of the config
+        const logConfig = JSON.parse(JSON.stringify(requestConfig));
+        if (logConfig.config && logConfig.config.referenceImages) {
+            logConfig.config.referenceImages = logConfig.config.referenceImages.map(img => ({
+                ...img,
+                data: `... (${img.data ? img.data.length : 0} bytes)` // Summarize data
+            }));
+        }
+
+        console.log('[GeminiProvider] startVideoGeneration request:', JSON.stringify(logConfig, null, 2));
 
-        // Store operation for later polling
-        this._pendingOperations.set(operation.name, operation);
+        try {
+            const operation = await this.client.models.generateVideos(requestConfig);
+
+            // Store operation for later polling
+            this._pendingOperations.set(operation.name, operation);
 
-        return { operationName: operation.name };
+            return { operationName: operation.name };
+        } catch (error) {
+            console.error('[GeminiProvider] startVideoGeneration failed:', error);
+            throw error;
+        }
     }
 
     async getVideoGenerationStatus(operationName) {
+        console.log(`[GeminiProvider] Checking status for operation: ${operationName}`);
+
         // Get the operation from cache or fetch it
         let operation = this._pendingOperations.get(operationName);
 
@@ -488,6 +514,8 @@ export class GeminiProvider extends BaseLLMProvider {
             state: operation.metadata?.state || (operation.done ? 'COMPLETED' : 'PROCESSING'),
         };
 
+        console.log(`[GeminiProvider] Operation status: ${result.state}, Progress: ${result.progress}%`);
+
         if (operation.done) {
             // Clean up from cache
             this._pendingOperations.delete(operationName);

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

@@ -68,10 +68,16 @@ export class OpenAIProvider extends BaseLLMProvider {
             );
         }
 
+        // Normalize the finish reason to standard value for consistent handling
+        const rawFinishReason = response.choices[0].finish_reason;
+        const normalizedFinishReason = this.normalizeFinishReason(rawFinishReason);
+
         // Return with parsed JSON if applicable
         return {
             content: message.content,
             tool_calls: message.tool_calls,
+            finishReason: normalizedFinishReason, // Standardized: 'completed', 'truncated', etc.
+            _rawFinishReason: rawFinishReason, // Keep original for debugging
             // Add metadata about response format
             _responseFormat: options.responseFormat,
             // Auto-parse JSON if requested

package/src/llm-service.js

@@ -174,12 +174,12 @@ export class LLMService {
             options
         );
 
-        let { content, tool_calls, parsedContent } = initialResponse;
+        let { content, tool_calls, parsedContent, finishReason } = initialResponse;
 
         // Tool execution loop with safety limit
         while (tool_calls && iteration < MAX_ITERATIONS) {
             iteration++;
-            console.log(`[Tool Call] Iteration ${iteration}/${MAX_ITERATIONS}: Assistant wants to use tools:`, tool_calls);
+            console.log(`[Tool Call] Iteration ${iteration}/${MAX_ITERATIONS} with finish reason ${finishReason}: Assistant wants to use tools:`, tool_calls);
             currentMessages.push({ role: 'assistant', content: content || '', tool_calls });
 
             // Execute tools using the provider's helper (which formats results for that provider)
@@ -196,6 +196,7 @@ export class LLMService {
             content = nextResponse.content;
             tool_calls = nextResponse.tool_calls;
             parsedContent = nextResponse.parsedContent; // Preserve parsedContent from final response
+            finishReason = nextResponse.finishReason; // Preserve finishReason from final response
         }
 
         if (iteration >= MAX_ITERATIONS) {
@@ -203,7 +204,7 @@ export class LLMService {
         }
 
         // Return both content and parsedContent (if available)
-        return { content, parsedContent, toolCalls: tool_calls };
+        return { content, parsedContent, toolCalls: tool_calls, finishReason };
     }
 
     /**