genai-lite 0.2.0 → 0.2.1

package/dist/llm/LLMService.js

@@ -9,6 +9,7 @@ exports.LLMService = void 0;
 const MockClientAdapter_1 = require("./clients/MockClientAdapter");
 const config_1 = require("./config");
 const presets_json_1 = __importDefault(require("../config/presets.json"));
+const template_1 = require("../prompting/template");
 /**
  * Main process service for LLM operations
  *
@@ -106,65 +107,34 @@ class LLMService {
      * @returns Promise resolving to either success or failure response
      */
     async sendMessage(request) {
-        console.log(`LLMService.sendMessage called for provider: ${request.providerId}, model: ${request.modelId}`);
+        console.log(`LLMService.sendMessage called with presetId: ${request.presetId}, provider: ${request.providerId}, model: ${request.modelId}`);
         try {
-            // Validate provider
-            if (!(0, config_1.isProviderSupported)(request.providerId)) {
-                console.warn(`Unsupported provider in sendMessage: ${request.providerId}`);
-                return {
-                    provider: request.providerId,
-                    model: request.modelId,
-                    error: {
-                        message: `Unsupported provider: ${request.providerId}. Supported providers: ${config_1.SUPPORTED_PROVIDERS.map((p) => p.id).join(", ")}`,
-                        code: "UNSUPPORTED_PROVIDER",
-                        type: "validation_error",
-                    },
-                    object: "error",
-                };
-            }
-            // Validate model
-            if (!(0, config_1.isModelSupported)(request.modelId, request.providerId)) {
-                const availableModels = (0, config_1.getModelsByProvider)(request.providerId).map((m) => m.id);
-                console.warn(`Unsupported model ${request.modelId} for provider ${request.providerId}. Available: ${availableModels.join(", ")}`);
-                return {
-                    provider: request.providerId,
-                    model: request.modelId,
-                    error: {
-                        message: `Unsupported model: ${request.modelId} for provider: ${request.providerId}. Available models: ${availableModels.join(", ")}`,
-                        code: "UNSUPPORTED_MODEL",
-                        type: "validation_error",
-                    },
-                    object: "error",
-                };
-            }
-            // Get model info for additional validation or settings
-            const modelInfo = (0, config_1.getModelById)(request.modelId, request.providerId);
-            if (!modelInfo) {
-                // This shouldn't happen if validation above passed, but defensive programming
-                console.error(`Model info not found for validated model: ${request.modelId}`);
-                return {
-                    provider: request.providerId,
-                    model: request.modelId,
-                    error: {
-                        message: `Internal error: Model configuration not found for ${request.modelId}`,
-                        code: "MODEL_CONFIG_ERROR",
-                        type: "internal_error",
-                    },
-                    object: "error",
-                };
+            // Resolve model information from preset or direct IDs
+            const resolved = this.resolveModelInfo(request);
+            if (resolved.error) {
+                return resolved.error;
             }
+            const { providerId, modelId, modelInfo, settings: resolvedSettings } = resolved;
+            // Create a proper LLMChatRequest with resolved values
+            const resolvedRequest = {
+                ...request,
+                providerId: providerId,
+                modelId: modelId,
+            };
+            // Provider and model validation already done by resolveModelInfo
             // Validate basic request structure
-            const structureValidationResult = this.validateRequestStructure(request);
+            const structureValidationResult = this.validateRequestStructure(resolvedRequest);
             if (structureValidationResult) {
                 return structureValidationResult;
             }
-            // Validate settings if provided
-            if (request.settings) {
-                const settingsValidationErrors = (0, config_1.validateLLMSettings)(request.settings);
+            // Validate settings if provided  
+            const combinedSettings = { ...resolvedSettings, ...request.settings };
+            if (combinedSettings) {
+                const settingsValidationErrors = (0, config_1.validateLLMSettings)(combinedSettings);
                 if (settingsValidationErrors.length > 0) {
                     return {
-                        provider: request.providerId,
-                        model: request.modelId,
+                        provider: providerId,
+                        model: modelId,
                         error: {
                             message: `Invalid settings: ${settingsValidationErrors.join(", ")}`,
                             code: "INVALID_SETTINGS",
@@ -175,11 +145,16 @@ class LLMService {
                 }
             }
             // Apply model-specific defaults and merge with user settings
-            const finalSettings = this.mergeSettingsForModel(request.modelId, request.providerId, request.settings);
+            const finalSettings = this.mergeSettingsForModel(modelId, providerId, combinedSettings);
+            // Validate reasoning settings for model capabilities
+            const reasoningValidation = this.validateReasoningSettings(modelInfo, finalSettings.reasoning, resolvedRequest);
+            if (reasoningValidation) {
+                return reasoningValidation;
+            }
             // Filter out unsupported parameters based on model and provider configuration
             let filteredSettings = { ...finalSettings }; // Create a mutable copy
             // Get provider info for parameter filtering (modelInfo is already available from earlier validation)
-            const providerInfo = (0, config_1.getProviderById)(request.providerId);
+            const providerInfo = (0, config_1.getProviderById)(providerId);
             const paramsToExclude = new Set();
             // Add provider-level exclusions
             if (providerInfo?.unsupportedParameters) {
@@ -190,7 +165,7 @@ class LLMService {
                 modelInfo.unsupportedParameters.forEach((param) => paramsToExclude.add(param));
             }
             if (paramsToExclude.size > 0) {
-                console.log(`LLMService: Potential parameters to exclude for provider '${request.providerId}', model '${request.modelId}':`, Array.from(paramsToExclude));
+                console.log(`LLMService: Potential parameters to exclude for provider '${providerId}', model '${modelId}':`, Array.from(paramsToExclude));
             }
             paramsToExclude.forEach((param) => {
                 // Check if the parameter key actually exists in filteredSettings before trying to delete
@@ -199,53 +174,59 @@ class LLMService {
                 // For direct properties of an object, hasOwnProperty is more specific.
                 // Given finalSettings is Required<LLMSettings>, all keys should be present, potentially as undefined.
                 if (param in filteredSettings) {
-                    console.log(`LLMService: Removing excluded parameter '${String(param)}' for provider '${request.providerId}', model '${request.modelId}'. Value was:`, filteredSettings[param]);
+                    console.log(`LLMService: Removing excluded parameter '${String(param)}' for provider '${providerId}', model '${modelId}'. Value was:`, filteredSettings[param]);
                     delete filteredSettings[param]; // Cast to allow deletion
                 }
                 else {
                     // This case should ideally not happen if finalSettings truly is Required<LLMSettings>
                     // and mergeSettingsForModel ensures all keys are present (even if undefined).
-                    console.log(`LLMService: Parameter '${String(param)}' marked for exclusion was not found in settings for provider '${request.providerId}', model '${request.modelId}'.`);
+                    console.log(`LLMService: Parameter '${String(param)}' marked for exclusion was not found in settings for provider '${providerId}', model '${modelId}'.`);
                 }
             });
+            // Handle reasoning settings for models that don't support it
+            // This happens after validateReasoningSettings so we know it's safe to strip
+            if (!modelInfo.reasoning?.supported && filteredSettings.reasoning) {
+                console.log(`LLMService: Removing reasoning settings for non-reasoning model ${modelId}`);
+                delete filteredSettings.reasoning;
+            }
             const internalRequest = {
-                ...request,
+                ...resolvedRequest,
                 settings: filteredSettings,
             };
             console.log(`Processing LLM request with (potentially filtered) settings:`, {
-                provider: request.providerId,
-                model: request.modelId,
+                provider: providerId,
+                model: modelId,
                 settings: filteredSettings,
-                messageCount: request.messages.length,
+                messageCount: resolvedRequest.messages.length,
             });
-            console.log(`Processing LLM request: ${request.messages.length} messages, model: ${request.modelId}`);
+            console.log(`Processing LLM request: ${resolvedRequest.messages.length} messages, model: ${modelId}`);
             // Get client adapter
-            const clientAdapter = this.getClientAdapter(request.providerId);
+            const clientAdapter = this.getClientAdapter(providerId);
             // Use ApiKeyProvider to get the API key and make the request
             try {
-                const apiKey = await this.getApiKey(request.providerId);
+                const apiKey = await this.getApiKey(providerId);
                 if (!apiKey) {
                     return {
-                        provider: request.providerId,
-                        model: request.modelId,
+                        provider: providerId,
+                        model: modelId,
                         error: {
-                            message: `API key for provider '${request.providerId}' could not be retrieved. Ensure your ApiKeyProvider is configured correctly.`,
+                            message: `API key for provider '${providerId}' could not be retrieved. Ensure your ApiKeyProvider is configured correctly.`,
                             code: "API_KEY_ERROR",
                             type: "authentication_error",
                         },
                         object: "error",
                     };
                 }
-                console.log(`Making LLM request with ${clientAdapter.constructor.name} for provider: ${request.providerId}`);
+                console.log(`Making LLM request with ${clientAdapter.constructor.name} for provider: ${providerId}`);
                 const result = await clientAdapter.sendMessage(internalRequest, apiKey);
-                console.log(`LLM request completed successfully for model: ${request.modelId}`);
+                console.log(`LLM request completed successfully for model: ${modelId}`);
                 return result;
             }
             catch (error) {
                 console.error("Error in LLMService.sendMessage:", error);
                 return {
-                    provider: request.providerId,
-                    model: request.modelId,
+                    provider: providerId,
+                    model: modelId,
                     error: {
                         message: error instanceof Error
                             ? error.message
@@ -261,8 +242,8 @@ class LLMService {
         catch (error) {
             console.error("Error in LLMService.sendMessage (outer):", error);
             return {
-                provider: request.providerId,
-                model: request.modelId,
+                provider: request.providerId || request.presetId || 'unknown',
+                model: request.modelId || request.presetId || 'unknown',
                 error: {
                     message: error instanceof Error
                         ? error.message
@@ -287,8 +268,8 @@ class LLMService {
             !Array.isArray(request.messages) ||
             request.messages.length === 0) {
             return {
-                provider: request.providerId,
-                model: request.modelId,
+                provider: request.providerId || request.presetId || 'unknown',
+                model: request.modelId || request.presetId || 'unknown',
                 error: {
                     message: "Request must contain at least one message",
                     code: "INVALID_REQUEST",
@@ -302,8 +283,8 @@ class LLMService {
             const message = request.messages[i];
             if (!message.role || !message.content) {
                 return {
-                    provider: request.providerId,
-                    model: request.modelId,
+                    provider: request.providerId || ('presetId' in request ? request.presetId : undefined) || 'unknown',
+                    model: request.modelId || ('presetId' in request ? request.presetId : undefined) || 'unknown',
                     error: {
                         message: `Message at index ${i} must have both 'role' and 'content' properties`,
                         code: "INVALID_MESSAGE",
@@ -314,8 +295,8 @@ class LLMService {
             }
             if (!["user", "assistant", "system"].includes(message.role)) {
                 return {
-                    provider: request.providerId,
-                    model: request.modelId,
+                    provider: request.providerId || ('presetId' in request ? request.presetId : undefined) || 'unknown',
+                    model: request.modelId || ('presetId' in request ? request.presetId : undefined) || 'unknown',
                     error: {
                         message: `Invalid message role '${message.role}' at index ${i}. Must be 'user', 'assistant', or 'system'`,
                         code: "INVALID_MESSAGE_ROLE",
@@ -327,6 +308,42 @@ class LLMService {
         }
         return null; // Request is valid
     }
+    /**
+     * Validates reasoning settings against model capabilities
+     *
+     * @param modelInfo - The model information
+     * @param reasoning - The reasoning settings to validate
+     * @param request - The original request for error context
+     * @returns LLMFailureResponse if validation fails, null if valid
+     */
+    validateReasoningSettings(modelInfo, reasoning, request) {
+        // If no reasoning settings provided, nothing to validate
+        if (!reasoning) {
+            return null;
+        }
+        // If model doesn't support reasoning
+        if (!modelInfo.reasoning?.supported) {
+            // Check if user is trying to enable reasoning
+            const tryingToEnableReasoning = reasoning.enabled === true ||
+                reasoning.effort !== undefined ||
+                (reasoning.maxTokens !== undefined && reasoning.maxTokens > 0);
+            if (tryingToEnableReasoning) {
+                return {
+                    provider: request.providerId,
+                    model: request.modelId,
+                    error: {
+                        message: `Model ${request.modelId} does not support reasoning/thinking`,
+                        type: 'validation_error',
+                        code: 'reasoning_not_supported'
+                    },
+                    object: 'error'
+                };
+            }
+            // Otherwise, user is explicitly disabling reasoning - this is fine
+            // The reasoning settings will be stripped later
+        }
+        return null;
+    }
     /**
      * Merges request settings with model-specific and global defaults
      *
@@ -351,6 +368,10 @@ class LLMService {
                 modelDefaults.supportsSystemMessage,
             geminiSafetySettings: requestSettings?.geminiSafetySettings ??
                 modelDefaults.geminiSafetySettings,
+            reasoning: {
+                ...modelDefaults.reasoning,
+                ...requestSettings?.reasoning,
+            },
         };
         // Log the final settings for debugging
         console.log(`Merged settings for ${providerId}/${modelId}:`, {
@@ -362,6 +383,7 @@ class LLMService {
             presencePenalty: mergedSettings.presencePenalty,
             hasUser: !!mergedSettings.user,
             geminiSafetySettingsCount: mergedSettings.geminiSafetySettings.length,
+            reasoning: mergedSettings.reasoning,
         });
         return mergedSettings;
     }
@@ -439,5 +461,196 @@ class LLMService {
     getPresets() {
         return [...this.presets]; // Return a copy to prevent external modification
     }
+    /**
+     * Resolves model information from either a preset ID or provider/model IDs
+     *
+     * @private
+     * @param options Options containing either presetId or providerId/modelId
+     * @returns Resolved model info and settings or error response
+     */
+    resolveModelInfo(options) {
+        // If presetId is provided, use it
+        if (options.presetId) {
+            const preset = this.presets.find(p => p.id === options.presetId);
+            if (!preset) {
+                return {
+                    error: {
+                        provider: 'unknown',
+                        model: 'unknown',
+                        error: {
+                            message: `Preset not found: ${options.presetId}`,
+                            code: 'PRESET_NOT_FOUND',
+                            type: 'validation_error',
+                        },
+                        object: 'error',
+                    }
+                };
+            }
+            const modelInfo = (0, config_1.getModelById)(preset.modelId, preset.providerId);
+            if (!modelInfo) {
+                return {
+                    error: {
+                        provider: preset.providerId,
+                        model: preset.modelId,
+                        error: {
+                            message: `Model not found for preset: ${options.presetId}`,
+                            code: 'MODEL_NOT_FOUND',
+                            type: 'validation_error',
+                        },
+                        object: 'error',
+                    }
+                };
+            }
+            // Merge preset settings with user settings
+            const settings = {
+                ...preset.settings,
+                ...options.settings
+            };
+            return {
+                providerId: preset.providerId,
+                modelId: preset.modelId,
+                modelInfo,
+                settings
+            };
+        }
+        // Otherwise, use providerId and modelId
+        if (!options.providerId || !options.modelId) {
+            return {
+                error: {
+                    provider: options.providerId || 'unknown',
+                    model: options.modelId || 'unknown',
+                    error: {
+                        message: 'Either presetId or both providerId and modelId must be provided',
+                        code: 'INVALID_MODEL_SELECTION',
+                        type: 'validation_error',
+                    },
+                    object: 'error',
+                }
+            };
+        }
+        // Check if provider is supported first
+        if (!(0, config_1.isProviderSupported)(options.providerId)) {
+            return {
+                error: {
+                    provider: options.providerId,
+                    model: options.modelId,
+                    error: {
+                        message: `Unsupported provider: ${options.providerId}. Supported providers: ${config_1.SUPPORTED_PROVIDERS.map((p) => p.id).join(', ')}`,
+                        code: 'UNSUPPORTED_PROVIDER',
+                        type: 'validation_error',
+                    },
+                    object: 'error',
+                }
+            };
+        }
+        const modelInfo = (0, config_1.getModelById)(options.modelId, options.providerId);
+        if (!modelInfo) {
+            return {
+                error: {
+                    provider: options.providerId,
+                    model: options.modelId,
+                    error: {
+                        message: `Unsupported model: ${options.modelId} for provider: ${options.providerId}`,
+                        code: 'UNSUPPORTED_MODEL',
+                        type: 'validation_error',
+                    },
+                    object: 'error',
+                }
+            };
+        }
+        return {
+            providerId: options.providerId,
+            modelId: options.modelId,
+            modelInfo,
+            settings: options.settings
+        };
+    }
+    /**
+     * Prepares messages with model context for template rendering
+     *
+     * This method resolves model information from either a preset or direct provider/model IDs,
+     * then renders a template with model context variables injected, or returns pre-built messages
+     * with the model context separately.
+     *
+     * @param options Options for preparing messages
+     * @returns Promise resolving to prepared messages and model context
+     *
+     * @example
+     * ```typescript
+     * const { messages } = await llm.prepareMessage({
+     *   template: 'Help me {{ thinking_enabled ? "think through" : "solve" }} this: {{ problem }}',
+     *   variables: { problem: 'complex algorithm' },
+     *   presetId: 'anthropic-claude-3-7-sonnet-20250219-thinking'
+     * });
+     * ```
+     */
+    async prepareMessage(options) {
+        console.log('LLMService.prepareMessage called');
+        // Validate input
+        if (!options.template && !options.messages) {
+            return {
+                provider: 'unknown',
+                model: 'unknown',
+                error: {
+                    message: 'Either template or messages must be provided',
+                    code: 'INVALID_INPUT',
+                    type: 'validation_error',
+                },
+                object: 'error',
+            };
+        }
+        // Resolve model information
+        const resolved = this.resolveModelInfo(options);
+        if (resolved.error) {
+            return resolved.error;
+        }
+        const { providerId, modelId, modelInfo, settings } = resolved;
+        // Merge settings with model defaults
+        const mergedSettings = this.mergeSettingsForModel(modelId, providerId, settings);
+        // Create model context
+        const modelContext = {
+            thinking_enabled: !!(modelInfo.reasoning?.supported &&
+                (mergedSettings.reasoning?.enabled === true ||
+                    (modelInfo.reasoning?.enabledByDefault && mergedSettings.reasoning?.enabled !== false))),
+            thinking_available: !!modelInfo.reasoning?.supported,
+            model_id: modelId,
+            provider_id: providerId,
+            reasoning_effort: mergedSettings.reasoning?.effort,
+            reasoning_max_tokens: mergedSettings.reasoning?.maxTokens,
+        };
+        // Prepare messages
+        let messages;
+        if (options.template) {
+            // Render template with variables and model context
+            const allVariables = {
+                ...options.variables,
+                ...modelContext, // Inject model context at root level
+            };
+            try {
+                const content = (0, template_1.renderTemplate)(options.template, allVariables);
+                messages = [{ role: 'user', content }];
+            }
+            catch (error) {
+                return {
+                    provider: providerId,
+                    model: modelId,
+                    error: {
+                        message: `Template rendering failed: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                        code: 'TEMPLATE_ERROR',
+                        type: 'validation_error',
+                    },
+                    object: 'error',
+                };
+            }
+        }
+        else {
+            // Use pre-built messages
+            messages = options.messages;
+        }
+        return {
+            messages,
+            modelContext,
+        };
+    }
 }
 exports.LLMService = LLMService;

package/dist/llm/LLMService.prepareMessage.test.d.ts

@@ -0,0 +1 @@
+export {};