genai-lite 0.1.0

package/dist/llm/LLMService.js

@@ -0,0 +1,410 @@
+"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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LLMService = void 0;
+const MockClientAdapter_1 = require("./clients/MockClientAdapter");
+const config_1 = require("./config");
+/**
+ * Main process service for LLM operations
+ *
+ * This service:
+ * - Manages LLM provider client adapters
+ * - Integrates with ApiKeyServiceMain for secure API key access
+ * - Validates requests and applies default settings
+ * - Routes requests to appropriate provider adapters
+ * - Handles errors and provides standardized responses
+ */
+class LLMService {
+    constructor(getApiKey) {
+        this.getApiKey = getApiKey;
+        this.clientAdapters = new Map();
+        this.mockClientAdapter = new MockClientAdapter_1.MockClientAdapter();
+        // 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.`);
+        }
+    }
+    /**
+     * Gets list of supported LLM providers
+     *
+     * @returns Promise resolving to array of provider information
+     */
+    async getProviders() {
+        console.log("LLMService.getProviders called");
+        return [...config_1.SUPPORTED_PROVIDERS]; // Return a copy to prevent external modification
+    }
+    /**
+     * Gets list of supported models for a specific provider
+     *
+     * @param providerId - The provider ID to get models for
+     * @returns Promise resolving to array of model information
+     */
+    async getModels(providerId) {
+        console.log(`LLMService.getModels called for provider: ${providerId}`);
+        // Validate provider exists
+        if (!(0, config_1.isProviderSupported)(providerId)) {
+            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
+    }
+    /**
+     * Sends a chat message to an LLM provider
+     *
+     * @param request - The LLM chat request
+     * @returns Promise resolving to either success or failure response
+     */
+    async sendMessage(request) {
+        console.log(`LLMService.sendMessage called for 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",
+                };
+            }
+            // Validate basic request structure
+            const structureValidationResult = this.validateRequestStructure(request);
+            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",
+                    };
+                }
+            }
+            // 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));
+            }
+            // 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));
+            }
+            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}'.`);
+                }
+            });
+            const internalRequest = {
+                ...request,
+                settings: filteredSettings,
+            };
+            console.log(`Processing LLM request with (potentially filtered) settings:`, {
+                provider: request.providerId,
+                model: request.modelId,
+                settings: filteredSettings,
+                messageCount: request.messages.length,
+            });
+            console.log(`Processing LLM request: ${request.messages.length} messages, model: ${request.modelId}`);
+            // Get client adapter
+            const clientAdapter = this.getClientAdapter(request.providerId);
+            // Use ApiKeyProvider to get the API key and make the request
+            try {
+                const apiKey = await this.getApiKey(request.providerId);
+                if (!apiKey) {
+                    return {
+                        provider: request.providerId,
+                        model: request.modelId,
+                        error: {
+                            message: `API key for provider '${request.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}`);
+                const result = await clientAdapter.sendMessage(internalRequest, apiKey);
+                console.log(`LLM request completed successfully for model: ${request.modelId}`);
+                return result;
+            }
+            catch (error) {
+                console.error("Error in LLMService.sendMessage:", error);
+                return {
+                    provider: request.providerId,
+                    model: request.modelId,
+                    error: {
+                        message: error instanceof Error
+                            ? error.message
+                            : "An unknown error occurred during message sending.",
+                        code: "PROVIDER_ERROR",
+                        type: "server_error",
+                        providerError: error,
+                    },
+                    object: "error",
+                };
+            }
+        }
+        catch (error) {
+            console.error("Error in LLMService.sendMessage (outer):", error);
+            return {
+                provider: request.providerId,
+                model: request.modelId,
+                error: {
+                    message: error instanceof Error
+                        ? error.message
+                        : "An unknown error occurred.",
+                    code: "UNEXPECTED_ERROR",
+                    type: "server_error",
+                    providerError: error,
+                },
+                object: "error",
+            };
+        }
+    }
+    /**
+     * Validates basic LLM request structure
+     *
+     * @param request - The request to validate
+     * @returns LLMFailureResponse if validation fails, null if valid
+     */
+    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
+    }
+    /**
+     * Merges request settings with model-specific and global defaults
+     *
+     * @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
+     *
+     * @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 providerId - The provider ID
+     * @param adapter - The client adapter implementation
+     */
+    registerClientAdapter(providerId, adapter) {
+        this.clientAdapters.set(providerId, adapter);
+        console.log(`Registered client adapter for provider: ${providerId}`);
+    }
+    /**
+     * Gets information about registered adapters
+     *
+     * @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;
+    }
+    /**
+     * Gets a summary of available providers and their adapter status
+     *
+     * @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,
+        };
+    }
+}
+exports.LLMService = LLMService;

package/dist/llm/clients/AnthropicClientAdapter.d.ts

@@ -0,0 +1,84 @@
+import type { LLMResponse, LLMFailureResponse } from "../types";
+import type { ILLMClientAdapter, InternalLLMChatRequest } from "./types";
+/**
+ * Client adapter for Anthropic API integration
+ *
+ * This adapter:
+ * - Formats requests according to Anthropic's messages API requirements
+ * - Handles Claude-specific system message positioning and formatting
+ * - Maps Anthropic responses to standardized LLMResponse format
+ * - Converts Anthropic errors to standardized LLMFailureResponse format
+ * - Manages Claude-specific settings and constraints
+ */
+export declare class AnthropicClientAdapter implements ILLMClientAdapter {
+    private baseURL?;
+    /**
+     * Creates a new Anthropic client adapter
+     *
+     * @param config Optional configuration for the adapter
+     * @param config.baseURL Custom base URL for Anthropic-compatible APIs
+     */
+    constructor(config?: {
+        baseURL?: string;
+    });
+    /**
+     * Sends a chat message to Anthropic's API
+     *
+     * @param request - The internal LLM request with applied settings
+     * @param apiKey - The decrypted Anthropic API key
+     * @returns Promise resolving to success or failure response
+     */
+    sendMessage(request: InternalLLMChatRequest, apiKey: string): Promise<LLMResponse | LLMFailureResponse>;
+    /**
+     * Validates Anthropic API key format
+     *
+     * @param apiKey - The API key to validate
+     * @returns True if the key format appears valid
+     */
+    validateApiKey(apiKey: string): boolean;
+    /**
+     * Gets adapter information
+     */
+    getAdapterInfo(): {
+        providerId: "anthropic";
+        name: string;
+        version: string;
+    };
+    /**
+     * Formats messages for Anthropic API with proper system message handling
+     *
+     * @param request - The internal LLM request
+     * @returns Formatted messages and system message for Anthropic
+     */
+    private formatMessagesForAnthropic;
+    /**
+     * Ensures messages alternate between user and assistant roles as required by Anthropic
+     *
+     * @param messages - Original messages array
+     * @returns Cleaned messages with proper alternating pattern
+     */
+    private ensureAlternatingRoles;
+    /**
+     * Creates a standardized success response from Anthropic's response
+     *
+     * @param completion - Raw Anthropic completion response
+     * @param request - Original request for context
+     * @returns Standardized LLM response
+     */
+    private createSuccessResponse;
+    /**
+     * Maps Anthropic stop reasons to standardized format
+     *
+     * @param anthropicReason - The stop reason from Anthropic
+     * @returns Standardized finish reason
+     */
+    private mapAnthropicStopReason;
+    /**
+     * Creates a standardized error response from Anthropic errors
+     *
+     * @param error - The error from Anthropic API
+     * @param request - Original request for context
+     * @returns Standardized LLM failure response
+     */
+    private createErrorResponse;
+}