@contentgrowth/llm-service 0.8.3 → 0.8.5

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

@@ -1,203 +0,0 @@
-import OpenAI from 'openai';
-import { BaseLLMProvider } from './base-provider.js';
-import { extractJsonFromResponse } from '../json-utils.js';
-import { LLMServiceException } from '../../llm-service.js';
-
-export class OpenAIProvider extends BaseLLMProvider {
-    constructor(config) {
-        super(config);
-        this.client = new OpenAI({ apiKey: config.apiKey });
-        this.models = config.models;
-        this.defaultModel = config.models.default;
-    }
-
-    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 = {}) {
-        const requestPayload = {
-            model: modelName,
-            temperature: options.temperature ?? temperature,
-            max_tokens: options.maxTokens ?? maxTokens,
-            messages: [{ role: 'system', content: systemPrompt }, ...messages],
-            tools: tools,
-            tool_choice: tools ? 'auto' : undefined,
-        };
-
-        // Add JSON mode support if requested
-        if (options.responseFormat) {
-            requestPayload.response_format = this._buildResponseFormat(options);
-        }
-
-        let response;
-        try {
-            response = await this.client.chat.completions.create(requestPayload);
-        } catch (error) {
-            console.error(`[OpenAIProvider] chat completion failed (API Key: ${this._getMaskedApiKey()}):`, error);
-            throw error;
-        }
-        const message = response.choices[0].message;
-
-        // Validate that we have EITHER content OR tool calls
-        if (!message.content && (!message.tool_calls || message.tool_calls.length === 0)) {
-            console.error('[OpenAIProvider] Model returned empty response (no text, no tool calls)');
-            throw new LLMServiceException(
-                'Model returned empty response. This usually means the prompt or schema is confusing the model.',
-                500
-            );
-        }
-
-        // 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
-            ...(options.responseFormat && this._shouldAutoParse(options) ? {
-                parsedContent: this._safeJsonParse(message.content)
-            } : {})
-        };
-    }
-
-    _buildResponseFormat(options) {
-        if (!options.responseFormat) {
-            return undefined;
-        }
-
-        // Handle responseFormat as either string or object { type, schema }
-        const formatType = typeof options.responseFormat === 'string'
-            ? options.responseFormat
-            : options.responseFormat.type;
-
-        const schema = typeof options.responseFormat === 'object'
-            ? options.responseFormat.schema
-            : options.responseSchema || null;
-
-        switch (formatType) {
-            case 'json':
-                // If schema is provided, use strict mode; otherwise use legacy json_object
-                if (schema) {
-                    console.log('[OpenAIProvider] Using Strict JSON mode with schema');
-                    return {
-                        type: 'json_schema',
-                        json_schema: {
-                            name: options.schemaName || 'response_schema',
-                            strict: options.strictSchema ?? true,
-                            schema: schema
-                        }
-                    };
-                } else {
-                    console.warn('[OpenAIProvider] Using legacy json_object mode without schema - may produce markdown wrappers');
-                    return { type: 'json_object' };
-                }
-
-            case 'json_schema':
-                if (!schema) {
-                    throw new Error('responseSchema required when using json_schema format');
-                }
-                console.log('[OpenAIProvider] Using Strict JSON mode with schema');
-                return {
-                    type: 'json_schema',
-                    json_schema: {
-                        name: options.schemaName || 'response_schema',
-                        strict: options.strictSchema ?? true,
-                        schema: schema
-                    }
-                };
-
-            default:
-                return undefined;
-        }
-    }
-
-    _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.log('[OpenAIProvider] Successfully parsed JSON from response');
-        } else {
-            console.error('[OpenAIProvider] Failed to extract valid JSON from response');
-            console.error('[OpenAIProvider] 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) => {
-                const toolName = toolCall.function.name;
-                const tool = toolImplementations[toolName];
-
-                console.log(`[Tool Call] ${toolName} with arguments:`, toolCall.function.arguments);
-
-                if (!tool) {
-                    console.error(`[Tool Error] Tool '${toolName}' not found`);
-                    return { tool_call_id: toolCall.id, output: JSON.stringify({ error: `Tool '${toolName}' not found.` }) };
-                }
-                try {
-                    const output = await tool(toolCall.function.arguments, { env, tenantId });
-                    console.log(`[Tool Result] ${toolName} returned:`, output.substring(0, 200) + (output.length > 200 ? '...' : ''));
-                    return { tool_call_id: toolCall.id, output };
-                } catch (error) {
-                    console.error(`[Tool Error] ${toolName} failed:`, error.message);
-                    return { tool_call_id: toolCall.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 }));
-    }
-
-    _getModelForTier(tier) {
-        return this.models[tier] || this.models.default;
-    }
-
-    async videoGeneration(prompt, images, modelName, systemPrompt, options = {}) {
-        throw new Error('Video generation is not supported by OpenAI provider yet.');
-    }
-}

