genai-lite 0.2.0 → 0.3.0

package/dist/llm/LLMService.js

@@ -1,14 +1,17 @@
 "use strict";
 // AI Summary: Main process service for LLM operations, integrating with ApiKeyProvider for secure key access.
 // Orchestrates LLM requests through provider-specific client adapters with proper error handling.
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 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");
+const parser_1 = require("../prompting/parser");
+// Import the extracted services
+const PresetManager_1 = require("./services/PresetManager");
+const AdapterRegistry_1 = require("./services/AdapterRegistry");
+const RequestValidator_1 = require("./services/RequestValidator");
+const SettingsManager_1 = require("./services/SettingsManager");
+const ModelResolver_1 = require("./services/ModelResolver");
 /**
  * Main process service for LLM operations
  *
@@ -23,55 +26,12 @@ const presets_json_1 = __importDefault(require("../config/presets.json"));
 class LLMService {
     constructor(getApiKey, options = {}) {
         this.getApiKey = getApiKey;
-        this.clientAdapters = new Map();
-        this.mockClientAdapter = new MockClientAdapter_1.MockClientAdapter();
-        // Initialize presets based on mode
-        const finalPresets = new Map();
-        const customPresets = options.presets || [];
-        const mode = options.presetMode || 'extend';
-        if (mode === 'replace') {
-            // Replace Mode: Only use custom presets.
-            for (const preset of customPresets) {
-                finalPresets.set(preset.id, preset);
-            }
-        }
-        else {
-            // Extend Mode: Load defaults first, then add/override.
-            for (const preset of presets_json_1.default) {
-                finalPresets.set(preset.id, preset);
-            }
-            for (const preset of customPresets) {
-                finalPresets.set(preset.id, preset);
-            }
-        }
-        this.presets = Array.from(finalPresets.values());
-        // Dynamically register client adapters based on configuration
-        let registeredCount = 0;
-        const successfullyRegisteredProviders = [];
-        for (const provider of config_1.SUPPORTED_PROVIDERS) {
-            const AdapterClass = config_1.ADAPTER_CONSTRUCTORS[provider.id];
-            if (AdapterClass) {
-                try {
-                    const adapterConfig = config_1.ADAPTER_CONFIGS[provider.id];
-                    const adapterInstance = new AdapterClass(adapterConfig);
-                    this.registerClientAdapter(provider.id, adapterInstance);
-                    registeredCount++;
-                    successfullyRegisteredProviders.push(provider.id);
-                }
-                catch (error) {
-                    console.error(`LLMService: Failed to instantiate adapter for provider '${provider.id}'. This provider will use the mock adapter. Error:`, error);
-                }
-            }
-            else {
-                console.warn(`LLMService: No adapter constructor found for supported provider '${provider.id}'. This provider will use the mock adapter as a fallback.`);
-            }
-        }
-        if (registeredCount > 0) {
-            console.log(`LLMService: Initialized with ${registeredCount} dynamically registered adapter(s) for: ${successfullyRegisteredProviders.join(", ")}.`);
-        }
-        else {
-            console.log(`LLMService: No real adapters were dynamically registered. All providers will use the mock adapter.`);
-        }
+        // Initialize services
+        this.presetManager = new PresetManager_1.PresetManager(options.presets, options.presetMode);
+        this.adapterRegistry = new AdapterRegistry_1.AdapterRegistry();
+        this.requestValidator = new RequestValidator_1.RequestValidator();
+        this.settingsManager = new SettingsManager_1.SettingsManager();
+        this.modelResolver = new ModelResolver_1.ModelResolver(this.presetManager);
     }
     /**
      * Gets list of supported LLM providers
@@ -91,11 +51,11 @@ class LLMService {
     async getModels(providerId) {
         console.log(`LLMService.getModels called for provider: ${providerId}`);
         // Validate provider exists
-        if (!(0, config_1.isProviderSupported)(providerId)) {
+        const models = (0, config_1.getModelsByProvider)(providerId);
+        if (models.length === 0) {
             console.warn(`Requested models for unsupported provider: ${providerId}`);
             return [];
         }
-        const models = (0, config_1.getModelsByProvider)(providerId);
         console.log(`Found ${models.length} models for provider: ${providerId}`);
         return [...models]; // Return a copy to prevent external modification
     }
@@ -106,146 +66,145 @@ 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.modelResolver.resolve(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,
+            };
             // Validate basic request structure
-            const structureValidationResult = this.validateRequestStructure(request);
+            const structureValidationResult = this.requestValidator.validateRequestStructure(resolvedRequest);
             if (structureValidationResult) {
                 return structureValidationResult;
             }
-            // Validate settings if provided
-            if (request.settings) {
-                const settingsValidationErrors = (0, config_1.validateLLMSettings)(request.settings);
-                if (settingsValidationErrors.length > 0) {
-                    return {
-                        provider: request.providerId,
-                        model: request.modelId,
-                        error: {
-                            message: `Invalid settings: ${settingsValidationErrors.join(", ")}`,
-                            code: "INVALID_SETTINGS",
-                            type: "validation_error",
-                        },
-                        object: "error",
-                    };
+            // Validate settings if provided  
+            const combinedSettings = { ...resolvedSettings, ...request.settings };
+            if (combinedSettings) {
+                const settingsValidation = this.requestValidator.validateSettings(combinedSettings, providerId, modelId);
+                if (settingsValidation) {
+                    return settingsValidation;
                 }
             }
             // Apply model-specific defaults and merge with user settings
-            const finalSettings = this.mergeSettingsForModel(request.modelId, request.providerId, request.settings);
-            // 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 paramsToExclude = new Set();
-            // Add provider-level exclusions
-            if (providerInfo?.unsupportedParameters) {
-                providerInfo.unsupportedParameters.forEach((param) => paramsToExclude.add(param));
+            const finalSettings = this.settingsManager.mergeSettingsForModel(modelId, providerId, combinedSettings);
+            // Validate reasoning settings for model capabilities
+            const reasoningValidation = this.requestValidator.validateReasoningSettings(modelInfo, finalSettings.reasoning, resolvedRequest);
+            if (reasoningValidation) {
+                return reasoningValidation;
             }
-            // Add model-level exclusions (these will be added to any provider-level ones)
-            if (modelInfo?.unsupportedParameters) {
-                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));
+            // Get provider info for parameter filtering
+            const providerInfo = (0, config_1.getProviderById)(providerId);
+            if (!providerInfo) {
+                return {
+                    provider: providerId,
+                    model: modelId,
+                    error: {
+                        message: `Provider information not found: ${providerId}`,
+                        code: "PROVIDER_ERROR",
+                        type: "server_error",
+                    },
+                    object: "error",
+                };
             }
-            paramsToExclude.forEach((param) => {
-                // Check if the parameter key actually exists in filteredSettings before trying to delete
-                // (it might have been undefined initially and thus not part of finalSettings depending on merge logic)
-                // Using 'in' operator is robust for checking presence of properties, including those from prototype chain.
-                // 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]);
-                    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}'.`);
-                }
-            });
+            // Filter out unsupported parameters
+            const filteredSettings = this.settingsManager.filterUnsupportedParameters(finalSettings, modelInfo, providerInfo);
             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}`);
             // Get client adapter
-            const clientAdapter = this.getClientAdapter(request.providerId);
+            const clientAdapter = this.adapterRegistry.getAdapter(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}`);
+                // Post-process for thinking extraction
+                if (result.object === 'chat.completion' && internalRequest.settings.thinkingExtraction?.enabled) {
+                    const settings = internalRequest.settings.thinkingExtraction;
+                    const tagName = settings.tag || 'thinking';
+                    // Step 1: Resolve the effective onMissing strategy
+                    let effectiveOnMissing = settings.onMissing || 'auto';
+                    if (effectiveOnMissing === 'auto') {
+                        // Check if native reasoning is active
+                        const isNativeReasoningActive = modelInfo.reasoning?.supported === true &&
+                            (internalRequest.settings.reasoning?.enabled === true ||
+                                modelInfo.reasoning?.enabledByDefault === true ||
+                                modelInfo.reasoning?.canDisable === false); // Always-on models
+                        effectiveOnMissing = isNativeReasoningActive ? 'ignore' : 'error';
+                    }
+                    // Step 2: Process the response
+                    const choice = result.choices[0];
+                    if (choice?.message?.content) {
+                        const { extracted, remaining } = (0, parser_1.extractInitialTaggedContent)(choice.message.content, tagName);
+                        if (extracted !== null) {
+                            console.log(`Extracted <${tagName}> block from response.`);
+                            // Handle the edge case: append to existing reasoning if present.
+                            const existingReasoning = choice.reasoning || '';
+                            const separator = existingReasoning ? '\n\n' : '';
+                            // Add a comment to indicate the source of this reasoning block.
+                            const newReasoning = `<!-- Extracted by genai-lite from <${tagName}> tag -->\n${extracted}`;
+                            // Update the choice object
+                            choice.reasoning = `${existingReasoning}${separator}${newReasoning}`;
+                            choice.message.content = remaining;
+                        }
+                        else {
+                            // Tag was not found, enforce the effective strategy
+                            if (effectiveOnMissing === 'error') {
+                                return {
+                                    provider: providerId,
+                                    model: modelId,
+                                    error: {
+                                        message: `The model (${modelId}) response was expected to start with a <${tagName}> tag but it was not found. ` +
+                                            `This is enforced because the model does not have native reasoning active. ` +
+                                            `Either ensure your prompt instructs the model to use <${tagName}> tags, or enable native reasoning if supported.`,
+                                        code: "MISSING_EXPECTED_TAG",
+                                        type: "validation_error",
+                                    },
+                                    object: "error",
+                                };
+                            }
+                            else if (effectiveOnMissing === 'warn') {
+                                console.warn(`Expected <${tagName}> tag was not found in the response from model ${modelId}.`);
+                            }
+                            // If 'ignore', do nothing
+                        }
+                    }
+                }
+                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 +220,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
@@ -276,121 +235,98 @@ class LLMService {
         }
     }
     /**
-     * Validates basic LLM request structure
+     * Gets all configured model presets
      *
-     * @param request - The request to validate
-     * @returns LLMFailureResponse if validation fails, null if valid
+     * @returns Array of model presets
      */
