@contentgrowth/llm-service 0.8.2 → 0.8.4

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

@@ -1,607 +0,0 @@
-import { GoogleGenAI } from '@google/genai';
-import { BaseLLMProvider } from './base-provider.js';
-import { LLMServiceException } from '../../llm-service.js';
-import { extractJsonFromResponse } from '../json-utils.js';
-
-export class GeminiProvider extends BaseLLMProvider {
-    constructor(config) {
-        super(config);
-
-        // 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';
-        const effectiveModel = this._getModelForTier(tier);
-        const effectiveMaxTokens = options.maxTokens || this.config.maxTokens;
-        const effectiveTemperature = options.temperature !== undefined ? options.temperature : this.config.temperature;
-
-        const response = await this._chatCompletionWithModel(
-            messages,
-            systemPrompt,
-            null,
-            effectiveModel,
-            effectiveMaxTokens,
-            effectiveTemperature
-        );
-        return { text: response.content };
-    }
-
-    async chatCompletion(messages, systemPrompt, tools = null, options = {}) {
-        return this._chatCompletionWithModel(
-            messages,
-            systemPrompt,
-            tools,
-            this.defaultModel,
-            this.config.maxTokens,
-            this.config.temperature,
-            options
-        );
-    }
-
-    async _chatCompletionWithModel(messages, systemPrompt, tools, modelName, maxTokens, temperature, options = {}) {
-        // Build generation config
-        const generationConfig = {
-            temperature: options.temperature ?? temperature,
-            maxOutputTokens: options.maxTokens ?? maxTokens,
-        };
-
-        // Add JSON mode support
-        if (options.responseFormat) {
-            const formatConfig = this._buildGenerationConfig(options, maxTokens, temperature);
-            Object.assign(generationConfig, formatConfig);
-        }
-
-        // Pre-process messages to handle the 'system' role for Gemini
-        const geminiMessages = [];
-        let systemContentBuffer = [];
-
-        for (const msg of messages) {
-            if (msg.role === 'system') {
-                systemContentBuffer.push(msg.content);
-            } else {
-                if (msg.role === 'user' && systemContentBuffer.length > 0) {
-                    const fullContent = `${systemContentBuffer.join('\n')}\n\n${msg.content}`;
-                    geminiMessages.push({ ...msg, content: fullContent });
-                    systemContentBuffer = [];
-                } else {
-                    geminiMessages.push(msg);
-                }
-            }
-        }
-
-        const contents = geminiMessages.map((msg, index) => {
-            let role = '';
-            let parts;
-
-            switch (msg.role) {
-                case 'user':
-                    role = 'user';
-                    parts = [{ text: msg.content }];
-
-                    // Enhancement: If this is the LAST message (current turn), append the reminder.
-                    // This helps the model respect the system prompt (especially format) even with long context history.
-                    if (index === geminiMessages.length - 1) {
-                        let reminder = "";
-                        if (options.responseFormat === 'json' || options.responseFormat?.type === 'json_schema' || options.responseSchema) {
-                            reminder = "\n\n[SYSTEM NOTE: The output MUST be valid JSON as per the schema. Do not include markdown formatting or explanations.]";
-                        } else {
-                            reminder = "\n\n[SYSTEM NOTE: Please ensure your response adheres strictly to the constraints defined in the System Prompt.]";
-                        }
-
-                        // Append to the existing text part (Safest method)
-                        const lastPart = parts.find(p => p.text);
-                        if (lastPart) {
-                            lastPart.text += reminder;
-                        } else {
-                            // Fallback if message was image-only
-                            parts.push({ text: reminder });
-                        }
-                    }
-                    break;
-                case 'assistant':
-                    role = 'model';
-
-                    // Find if this is the LAST assistant message in the conversation
-                    // Only the last assistant message should carry the thought_signature to avoid token bloat
-                    const isLastAssistantMessage = index === geminiMessages.map((m, i) => m.role === 'assistant' ? i : -1).filter(i => i >= 0).pop();
-
-                    if (msg.tool_calls) {
-                        parts = msg.tool_calls.map(tc => {
-                            const part = {
-                                functionCall: { name: tc.function.name, args: tc.function.arguments || tc.function.args }
-                            };
-                            // Only attach signature for the last assistant message
-                            if (isLastAssistantMessage && tc.thought_signature) {
-                                console.log(`[GeminiProvider] Sending thought_signature in tool_call (${tc.thought_signature.length} chars)`);
-                                part.thoughtSignature = tc.thought_signature; // camelCase for SDK
-                            }
-                            return part;
-                        });
-                    } else {
-                        // Handle text content with optional thought signature
-                        const part = { text: msg.content || '' };
-                        // Only attach signature for the last assistant message
-                        if (isLastAssistantMessage && msg.thought_signature) {
-                            console.log(`[GeminiProvider] Sending thought_signature in text message (${msg.thought_signature.length} chars)`);
-                            part.thoughtSignature = msg.thought_signature;
-                        }
-                        parts = [part];
-                    }
-                    break;
-                case 'tool':
-                    role = 'user';
-                    const preceding_message = messages[index - 1];
-                    const tool_call = preceding_message?.tool_calls?.find(tc => tc.id === msg.tool_call_id);
-                    parts = [{
-                        functionResponse: {
-                            name: tool_call?.function?.name || 'unknown_tool',
-                            response: { content: msg.content },
-                        }
-                    }];
-
-                    // Fix for JSON mode: If JSON is requested, remind the model to output JSON after tool execution
-                    // This is necessary because strict JSON mode is disabled when tools are present.
-                    if (options.responseFormat === 'json' || options.responseFormat?.type === 'json_schema' || options.responseSchema) {
-                        parts.push({ text: "\n\n[SYSTEM NOTE: The output MUST be valid JSON as per the schema. Do not include markdown formatting or explanations.]" });
-                    } else {
-                        // Generic reminder to help model stay on track with system prompt instructions (e.g. formatting)
-                        // even if no specific JSON mode is configured.
-                        parts.push({ text: "\n\n[SYSTEM NOTE: Please ensure your response adheres strictly to the constraints defined in the System Prompt.]" });
-                    }
-                    break;
-                default:
-                    return null;
-            }
-            return { role, parts };
-        }).filter(Boolean);
-
-        while (contents.length > 0 && contents[0].role !== 'user') {
-            contents.shift();
-        }
-
-        if (contents.length === 0) {
-            throw new LLMServiceException('Cannot process a conversation with no user messages.', 400);
-        }
-
-        // Use the new @google/genai API
-        // Use the new @google/genai API
-        const requestOptions = {
-            model: modelName,
-            contents: contents,
-            config: generationConfig,
-        };
-
-        if (systemPrompt) {
-            requestOptions.config.systemInstruction = { parts: [{ text: systemPrompt }] };
-        }
-
-        if (tools && tools.length > 0) {
-            requestOptions.config.tools = [{ functionDeclarations: tools.map(t => t.function) }];
-            // CRITICAL: Cannot enforce JSON mode (responseMimeType/responseSchema) when tools are present
-            // because the model needs to be able to return tool calls (which are not JSON text).
-            // We must rely on the system prompt for JSON formatting in this case.
-            if (requestOptions.config.responseMimeType === 'application/json') {
-                console.warn('[GeminiProvider] Disabling strict JSON mode because tools are present. Relying on system prompt.');
-                delete requestOptions.config.responseMimeType;
-                delete requestOptions.config.responseSchema;
-            }
-        }
-
-        // 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 (API Key: ${this._getMaskedApiKey()}):`, 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, function calls, and thought signatures
-        let textContent = '';
-        let toolCalls = null;
-        let responseThoughtSignature = null;
-
-        for (const part of parts) {
-            if (part.text) {
-                textContent += part.text;
-                // Capture thought signature attached to text part if present
-                if (part.thought_signature || part.thoughtSignature) {
-                    responseThoughtSignature = part.thought_signature || part.thoughtSignature;
-                }
-            }
-            if (part.functionCall) {
-                if (!toolCalls) toolCalls = [];
-                // Preserve thought_signature if present (Gemini 3 requirement)
-                // Check both snake_case (API) and camelCase (SDK convention)
-                const sig = part.thought_signature || part.thoughtSignature;
-                if (sig) {
-                    part.functionCall.thought_signature = sig;
-                    // Also capture as top-level if not already set (though tool calls might have their own)
-                    if (!responseThoughtSignature) responseThoughtSignature = sig;
-                }
-                toolCalls.push(part.functionCall);
-            }
-            // Fallback for standalone thought signature parts if they exist (hypothetical)
-            if (!part.text && !part.functionCall && (part.thought_signature || part.thoughtSignature)) {
-                responseThoughtSignature = part.thought_signature || part.thoughtSignature;
-            }
-        }
-
-        // 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] Finish Reason:', candidate.finishReason);
-            console.error('[GeminiProvider] Safety Ratings:', JSON.stringify(candidate.safetyRatings, null, 2));
-            console.error('[GeminiProvider] Full Candidate:', JSON.stringify(candidate, null, 2));
-
-            throw new LLMServiceException(
-                `Model returned empty response. Finish Reason: ${candidate.finishReason}.`,
-                500
-            );
-        }
-
-        // Detailed logging as requested
-        // console.log('[GeminiProvider] generateContent response candidate:', JSON.stringify(candidate, null, 2));
-
-        // 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,
-            thought_signature: responseThoughtSignature, // Return signature to caller
-            tool_calls: toolCalls ? (Array.isArray(toolCalls) ? toolCalls : [toolCalls]).map(fc => ({
-                type: 'function',
-                function: fc,
-                thought_signature: fc.thought_signature
-            })) : 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)
-            } : {})
-        };
-    }
-
-
-    _buildGenerationConfig(options, maxTokens, temperature) {
-        const config = {
-            temperature: options.temperature ?? temperature,
-            maxOutputTokens: options.maxTokens ?? maxTokens,
-        };
-
-        // Handle responseFormat as an object with type and schema properties
-        if (options.responseFormat) {
-            const formatType = typeof options.responseFormat === 'string'
-                ? options.responseFormat
-                : options.responseFormat.type;
-
-            const schema = typeof options.responseFormat === 'object'
-                ? options.responseFormat.schema
-                : 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 (responseSchema)');
-                } else {
-                    console.warn('[GeminiProvider] Using legacy JSON mode without schema - may produce markdown wrappers');
-                }
-            }
-        }
-
-        return config;
-    }
-
-    _convertToGeminiSchema(jsonSchema) {
-        const convertType = (type) => {
-            switch (type) {
-                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';
-            }
-        };
-
-        const convert = (schema) => {
-            const result = {
-                type: convertType(schema.type),
-            };
-
-            if (schema.properties) {
-                result.properties = {};
-                for (const [key, value] of Object.entries(schema.properties)) {
-                    result.properties[key] = convert(value);
-                }
-            }
-
-            if (schema.items) {
-                result.items = convert(schema.items);
-            }
-
-            if (schema.required) {
-                result.required = schema.required;
-            }
-
-            if (schema.nullable) {
-                result.nullable = schema.nullable;
-            }
-
-            if (schema.description) {
-                result.description = schema.description;
-            }
-
-            return result;
-        };
-
-        return convert(jsonSchema);
-    }
-
-    _shouldAutoParse(options) {
-        return options.autoParse !== false; // Default true
-    }
-
-    _safeJsonParse(content) {
-        if (!content) return null;
-
-        // Use the robust JSON extractor that handles:
-        // - Markdown code blocks (```json ... ```)
-        // - Plain JSON objects
-        // - Over-escaped content (\\\\n instead of \\n)
-        // - Brace extraction as fallback
-        const parsed = extractJsonFromResponse(content);
-
-        if (!parsed) {
-            console.error('[GeminiProvider] Failed to extract valid JSON from response');
-            console.error('[GeminiProvider] Content preview:', content.substring(0, 200));
-        }
-
-        return parsed;
-    }
-
-    async executeTools(tool_calls, messages, tenantId, toolImplementations, env) {
-        const toolResults = await Promise.all(
-            tool_calls.map(async (toolCall, index) => {
-                const toolName = toolCall.function.name;
-                const tool = toolImplementations[toolName];
-                const tool_call_id = `gemini-tool-call-${index}`;
-                toolCall.id = tool_call_id;
-
-                // console.log(`[Tool Call] ${toolName} with arguments:`, toolCall.function.args);
-
-                if (!tool) {
-                    console.error(`[Tool Error] Tool '${toolName}' not found`);
-                    return { tool_call_id, output: JSON.stringify({ error: `Tool '${toolName}' not found.` }) };
-                }
-                try {
-                    const output = await tool(toolCall.function.args, { env, tenantId });
-                    // 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);
-                    return { tool_call_id, output: JSON.stringify({ error: `Error executing tool '${toolName}': ${error.message}` }) };
-                }
-            })
-        );
-        toolResults.forEach(result => messages.push({ role: 'tool', tool_call_id: result.tool_call_id, content: result.output }));
-    }
-
-    async imageGeneration(prompt, systemPrompt, options = {}) {
-        // Allow model override via options.model, otherwise use default from config
-        const modelName = options.model || this.models.image || 'gemini-3-pro-image-preview';
-        console.log(`[GeminiProvider] Generating image with model: ${modelName}`);
-
-        const generationConfig = {
-            responseModalities: ["IMAGE"],
-        };
-
-        if (options.aspectRatio) {
-            generationConfig.imageConfig = {
-                aspectRatio: options.aspectRatio
-            };
-        }
-
-        const parts = [{ text: prompt }];
-
-        if (options.images && options.images.length > 0) {
-            options.images.forEach(img => {
-                parts.push({
-                    inlineData: {
-                        data: img.data,
-                        mimeType: img.mimeType
-                    }
-                });
-            });
-        }
-
-        // Use the new @google/genai API
-        const requestOptions = {
-            model: modelName,
-            contents: [{
-                role: "user",
-                parts: parts
-            }],
-            config: generationConfig
-        };
-
-        if (systemPrompt) {
-            requestOptions.config.systemInstruction = { parts: [{ text: systemPrompt }] };
-        }
-
-        // 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) {
-            // Fallback: Check if it returned a URI or other format, or just text
-            const textPart = response.candidates?.[0]?.content?.parts?.find(p => p.text);
-            const candidate = response.candidates?.[0];
-
-            console.error('[GeminiProvider] Image generation failed (no image data)');
-            if (candidate) {
-                console.error('[GeminiProvider] Finish Reason:', candidate.finishReason);
-                console.error('[GeminiProvider] Safety Ratings:', JSON.stringify(candidate.safetyRatings, null, 2));
-                console.error('[GeminiProvider] Full Candidate:', JSON.stringify(candidate, null, 2));
-            }
-
-            if (textPart) {
-                console.warn('[GeminiProvider] Model returned text instead of image:', textPart.text);
-            }
-            throw new Error(`No image data in response. Finish Reason: ${candidate?.finishReason}`);
-        }
-
-        // Check for thought signature in the image part or any other part
-        let thoughtSignature = null;
-        if (imagePart.thought_signature || imagePart.thoughtSignature) {
-            thoughtSignature = imagePart.thought_signature || imagePart.thoughtSignature;
-        } else {
-            // Check other parts for standalone thought signature
-            const signaturePart = response.candidates?.[0]?.content?.parts?.find(p => p.thought_signature || p.thoughtSignature);
-            if (signaturePart) {
-                thoughtSignature = signaturePart.thought_signature || signaturePart.thoughtSignature;
-            }
-        }
-
-        // Safety: If thought signature is abnormally large (>50KB), replace with bypass token
-        // to prevent massive context usage (User reported 1.5MB signatures in some cases).
-        if (thoughtSignature && thoughtSignature.length > 50000) {
-            console.warn(`[GeminiProvider] ⚠️  Thought signature is abnormally large (${thoughtSignature.length} chars). Replacing with bypass token to save context.`);
-            thoughtSignature = "skip_thought_signature_validator";
-        }
-
-        return {
-            imageData: imagePart.inlineData.data,
-            mimeType: imagePart.inlineData.mimeType,
-            thought_signature: thoughtSignature
-        };
-    }
-
-    _getModelForTier(tier) {
-        return this.models[tier] || this.models.default;
-    }
-
-    async startVideoGeneration(prompt, images, modelName, systemPrompt, options = {}) {
-        // Use unified client for video generation
-        // 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: effectivePrompt,
-            config: {
-                durationSeconds: options.durationSeconds || 6,
-                aspectRatio: options.aspectRatio || '16:9',
-                numberOfVideos: 1,
-                // 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));
-
-        try {
-            const operation = await this.client.models.generateVideos(requestConfig);
-
-            // Store operation for later polling
-            this._pendingOperations.set(operation.name, operation);
-
-            return { operationName: operation.name };
-        } catch (error) {
-            console.error(`[GeminiProvider] startVideoGeneration failed (API Key: ${this._getMaskedApiKey()}):`, 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);
-
-        if (!operation) {
-            // If not in cache, we need to fetch it by name
-            operation = await this.client.models.getOperation(operationName);
-        }
-
-        // Refresh status
-        operation = await operation.get();
-
-        // Update cache
-        this._pendingOperations.set(operationName, operation);
-
-        const result = {
-            done: operation.done,
-            progress: operation.metadata?.progressPercent || 0,
-            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);
-
-            if (operation.error) {
-                console.error('[GeminiProvider] Video generation failed:', JSON.stringify(operation.error, null, 2));
-                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;
-    }
-}