package/src/llm-service.js

@@ -1,281 +0,0 @@
-import { ConfigManager } from './llm/config-manager.js';
-import { OpenAIProvider } from './llm/providers/openai-provider.js';
-import { GeminiProvider } from './llm/providers/gemini-provider.js';
-
-/**
- * LLM Service Module
- * 
- * This module provides a unified interface for interacting with different LLM providers.
- * It now supports BYOK (Bring Your Own Key) via Tenant Configuration.
- */
-export class LLMService {
-    constructor(env, toolImplementations = {}) {
-        this.env = env;
-        this.toolImplementations = toolImplementations;
-        // Cache for provider instances to avoid recreation within the same request if possible
-        this.providerCache = new Map();
-    }
-
-    async _getProvider(tenantId) {
-        // Check cache first
-        const cacheKey = tenantId || 'system';
-        if (this.providerCache.has(cacheKey)) {
-            return this.providerCache.get(cacheKey);
-        }
-
-        const config = await ConfigManager.getConfig(tenantId, this.env);
-
-        if (!config.apiKey) {
-            throw new LLMServiceException(`LLM service is not configured for ${config.provider}. Missing API Key.`, 500);
-        }
-
-        let provider;
-        if (config.provider === 'openai') {
-            provider = new OpenAIProvider(config);
-        } else if (config.provider === 'gemini') {
-            provider = new GeminiProvider(config);
-        } else {
-            throw new LLMServiceException(`Unsupported LLM provider: ${config.provider}`, 500);
-        }
-
-        this.providerCache.set(cacheKey, provider);
-        return provider;
-    }
-
-    /**
-     * Check if LLM service is configured for a tenant (or system default)
-     */
-    async isConfigured(tenantId) {
-        const config = await ConfigManager.getConfig(tenantId, this.env);
-        return !!config.apiKey;
-    }
-
-    /**
-     * Simple chat interface for single-turn conversations
-     */
-    async chat(userMessage, tenantId, systemPrompt = '', options = {}) {
-        const provider = await this._getProvider(tenantId);
-        return provider.chat(userMessage, systemPrompt, options);
-    }
-
-    /**
-     * Interact with LLM for generation
-     * 
-     * Intelligent signature detection supports:
-     * - chatCompletion(messages, tenantId, systemPrompt)
-     * - chatCompletion(messages, tenantId, systemPrompt, tools)
-     * - chatCompletion(messages, tenantId, systemPrompt, options)
-     * - chatCompletion(messages, tenantId, systemPrompt, tools, options)
-     * 
-     * @param {Array} messages - Conversation messages
-     * @param {string} tenantId - Tenant identifier
-     * @param {string} systemPrompt - System instructions
-     * @param {Array|Object} toolsOrOptions - Tools array or options object
-     * @param {Object} optionsParam - Options object (if tools provided)
-     * @returns {Object} Response with content, tool_calls, and optionally parsedContent
-     */
-    async chatCompletion(messages, tenantId, systemPrompt, toolsOrOptions = null, optionsParam = {}) {
-        const provider = await this._getProvider(tenantId);
-
-        if (!systemPrompt?.trim()) {
-            throw new LLMServiceException('No prompt set for bot', 503);
-        }
-
-        // Intelligent parameter detection
-        const { tools, options } = this._parseToolsAndOptions(toolsOrOptions, optionsParam);
-
-        return provider.chatCompletion(messages, systemPrompt, tools, options);
-    }
-
-    /**
-     * Helper to intelligently detect tools vs options parameters
-     * @private
-     */
-    _parseToolsAndOptions(param1, param2) {
-        // If param1 is null/undefined, use defaults
-        if (param1 === null || param1 === undefined) {
-            return { tools: null, options: param2 || {} };
-        }
-
-        // If param1 is an array, it's tools
-        if (Array.isArray(param1)) {
-            return { tools: param1, options: param2 || {} };
-        }
-
-        // If param1 is an object, check if it looks like options or tools
-        if (typeof param1 === 'object') {
-            // Check for known options keys
-            const optionsKeys = ['responseFormat', 'responseSchema', 'temperature', 'maxTokens', 'tier', 'autoParse', 'strictSchema', 'schemaName'];
-            const hasOptionsKeys = optionsKeys.some(key => key in param1);
-
-            if (hasOptionsKeys) {
-                // param1 is options
-                return { tools: null, options: param1 };
-            }
-
-            // Could be tools in object format (legacy support)
-            // Treat as tools if it doesn't have options keys
-            return { tools: param1, options: param2 || {} };
-        }
-
-        // Default: treat as tools
-        return { tools: param1, options: param2 || {} };
-    }
-
-    /**
-     * Convenience method for JSON-only responses
-     * Automatically enables JSON mode and returns parsed object
-     * 
-     * @param {Array} messages - Conversation messages
-     * @param {string} tenantId - Tenant identifier
-     * @param {string} systemPrompt - System instructions
-     * @param {Object} schema - Optional JSON schema for validation
-     * @param {Array} tools - Optional tools array
-     * @returns {Object} Parsed JSON object
-     * @throws {LLMServiceException} If JSON parsing fails
-     */
-    async chatCompletionJson(messages, tenantId, systemPrompt, schema = null, tools = null) {
-        const options = {
-            responseFormat: schema ? { type: 'json_schema', schema } : 'json',
-            autoParse: true
-        };
-
-        const response = await this.chatCompletion(messages, tenantId, systemPrompt, tools, options);
-
-        // Return parsed content directly or throw if parsing failed
-        if (response.parsedContent !== null && response.parsedContent !== undefined) {
-            return response.parsedContent;
-        }
-
-        // Fallback: try to parse the raw content
-        try {
-            return JSON.parse(response.content);
-        } catch (e) {
-            throw new LLMServiceException(
-                'LLM returned invalid JSON despite JSON mode being enabled',
-                500,
-                { rawContent: response.content, parseError: e.message }
-            );
-        }
-    }
-
-    async chatWithTools(messages, tenantId, systemPrompt, tools = [], options = {}) {
-        const provider = await this._getProvider(tenantId);
-
-        let currentMessages = [...messages];
-        const MAX_ITERATIONS = 10; // Prevent infinite loops
-        let iteration = 0;
-
-        // Initial call
-        const initialResponse = await provider.chatCompletion(
-            currentMessages,
-            systemPrompt,
-            tools,
-            options
-        );
-
-        let { content, tool_calls, parsedContent, finishReason, _rawFinishReason } = initialResponse;
-
-        // Tool execution loop with safety limit
-        while (tool_calls && iteration < MAX_ITERATIONS) {
-            iteration++;
-            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)
-            await provider.executeTools(tool_calls, currentMessages, tenantId, this.toolImplementations, this.env);
-
-            // Next call
-            const nextResponse = await provider.chatCompletion(
-                currentMessages,
-                systemPrompt,
-                tools,
-                options
-            );
-
-            content = nextResponse.content;
-            tool_calls = nextResponse.tool_calls;
-            parsedContent = nextResponse.parsedContent; // Preserve parsedContent from final response
-            finishReason = nextResponse.finishReason; // Preserve finishReason from final response
-            _rawFinishReason = nextResponse._rawFinishReason; // Preserve raw finish reason for debugging
-        }
-
-        if (iteration >= MAX_ITERATIONS) {
-            console.warn(`[Tool Call] Reached maximum iterations (${MAX_ITERATIONS}). Forcing completion.`);
-        }
-
-        // Return both content and parsedContent (if available)
-        return { content, parsedContent, toolCalls: tool_calls, finishReason, _rawFinishReason };
-    }
-
-    /**
-     * Generate a video (async wrapper with polling - backward compatibility)
-     */
-    async videoGeneration(prompt, images, tenantId, modelName, systemPrompt, options = {}) {
-        const { operationName } = await this.startVideoGeneration(prompt, images, tenantId, modelName, systemPrompt, options);
-
-        let status = await this.getVideoGenerationStatus(operationName, tenantId);
-
-        while (!status.done) {
-            console.log(`Waiting for video generation... Progress: ${status.progress}%`);
-            await new Promise(resolve => setTimeout(resolve, 10000)); // Wait 10 seconds
-            status = await this.getVideoGenerationStatus(operationName, tenantId);
-        }
-
-        if (status.error) {
-            throw new Error(`Video generation failed: ${status.error.message || JSON.stringify(status.error)}`);
-        }
-
-        return {
-            content: status.content || "Video generation completed.",
-            videoUri: status.videoUri
-        };
-    }
-
-    /**
-     * Start video generation (returns operation name for polling)
-     */
-    async startVideoGeneration(prompt, images, tenantId, modelName, systemPrompt, options = {}) {
-        const provider = await this._getProvider(tenantId);
-        return provider.startVideoGeneration(prompt, images, modelName, systemPrompt, options);
-    }
-
-    /**
-     * Get video generation status
-     */
-    async getVideoGenerationStatus(operationName, tenantId) {
-        const provider = await this._getProvider(tenantId);
-        return provider.getVideoGenerationStatus(operationName);
-    }
-
-    /**
-     * Generate an image
-     * Falls back to system keys if tenant doesn't have image capability enabled
-     * @param {string} prompt - Text description of the image
-     * @param {string} tenantId - Tenant identifier
-     * @param {string} systemPrompt - System instructions for generation
-     * @param {Object} options - Generation options (aspectRatio, images, etc.)
-     */
-    async imageGeneration(prompt, tenantId, systemPrompt, options = {}) {
-        // Check if tenant has image capability enabled
-        if (tenantId) {
-            const config = await ConfigManager.getConfig(tenantId, this.env);
-            if (config.isTenantOwned && !config.capabilities?.image) {
-                console.log(`[LLMService] Tenant ${tenantId} BYOK doesn't have image capability. Using system keys.`);
-                tenantId = null; // Fall back to system
-            }
-        }
-
-        const provider = await this._getProvider(tenantId);
-        return provider.imageGeneration(prompt, systemPrompt, options);
-    }
-}
-
-export class LLMServiceException extends Error {
-    constructor(message, statusCode = 500, details = null) {
-        super(message);
-        this.name = 'LLMServiceException';
-        this.statusCode = statusCode;
-        this.details = details || {};
-    }
-}