-    validateRequestStructure(request) {
-        // Basic request structure validation
-        if (!request.messages ||
-            !Array.isArray(request.messages) ||
-            request.messages.length === 0) {
-            return {
-                provider: request.providerId,
-                model: request.modelId,
-                error: {
-                    message: "Request must contain at least one message",
-                    code: "INVALID_REQUEST",
-                    type: "validation_error",
-                },
-                object: "error",
-            };
-        }
-        // Validate message structure
-        for (let i = 0; i < request.messages.length; i++) {
-            const message = request.messages[i];
-            if (!message.role || !message.content) {
-                return {
-                    provider: request.providerId,
-                    model: request.modelId,
-                    error: {
-                        message: `Message at index ${i} must have both 'role' and 'content' properties`,
-                        code: "INVALID_MESSAGE",
-                        type: "validation_error",
-                    },
-                    object: "error",
-                };
-            }
-            if (!["user", "assistant", "system"].includes(message.role)) {
-                return {
-                    provider: request.providerId,
-                    model: request.modelId,
-                    error: {
-                        message: `Invalid message role '${message.role}' at index ${i}. Must be 'user', 'assistant', or 'system'`,
-                        code: "INVALID_MESSAGE_ROLE",
-                        type: "validation_error",
-                    },
-                    object: "error",
-                };
-            }
-        }
-        return null; // Request is valid
+    getPresets() {
+        return this.presetManager.getPresets();
     }
     /**
-     * Merges request settings with model-specific and global defaults
+     * Creates messages from a template with role tags and model-aware variable substitution
      *
-     * @param modelId - The model ID to get defaults for
-     * @param providerId - The provider ID to get defaults for
-     * @param requestSettings - Settings from the request
-     * @returns Complete settings object with all required fields
-     */
-    mergeSettingsForModel(modelId, providerId, requestSettings) {
-        // Get model-specific defaults
-        const modelDefaults = (0, config_1.getDefaultSettingsForModel)(modelId, providerId);
-        // Merge with user-provided settings (user settings take precedence)
-        const mergedSettings = {
-            temperature: requestSettings?.temperature ?? modelDefaults.temperature,
-            maxTokens: requestSettings?.maxTokens ?? modelDefaults.maxTokens,
-            topP: requestSettings?.topP ?? modelDefaults.topP,
-            stopSequences: requestSettings?.stopSequences ?? modelDefaults.stopSequences,
-            frequencyPenalty: requestSettings?.frequencyPenalty ?? modelDefaults.frequencyPenalty,
-            presencePenalty: requestSettings?.presencePenalty ?? modelDefaults.presencePenalty,
-            user: requestSettings?.user ?? modelDefaults.user,
-            supportsSystemMessage: requestSettings?.supportsSystemMessage ??
-                modelDefaults.supportsSystemMessage,
-            geminiSafetySettings: requestSettings?.geminiSafetySettings ??
-                modelDefaults.geminiSafetySettings,
-        };
-        // Log the final settings for debugging
-        console.log(`Merged settings for ${providerId}/${modelId}:`, {
-            temperature: mergedSettings.temperature,
-            maxTokens: mergedSettings.maxTokens,
-            topP: mergedSettings.topP,
-            hasStopSequences: mergedSettings.stopSequences.length > 0,
-            frequencyPenalty: mergedSettings.frequencyPenalty,
-            presencePenalty: mergedSettings.presencePenalty,
-            hasUser: !!mergedSettings.user,
-            geminiSafetySettingsCount: mergedSettings.geminiSafetySettings.length,
-        });
-        return mergedSettings;
-    }
-    /**
-     * Gets the appropriate client adapter for a provider
+     * This unified method combines the functionality of template rendering, model context
+     * injection, and role tag parsing into a single, intuitive API. It replaces the need
+     * to chain prepareMessage and buildMessagesFromTemplate for model-aware multi-turn prompts.
      *
-     * @param providerId - The provider ID
-     * @returns The client adapter to use
-     */
-    getClientAdapter(providerId) {
-        // Check for registered real adapters first
-        const registeredAdapter = this.clientAdapters.get(providerId);
-        if (registeredAdapter) {
-            console.log(`Using registered adapter for provider: ${providerId}`);
-            return registeredAdapter;
-        }
-        // Fall back to mock adapter for unsupported providers
-        console.log(`No real adapter found for ${providerId}, using mock adapter`);
-        return this.mockClientAdapter;
-    }
-    /**
-     * Registers a client adapter for a specific provider
+     * @param options Options for creating messages
+     * @returns Promise resolving to parsed messages and model context
      *
-     * @param providerId - The provider ID
-     * @param adapter - The client adapter implementation
+     * @example
+     * ```typescript
+     * const { messages } = await llm.createMessages({
+     *   template: `
+     *     <SYSTEM>You are a {{ thinking_enabled ? "thoughtful" : "helpful" }} assistant.</SYSTEM>
+     *     <USER>Help me with {{ task }}</USER>
+     *   `,
+     *   variables: { task: 'understanding async/await' },
+     *   presetId: 'openai-gpt-4.1-default'
+     * });
+     * ```
      */
-    registerClientAdapter(providerId, adapter) {
-        this.clientAdapters.set(providerId, adapter);
-        console.log(`Registered client adapter for provider: ${providerId}`);
+    async createMessages(options) {
+        console.log('LLMService.createMessages called');
+        // NEW: Step 1 - Parse the template for metadata and content
+        const { metadata, content: templateContent } = (0, parser_1.parseTemplateWithMetadata)(options.template);
+        // Validate the settings from the template
+        const templateSettings = this.settingsManager.validateTemplateSettings(metadata.settings || {});
+        // Step 2: Get model context if model information is provided
+        let modelContext = null;
+        if (options.presetId || (options.providerId && options.modelId)) {
+            // Resolve model information
+            const resolved = this.modelResolver.resolve({
+                presetId: options.presetId,
+                providerId: options.providerId,
+                modelId: options.modelId
+            });
+            if (resolved.error) {
+                // If resolution fails, proceed without model context
+                console.warn('Model resolution failed, proceeding without model context:', resolved.error);
+            }
+            else {
+                const { providerId, modelId, modelInfo, settings } = resolved;
+                // Merge settings with model defaults
+                const mergedSettings = this.settingsManager.mergeSettingsForModel(modelId, providerId, settings || {});
+                // Create model context
+                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,
+                };
+            }
+        }
+        // Step 2: Combine variables with model context
+        // Model context comes first so user variables can override
+        const allVariables = {
+            ...(modelContext || {}),
+            ...options.variables
+        };
+        // Step 3: Render the template with all variables
+        let renderedTemplate;
+        try {
+            // Use templateContent which is the template without the <META> block
+            renderedTemplate = (0, template_1.renderTemplate)(templateContent, allVariables);
+        }
+        catch (error) {
+            throw new Error(`Template rendering failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        // Step 4: Parse role tags from the rendered template
+        const parsedMessages = (0, parser_1.parseRoleTags)(renderedTemplate);
+        // Step 5: Convert to LLMMessage format
+        const messages = parsedMessages.map(({ role, content }) => ({
+            role: role,
+            content
+        }));
+        return {
+            messages,
+            modelContext,
+            settings: templateSettings // NEW: Add the extracted settings
+        };
     }
     /**
      * Gets information about registered adapters
@@ -398,15 +334,7 @@ class LLMService {
      * @returns Map of provider IDs to adapter info
      */
     getRegisteredAdapters() {
-        const adapterInfo = new Map();
-        for (const [providerId, adapter] of this.clientAdapters.entries()) {
-            adapterInfo.set(providerId, {
-                providerId,
-                hasAdapter: true,
-                adapterInfo: adapter.getAdapterInfo?.() || { name: "Unknown Adapter" },
-            });
-        }
-        return adapterInfo;
+        return this.adapterRegistry.getRegisteredAdapters();
     }
     /**
      * Gets a summary of available providers and their adapter status
@@ -414,30 +342,7 @@ class LLMService {
      * @returns Summary of provider availability
      */
     getProviderSummary() {
-        const availableProviders = [];
-        const unavailableProviders = [];
-        for (const provider of config_1.SUPPORTED_PROVIDERS) {
-            if (this.clientAdapters.has(provider.id)) {
-                availableProviders.push(provider.id);
-            }
-            else {
-                unavailableProviders.push(provider.id);
-            }
-        }
-        return {
-            totalProviders: config_1.SUPPORTED_PROVIDERS.length,
-            providersWithAdapters: availableProviders.length,
-            availableProviders,
-            unavailableProviders,
-        };
-    }
-    /**
-     * Gets all configured model presets
-     *
-     * @returns Array of model presets
-     */
-    getPresets() {
-        return [...this.presets]; // Return a copy to prevent external modification
+        return this.adapterRegistry.getProviderSummary();
     }
 }
 exports.LLMService = LLMService;