genai-lite 0.6.1 → 0.7.0

package/dist/llm/clients/OpenAIClientAdapter.js

@@ -9,6 +9,8 @@ exports.OpenAIClientAdapter = void 0;
 const openai_1 = __importDefault(require("openai"));
 const types_1 = require("./types");
 const errorUtils_1 = require("../../shared/adapters/errorUtils");
+const defaultLogger_1 = require("../../logging/defaultLogger");
+const logger = (0, defaultLogger_1.createDefaultLogger)();
 /**
  * Client adapter for OpenAI API integration
  *
@@ -76,7 +78,7 @@ class OpenAIClientAdapter {
                     completionParams.reasoning_effort = 'medium';
                 }
             }
-            console.log(`OpenAI API parameters:`, {
+            logger.debug(`OpenAI API parameters:`, {
                 model: completionParams.model,
                 temperature: completionParams.temperature,
                 max_completion_tokens: completionParams.max_completion_tokens,
@@ -86,12 +88,12 @@ class OpenAIClientAdapter {
                 presence_penalty: completionParams.presence_penalty,
                 hasUser: !!completionParams.user,
             });
-            console.log(`Making OpenAI API call for model: ${request.modelId}`);
+            logger.info(`Making OpenAI API call for model: ${request.modelId}`);
             // Make the API call
             const completion = await openai.chat.completions.create(completionParams);
             // Type guard to ensure we have a non-streaming response
             if ('id' in completion && 'choices' in completion) {
-                console.log(`OpenAI API call successful, response ID: ${completion.id}`);
+                logger.info(`OpenAI API call successful, response ID: ${completion.id}`);
                 // Convert to standardized response format
                 return this.createSuccessResponse(completion, request);
             }
@@ -100,7 +102,7 @@ class OpenAIClientAdapter {
             }
         }
         catch (error) {
-            console.error("OpenAI API error:", error);
+            logger.error("OpenAI API error:", error);
             return this.createErrorResponse(error, request);
         }
     }

package/dist/llm/config.js

@@ -16,6 +16,8 @@ const OpenAIClientAdapter_1 = require("./clients/OpenAIClientAdapter");
 const AnthropicClientAdapter_1 = require("./clients/AnthropicClientAdapter");
 const GeminiClientAdapter_1 = require("./clients/GeminiClientAdapter");
 const LlamaCppClientAdapter_1 = require("./clients/LlamaCppClientAdapter");
+const defaultLogger_1 = require("../logging/defaultLogger");
+const logger = (0, defaultLogger_1.createDefaultLogger)();
 // Placeholder for future imports:
 // import { MistralClientAdapter } from './clients/MistralClientAdapter';
 /**
@@ -271,7 +273,7 @@ function detectGgufCapabilities(ggufFilename) {
     // First match wins (array is pre-ordered from specific to generic)
     for (const model of exports.KNOWN_GGUF_MODELS) {
         if (lowerFilename.includes(model.pattern.toLowerCase())) {
-            console.log(`Detected GGUF model: ${model.name} (pattern: ${model.pattern})`);
+            logger.debug(`Detected GGUF model: ${model.name} (pattern: ${model.pattern})`);
             return model.capabilities;
         }
     }
@@ -588,32 +590,6 @@ exports.SUPPORTED_MODELS = [
             outputType: 'summary',
         },
     },
-    {
-        id: "gemini-2.0-flash",
-        name: "Gemini 2.0 Flash",
-        providerId: "gemini",
-        contextWindow: 1048576,
-        inputPrice: 0.1,
-        outputPrice: 0.4,
-        description: "High-performance model with multimodal capabilities",
-        maxTokens: 8192,
-        supportsImages: true,
-        supportsPromptCache: true,
-        cacheReadsPrice: 0.025,
-        cacheWritesPrice: 1.0,
-    },
-    {
-        id: "gemini-2.0-flash-lite",
-        name: "Gemini 2.0 Flash Lite",
-        providerId: "gemini",
-        contextWindow: 1048576,
-        inputPrice: 0.075,
-        outputPrice: 0.3,
-        description: "Lightweight version of Gemini 2.0 Flash",
-        maxTokens: 8192,
-        supportsImages: true,
-        supportsPromptCache: false,
-    },
     // Google Gemma 3 Models (Open weights, free via Gemini API)
     {
         id: "gemma-3-27b-it",

package/dist/llm/services/ModelResolver.d.ts

@@ -1,6 +1,7 @@
 import type { LLMFailureResponse, LLMSettings, ModelInfo, ApiProviderId } from "../types";
 import type { ILLMClientAdapter } from "../clients/types";
 import type { ModelPreset } from "../../types/presets";
+import type { Logger } from "../../logging/types";
 import { PresetManager } from "../../shared/services/PresetManager";
 import { AdapterRegistry } from "../../shared/services/AdapterRegistry";
 /**
@@ -28,7 +29,8 @@ export interface ModelResolution {
 export declare class ModelResolver {
     private presetManager;
     private adapterRegistry;
-    constructor(presetManager: PresetManager<ModelPreset>, adapterRegistry: AdapterRegistry<ILLMClientAdapter, ApiProviderId>);
+    private logger;
+    constructor(presetManager: PresetManager<ModelPreset>, adapterRegistry: AdapterRegistry<ILLMClientAdapter, ApiProviderId>, logger?: Logger);
     /**
      * Resolves model information from either a preset ID or provider/model IDs
      *

package/dist/llm/services/ModelResolver.js

@@ -1,14 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ModelResolver = void 0;
+const defaultLogger_1 = require("../../logging/defaultLogger");
 const config_1 = require("../config");
 /**
  * Resolves model information from presets or direct provider/model IDs
  */
 class ModelResolver {
-    constructor(presetManager, adapterRegistry) {
+    constructor(presetManager, adapterRegistry, logger) {
         this.presetManager = presetManager;
         this.adapterRegistry = adapterRegistry;
+        this.logger = logger ?? (0, defaultLogger_1.createDefaultLogger)();
     }
     /**
      * Resolves model information from either a preset ID or provider/model IDs
@@ -107,7 +109,7 @@ class ModelResolver {
                     }
                 }
                 catch (error) {
-                    console.warn('Failed to detect GGUF model capabilities:', error);
+                    this.logger.warn('Failed to detect GGUF model capabilities:', error);
                     // Continue with fallback
                 }
             }
@@ -117,7 +119,7 @@ class ModelResolver {
             }
             else {
                 // Strict provider - warn but allow
-                console.warn(`⚠️  Unknown model "${options.modelId}" for provider "${options.providerId}". ` +
+                this.logger.warn(`Unknown model "${options.modelId}" for provider "${options.providerId}". ` +
                     `Using default settings. This may fail at the provider API if the model doesn't exist.`);
                 modelInfo = (0, config_1.createFallbackModelInfo)(options.modelId, options.providerId, detectedCapabilities);
             }

package/dist/llm/services/SettingsManager.d.ts

@@ -1,8 +1,11 @@
 import type { ApiProviderId, LLMSettings, ModelInfo, ProviderInfo } from "../types";
+import type { Logger } from "../../logging/types";
 /**
  * Manages LLM settings including merging with defaults and filtering unsupported parameters
  */
 export declare class SettingsManager {
+    private logger;
+    constructor(logger?: Logger);
     /**
      * Merges request settings with model-specific and global defaults
      *

package/dist/llm/services/SettingsManager.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SettingsManager = void 0;
+const defaultLogger_1 = require("../../logging/defaultLogger");
 const config_1 = require("../config");
 /**
  * Manages LLM settings including merging with defaults and filtering unsupported parameters
  */
 class SettingsManager {
+    constructor(logger) {
+        this.logger = logger ?? (0, defaultLogger_1.createDefaultLogger)();
+    }
     /**
      * Merges request settings with model-specific and global defaults
      *
@@ -40,7 +44,7 @@ class SettingsManager {
             },
         };
         // Log the final settings for debugging
-        console.log(`Merged settings for ${providerId}/${modelId}:`, {
+        this.logger.debug(`Merged settings for ${providerId}/${modelId}:`, {
             temperature: mergedSettings.temperature,
             maxTokens: mergedSettings.maxTokens,
             topP: mergedSettings.topP,
@@ -74,23 +78,23 @@ class SettingsManager {
             modelInfo.unsupportedParameters.forEach((param) => paramsToExclude.add(param));
         }
         if (paramsToExclude.size > 0) {
-            console.log(`LLMService: Potential parameters to exclude for provider '${providerInfo.id}', model '${modelInfo.id}':`, Array.from(paramsToExclude));
+            this.logger.debug(`LLMService: Potential parameters to exclude for provider '${providerInfo.id}', model '${modelInfo.id}':`, Array.from(paramsToExclude));
         }
         paramsToExclude.forEach((param) => {
             // Check if the parameter key actually exists in filteredSettings before trying to delete
             if (param in filteredSettings) {
-                console.log(`LLMService: Removing excluded parameter '${String(param)}' for provider '${providerInfo.id}', model '${modelInfo.id}'. Value was:`, filteredSettings[param]);
+                this.logger.debug(`LLMService: Removing excluded parameter '${String(param)}' for provider '${providerInfo.id}', model '${modelInfo.id}'. Value was:`, filteredSettings[param]);
                 delete filteredSettings[param]; // Cast to allow deletion
             }
             else {
                 // This case should ideally not happen if settings truly is Required<LLMSettings>
-                console.log(`LLMService: Parameter '${String(param)}' marked for exclusion was not found in settings for provider '${providerInfo.id}', model '${modelInfo.id}'.`);
+                this.logger.debug(`LLMService: Parameter '${String(param)}' marked for exclusion was not found in settings for provider '${providerInfo.id}', model '${modelInfo.id}'.`);
             }
         });
         // 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 ${modelInfo.id}`);
+            this.logger.debug(`LLMService: Removing reasoning settings for non-reasoning model ${modelInfo.id}`);
             delete filteredSettings.reasoning;
         }
         return filteredSettings;
@@ -121,71 +125,71 @@ class SettingsManager {
         for (const [key, value] of Object.entries(settings)) {
             // Check if it's a known field
             if (!knownFields.includes(key)) {
-                console.warn(`Unknown setting "${key}" in template metadata. Ignoring.`);
+                this.logger.warn(`Unknown setting "${key}" in template metadata. Ignoring.`);
                 continue;
             }
             // Type-specific validation
             if (key === 'temperature') {
                 if (typeof value !== 'number' || value < 0 || value > 2) {
-                    console.warn(`Invalid temperature value in template: ${value}. Must be a number between 0 and 2.`);
+                    this.logger.warn(`Invalid temperature value in template: ${value}. Must be a number between 0 and 2.`);
                     continue;
                 }
             }
             if (key === 'maxTokens') {
                 if (typeof value !== 'number' || value <= 0) {
-                    console.warn(`Invalid maxTokens value in template: ${value}. Must be a positive number.`);
+                    this.logger.warn(`Invalid maxTokens value in template: ${value}. Must be a positive number.`);
                     continue;
                 }
             }
             if (key === 'topP') {
                 if (typeof value !== 'number' || value < 0 || value > 1) {
-                    console.warn(`Invalid topP value in template: ${value}. Must be a number between 0 and 1.`);
+                    this.logger.warn(`Invalid topP value in template: ${value}. Must be a number between 0 and 1.`);
                     continue;
                 }
             }
             if (key === 'stopSequences') {
                 if (!Array.isArray(value) || !value.every(v => typeof v === 'string')) {
-                    console.warn(`Invalid stopSequences value in template. Must be an array of strings.`);
+                    this.logger.warn(`Invalid stopSequences value in template. Must be an array of strings.`);
                     continue;
                 }
             }
             if ((key === 'frequencyPenalty' || key === 'presencePenalty')) {
                 if (typeof value !== 'number' || value < -2 || value > 2) {
-                    console.warn(`Invalid ${key} value in template: ${value}. Must be a number between -2 and 2.`);
+                    this.logger.warn(`Invalid ${key} value in template: ${value}. Must be a number between -2 and 2.`);
                     continue;
                 }
             }
             if (key === 'user' && typeof value !== 'string') {
-                console.warn(`Invalid user value in template. Must be a string.`);
+                this.logger.warn(`Invalid user value in template. Must be a string.`);
                 continue;
             }
             if (key === 'supportsSystemMessage' && typeof value !== 'boolean') {
-                console.warn(`Invalid supportsSystemMessage value in template. Must be a boolean.`);
+                this.logger.warn(`Invalid supportsSystemMessage value in template. Must be a boolean.`);
                 continue;
             }
             // Nested object validation
             if (key === 'reasoning' && typeof value === 'object' && value !== null) {
                 const reasoningValidated = {};
                 if ('enabled' in value && typeof value.enabled !== 'boolean') {
-                    console.warn(`Invalid reasoning.enabled value in template. Must be a boolean.`);
+                    this.logger.warn(`Invalid reasoning.enabled value in template. Must be a boolean.`);
                 }
                 else if ('enabled' in value) {
                     reasoningValidated.enabled = value.enabled;
                 }
                 if ('effort' in value && !['low', 'medium', 'high'].includes(value.effort)) {
-                    console.warn(`Invalid reasoning.effort value in template: ${value.effort}. Must be 'low', 'medium', or 'high'.`);
+                    this.logger.warn(`Invalid reasoning.effort value in template: ${value.effort}. Must be 'low', 'medium', or 'high'.`);
                 }
                 else if ('effort' in value) {
                     reasoningValidated.effort = value.effort;
                 }
                 if ('maxTokens' in value && (typeof value.maxTokens !== 'number' || value.maxTokens <= 0)) {
-                    console.warn(`Invalid reasoning.maxTokens value in template. Must be a positive number.`);
+                    this.logger.warn(`Invalid reasoning.maxTokens value in template. Must be a positive number.`);
                 }
                 else if ('maxTokens' in value) {
                     reasoningValidated.maxTokens = value.maxTokens;
                 }
                 if ('exclude' in value && typeof value.exclude !== 'boolean') {
-                    console.warn(`Invalid reasoning.exclude value in template. Must be a boolean.`);
+                    this.logger.warn(`Invalid reasoning.exclude value in template. Must be a boolean.`);
                 }
                 else if ('exclude' in value) {
                     reasoningValidated.exclude = value.exclude;
@@ -198,19 +202,19 @@ class SettingsManager {
             if (key === 'thinkingTagFallback' && typeof value === 'object' && value !== null) {
                 const thinkingValidated = {};
                 if ('enabled' in value && typeof value.enabled !== 'boolean') {
-                    console.warn(`Invalid thinkingTagFallback.enabled value in template. Must be a boolean.`);
+                    this.logger.warn(`Invalid thinkingTagFallback.enabled value in template. Must be a boolean.`);
                 }
                 else if ('enabled' in value) {
                     thinkingValidated.enabled = value.enabled;
                 }
                 if ('tagName' in value && typeof value.tagName !== 'string') {
-                    console.warn(`Invalid thinkingTagFallback.tagName value in template. Must be a string.`);
+                    this.logger.warn(`Invalid thinkingTagFallback.tagName value in template. Must be a string.`);
                 }
                 else if ('tagName' in value) {
                     thinkingValidated.tagName = value.tagName;
                 }
                 if ('enforce' in value && typeof value.enforce !== 'boolean') {
-                    console.warn(`Invalid thinkingTagFallback.enforce value in template. Must be a boolean.`);
+                    this.logger.warn(`Invalid thinkingTagFallback.enforce value in template. Must be a boolean.`);
                 }
                 else if ('enforce' in value) {
                     thinkingValidated.enforce = value.enforce;

package/dist/logging/defaultLogger.d.ts

@@ -0,0 +1,35 @@
+import type { Logger, LogLevel } from './types';
+/**
+ * The default log level, read once at module initialization.
+ * Can be overridden per-service via constructor options.
+ */
+export declare const DEFAULT_LOG_LEVEL: LogLevel;
+/**
+ * Creates a default console-based logger with level filtering.
+ *
+ * @param level - The minimum log level to output (defaults to env var or 'warn')
+ * @returns A Logger instance that filters messages below the specified level
+ *
+ * @example
+ * ```typescript
+ * const logger = createDefaultLogger('debug');
+ * logger.debug('This will be shown');
+ * logger.info('This will be shown');
+ *
+ * const quietLogger = createDefaultLogger('error');
+ * quietLogger.debug('This will be suppressed');
+ * quietLogger.info('This will be suppressed');
+ * quietLogger.error('This will be shown');
+ * ```
+ */
+export declare function createDefaultLogger(level?: LogLevel): Logger;
+/**
+ * A silent logger that discards all output.
+ * Useful for testing or when logging should be completely disabled.
+ *
+ * @example
+ * ```typescript
+ * const service = new LLMService(apiKeyProvider, { logger: silentLogger });
+ * ```
+ */
+export declare const silentLogger: Logger;

package/dist/logging/defaultLogger.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.silentLogger = exports.DEFAULT_LOG_LEVEL = void 0;
+exports.createDefaultLogger = createDefaultLogger;
+/**
+ * Numeric values for log levels (higher = more verbose)
+ */
+const LOG_LEVEL_VALUES = {
+    silent: 0,
+    error: 1,
+    warn: 2,
+    info: 3,
+    debug: 4,
+};
+/**
+ * Valid log level strings for validation
+ */
+const VALID_LOG_LEVELS = new Set(['silent', 'error', 'warn', 'info', 'debug']);
+/**
+ * Reads the default log level from environment variable.
+ * Called once at module load time.
+ *
+ * @returns The log level from GENAI_LITE_LOG_LEVEL or 'warn' as default
+ */
+function getDefaultLogLevelFromEnv() {
+    const envLevel = process.env.GENAI_LITE_LOG_LEVEL?.toLowerCase();
+    if (envLevel && VALID_LOG_LEVELS.has(envLevel)) {
+        return envLevel;
+    }
+    return 'warn'; // Sensible default: errors + warnings
+}
+/**
+ * The default log level, read once at module initialization.
+ * Can be overridden per-service via constructor options.
+ */
+exports.DEFAULT_LOG_LEVEL = getDefaultLogLevelFromEnv();
+/**
+ * Creates a default console-based logger with level filtering.
+ *
+ * @param level - The minimum log level to output (defaults to env var or 'warn')
+ * @returns A Logger instance that filters messages below the specified level
+ *
+ * @example
+ * ```typescript
+ * const logger = createDefaultLogger('debug');
+ * logger.debug('This will be shown');
+ * logger.info('This will be shown');
+ *
+ * const quietLogger = createDefaultLogger('error');
+ * quietLogger.debug('This will be suppressed');
+ * quietLogger.info('This will be suppressed');
+ * quietLogger.error('This will be shown');
+ * ```
+ */
+function createDefaultLogger(level = exports.DEFAULT_LOG_LEVEL) {
+    const threshold = LOG_LEVEL_VALUES[level];
+    return {
+        debug(message, ...args) {
+            if (threshold >= LOG_LEVEL_VALUES.debug) {
+                console.log(`[genai-lite:debug] ${message}`, ...args);
+            }
+        },
+        info(message, ...args) {
+            if (threshold >= LOG_LEVEL_VALUES.info) {
+                console.log(`[genai-lite:info] ${message}`, ...args);
+            }
+        },
+        warn(message, ...args) {
+            if (threshold >= LOG_LEVEL_VALUES.warn) {
+                console.warn(`[genai-lite:warn] ${message}`, ...args);
+            }
+        },
+        error(message, ...args) {
+            if (threshold >= LOG_LEVEL_VALUES.error) {
+                console.error(`[genai-lite:error] ${message}`, ...args);
+            }
+        },
+    };
+}
+/**
+ * A silent logger that discards all output.
+ * Useful for testing or when logging should be completely disabled.
+ *
+ * @example
+ * ```typescript
+ * const service = new LLMService(apiKeyProvider, { logger: silentLogger });
+ * ```
+ */
+exports.silentLogger = {
+    debug: () => { },
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+};

package/dist/logging/index.d.ts

@@ -0,0 +1,2 @@
+export type { Logger, LogLevel, LoggingConfig } from './types';
+export { createDefaultLogger, DEFAULT_LOG_LEVEL, silentLogger, } from './defaultLogger';

package/dist/logging/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.silentLogger = exports.DEFAULT_LOG_LEVEL = exports.createDefaultLogger = void 0;
+var defaultLogger_1 = require("./defaultLogger");
+Object.defineProperty(exports, "createDefaultLogger", { enumerable: true, get: function () { return defaultLogger_1.createDefaultLogger; } });
+Object.defineProperty(exports, "DEFAULT_LOG_LEVEL", { enumerable: true, get: function () { return defaultLogger_1.DEFAULT_LOG_LEVEL; } });
+Object.defineProperty(exports, "silentLogger", { enumerable: true, get: function () { return defaultLogger_1.silentLogger; } });

package/dist/logging/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Log level type - ordered from most quiet to most verbose
+ */
+export type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+/**
+ * Logger interface compatible with popular logging libraries
+ * (pino, winston, bunyan, console all have these methods)
+ */
+export interface Logger {
+    debug(message: string, ...args: unknown[]): void;
+    info(message: string, ...args: unknown[]): void;
+    warn(message: string, ...args: unknown[]): void;
+    error(message: string, ...args: unknown[]): void;
+}
+/**
+ * Configuration for the logging system
+ */
+export interface LoggingConfig {
+    /** Log level threshold - messages below this level are suppressed */
+    level: LogLevel;
+    /** Custom logger implementation (optional) */
+    logger?: Logger;
+}

package/dist/logging/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/prompting/parser.js

@@ -10,6 +10,9 @@ exports.parseStructuredContent = parseStructuredContent;
 exports.extractInitialTaggedContent = extractInitialTaggedContent;
 exports.parseRoleTags = parseRoleTags;
 exports.parseTemplateWithMetadata = parseTemplateWithMetadata;
+const defaultLogger_1 = require("../logging/defaultLogger");
+// Module-level logger for utility functions
+const logger = (0, defaultLogger_1.createDefaultLogger)();
 /**
  * Parses a string containing structured data wrapped in custom XML-style tags.
  *
@@ -183,7 +186,7 @@ function parseTemplateWithMetadata(template) {
     catch (error) {
         // If the JSON is invalid, we warn the developer and treat the <META> block
         // as regular text to avoid crashing.
-        console.warn('Could not parse <META> block in template. Treating it as content.', error);
+        logger.warn('Could not parse <META> block in template. Treating it as content.', error);
         return { metadata: { settings: {} }, content: template };
     }
 }

package/dist/shared/services/AdapterRegistry.d.ts

@@ -1,3 +1,4 @@
+import type { Logger } from "../../logging/types";
 /**
  * Information about a registered adapter
  */
@@ -50,12 +51,14 @@ export declare class AdapterRegistry<TAdapter, TProviderId extends string> {
     private adapters;
     private fallbackAdapter;
     private supportedProviders;
+    private logger;
     /**
      * Creates a new AdapterRegistry
      *
      * @param config - Configuration for the registry
+     * @param logger - Optional logger instance
      */
-    constructor(config: AdapterRegistryConfig<TAdapter, TProviderId>);
+    constructor(config: AdapterRegistryConfig<TAdapter, TProviderId>, logger?: Logger);
     /**
      * Initializes adapters for all supported providers using constructors
      */

package/dist/shared/services/AdapterRegistry.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AdapterRegistry = void 0;
+const defaultLogger_1 = require("../../logging/defaultLogger");
 /**
  * Generic registry for managing service adapters across different providers.
  * Handles adapter initialization, registration, and retrieval.
@@ -13,11 +14,13 @@ class AdapterRegistry {
      * Creates a new AdapterRegistry
      *
      * @param config - Configuration for the registry
+     * @param logger - Optional logger instance
      */
-    constructor(config) {
+    constructor(config, logger) {
         this.adapters = new Map();
         this.fallbackAdapter = config.fallbackAdapter;
         this.supportedProviders = config.supportedProviders;
+        this.logger = logger ?? (0, defaultLogger_1.createDefaultLogger)();
         // Register custom adapters first if provided
         if (config.customAdapters) {
             for (const [providerId, adapter] of Object.entries(config.customAdapters)) {
@@ -39,7 +42,7 @@ class AdapterRegistry {
             const providerId = provider.id;
             // Skip if adapter is already registered (from custom adapters)
             if (this.adapters.has(providerId)) {
-                console.log(`AdapterRegistry: Skipping constructor initialization for '${provider.id}' ` +
+                this.logger.debug(`AdapterRegistry: Skipping constructor initialization for '${provider.id}' ` +
                     `(custom adapter already registered)`);
                 continue;
             }
@@ -53,21 +56,21 @@ class AdapterRegistry {
                     successfullyRegisteredProviders.push(provider.id);
                 }
                 catch (error) {
-                    console.error(`AdapterRegistry: Failed to instantiate adapter for provider '${provider.id}'. ` +
+                    this.logger.error(`AdapterRegistry: Failed to instantiate adapter for provider '${provider.id}'. ` +
                         `This provider will use the fallback adapter. Error:`, error);
                 }
             }
             else {
-                console.warn(`AdapterRegistry: No adapter constructor found for supported provider '${provider.id}'. ` +
+                this.logger.warn(`AdapterRegistry: No adapter constructor found for supported provider '${provider.id}'. ` +
                     `This provider will use the fallback adapter.`);
             }
         }
         if (registeredCount > 0) {
-            console.log(`AdapterRegistry: Initialized with ${registeredCount} dynamically registered adapter(s) ` +
+            this.logger.debug(`AdapterRegistry: Initialized with ${registeredCount} dynamically registered adapter(s) ` +
                 `for: ${successfullyRegisteredProviders.join(', ')}.`);
         }
         else {
-            console.log(`AdapterRegistry: No real adapters were dynamically registered. ` +
+            this.logger.debug(`AdapterRegistry: No real adapters were dynamically registered. ` +
                 `All providers will use the fallback adapter.`);
         }
     }
@@ -79,7 +82,7 @@ class AdapterRegistry {
      */
     registerAdapter(providerId, adapter) {
         this.adapters.set(providerId, adapter);
-        console.log(`AdapterRegistry: Registered adapter for provider: ${providerId}`);
+        this.logger.debug(`AdapterRegistry: Registered adapter for provider: ${providerId}`);
     }
     /**
      * Gets the appropriate adapter for a provider
@@ -91,11 +94,11 @@ class AdapterRegistry {
         // Check for registered real adapters first
         const registeredAdapter = this.adapters.get(providerId);
         if (registeredAdapter) {
-            console.log(`AdapterRegistry: Using registered adapter for provider: ${providerId}`);
+            this.logger.debug(`AdapterRegistry: Using registered adapter for provider: ${providerId}`);
             return registeredAdapter;
         }
         // Fall back to fallback adapter for unsupported providers
-        console.log(`AdapterRegistry: No real adapter found for ${providerId}, using fallback adapter`);
+        this.logger.debug(`AdapterRegistry: No real adapter found for ${providerId}, using fallback adapter`);
         return this.fallbackAdapter;
     }
     /**

package/dist/types/image.d.ts

@@ -4,6 +4,7 @@
  * This module contains all types for the ImageService and image generation adapters.
  * Based on the design specification in docs/devlog/2025-10-22-genai-lite-image-api-design.md
  */
+import type { Logger, LogLevel } from '../logging/types';
 /**
  * Image provider ID type - represents a unique identifier for an image generation provider
  */
@@ -387,6 +388,10 @@ export interface ImageServiceOptions {
     adapters?: Record<ImageProviderId, ImageProviderAdapter>;
     /** Override default base URLs per provider */
     baseUrls?: Record<ImageProviderId, string>;
+    /** Log level for filtering messages. Defaults to GENAI_LITE_LOG_LEVEL env var or 'warn'. */
+    logLevel?: LogLevel;
+    /** Custom logger implementation. If provided, logLevel is ignored. */
+    logger?: Logger;
 }
 /**
  * Result from createPrompt utility

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genai-lite",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "A lightweight, portable toolkit for interacting with various Generative AI APIs.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",