package/src/utils/error-handler.js

@@ -1,117 +0,0 @@
-/**
- * Error Handling Utility for LLM Service
- * Provides centralized error parsing and user-friendly message generation.
- * Returns plain objects - framework-specific response handling is done by consumers.
- */
-
-/**
- * Parse an error and return a standardized error response object.
- * Detects specific error types like service overload, rate limits, and input issues.
- * 
- * @param {Error} error - The caught error
- * @param {string} operation - The operation being performed (e.g., 'generate image', 'edit article')
- * @param {string} context - Context for logging (e.g., 'image_generation', 'ai_edit')
- * @returns {{ message: string, error: string, retryable: boolean, statusCode: number }}
- */
-export function handleApiError(error, operation = 'complete this operation', context = 'api') {
-  console.error(`[${context}] Error:`, error);
-
-  const errorMessage = error.message?.toLowerCase() || '';
-  const errorString = JSON.stringify(error).toLowerCase();
-
-  // Check for model overload (503)
-  if (errorMessage.includes('overloaded') || errorMessage.includes('503') ||
-    errorString.includes('unavailable') || errorString.includes('overloaded')) {
-    return {
-      message: 'AI service is busy. Please try again.',
-      error: 'service_overloaded',
-      retryable: true,
-      statusCode: 503
-    };
-  }
-
-  // Check for rate limiting (429)
-  if (errorMessage.includes('quota') || errorMessage.includes('429') ||
-    errorMessage.includes('too many requests') || errorMessage.includes('rate limit') ||
-    errorString.includes('resource_exhausted')) {
-    return {
-      message: 'Too many requests. Please try again later.',
-      error: 'rate_limited',
-      retryable: true,
-      statusCode: 429
-    };
-  }
-
-  // Check for context length / input too long
-  if (errorMessage.includes('context length') || errorMessage.includes('too long') ||
-    errorString.includes('invalid_argument')) {
-    return {
-      message: 'Content too big. Try making focused edits.',
-      error: 'input_too_long',
-      retryable: false,
-      statusCode: 422
-    };
-  }
-
-  // Check for user quota exceeded (from our own quota system)
-  if (errorMessage.includes('quotaerror') || errorMessage.includes('quota_exceeded')) {
-    return {
-      message: 'You have reached your usage limit for this month. Please upgrade your plan to continue.',
-      error: 'user_quota_exceeded',
-      retryable: false,
-      statusCode: 402
-    };
-  }
-
-  // Check for trial limitation errors
-  if (errorMessage.includes('trial')) {
-    return {
-      message: 'This feature is not available during the free trial. Please upgrade to use this feature.',
-      error: 'trial_limitation',
-      retryable: false,
-      statusCode: 402
-    };
-  }
-
-  // Check for authentication/configuration errors
-  if (errorMessage.includes('api key') || errorMessage.includes('authentication') || errorMessage.includes('unauthorized')) {
-    return {
-      message: 'Service is not available at this time. Please contact support.',
-      error: 'not_configured',
-      retryable: false,
-      statusCode: 503
-    };
-  }
-
-  // Check for invalid input errors
-  if (errorMessage.includes('invalid') || errorMessage.includes('bad request')) {
-    return {
-      message: 'Invalid request. Please check your input and try again.',
-      error: 'invalid_input',
-      retryable: false,
-      statusCode: 400
-    };
-  }
-
-  // Default error
-  return {
-    message: `An error occurred while trying to ${operation}. Please try again.`,
-    error: 'operation_failed',
-    retryable: true,
-    statusCode: 500
-  };
-}
-
-/**
- * Sanitize error messages to prevent leaking technical details.
- * Returns an Error with a clean error code that can be handled by the API layer.
- * Use this when you want to throw an error rather than return a JSON response.
- * 
- * @param {Error} error - The original error
- * @param {string} context - Context of where error occurred (e.g., 'image_generation', 'ai_edit')
- * @returns {Error} - Sanitized error with clean message code
- */
-export function sanitizeError(error, context = 'general') {
-  const result = handleApiError(error, 'complete this operation', context);
-  return new Error(result.error);
-}