genai-lite 0.6.0 → 0.7.0

package/dist/llm/clients/LlamaCppClientAdapter.js

@@ -11,6 +11,8 @@ const types_1 = require("./types");
 const errorUtils_1 = require("../../shared/adapters/errorUtils");
 const LlamaCppServerClient_1 = require("./LlamaCppServerClient");
 const config_1 = require("../config");
+const defaultLogger_1 = require("../../logging/defaultLogger");
+const logger = (0, defaultLogger_1.createDefaultLogger)();
 /**
  * Client adapter for llama.cpp server integration
  *
@@ -78,10 +80,10 @@ class LlamaCppClientAdapter {
         }
         // Attempt detection
         try {
-            console.log(`Detecting model capabilities from llama.cpp server at ${this.baseURL}`);
+            logger.debug(`Detecting model capabilities from llama.cpp server at ${this.baseURL}`);
             const { data } = await this.serverClient.getModels();
             if (!data || data.length === 0) {
-                console.warn('No models loaded in llama.cpp server');
+                logger.warn('No models loaded in llama.cpp server');
                 this.detectionAttempted = true;
                 return null;
             }
@@ -91,15 +93,15 @@ class LlamaCppClientAdapter {
             this.cachedModelCapabilities = capabilities;
             this.detectionAttempted = true;
             if (capabilities) {
-                console.log(`Cached model capabilities for: ${ggufFilename}`);
+                logger.debug(`Cached model capabilities for: ${ggufFilename}`);
             }
             else {
-                console.log(`No known pattern matched for: ${ggufFilename}`);
+                logger.debug(`No known pattern matched for: ${ggufFilename}`);
             }
             return capabilities;
         }
         catch (error) {
-            console.warn('Failed to detect model capabilities:', error);
+            logger.warn('Failed to detect model capabilities:', error);
             this.detectionAttempted = true;
             return null;
         }
@@ -113,7 +115,7 @@ class LlamaCppClientAdapter {
     clearModelCache() {
         this.cachedModelCapabilities = null;
         this.detectionAttempted = false;
-        console.log('Cleared model capabilities cache');
+        logger.debug('Cleared model capabilities cache');
     }
     /**
      * Sends a chat message to llama.cpp server
@@ -142,7 +144,7 @@ class LlamaCppClientAdapter {
                     }
                 }
                 catch (healthError) {
-                    console.warn('Health check failed, proceeding with request anyway:', healthError);
+                    logger.warn('Health check failed, proceeding with request anyway:', healthError);
                 }
             }
             // Initialize OpenAI client with llama.cpp base URL
@@ -170,19 +172,19 @@ class LlamaCppClientAdapter {
                     presence_penalty: request.settings.presencePenalty,
                 }),
             };
-            console.log(`llama.cpp API parameters:`, {
+            logger.debug(`llama.cpp API parameters:`, {
                 baseURL: this.baseURL,
                 model: completionParams.model,
                 temperature: completionParams.temperature,
                 max_tokens: completionParams.max_tokens,
                 top_p: completionParams.top_p,
             });
-            console.log(`Making llama.cpp API call for model: ${request.modelId}`);
+            logger.info(`Making llama.cpp 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(`llama.cpp API call successful, response ID: ${completion.id}`);
+                logger.info(`llama.cpp API call successful, response ID: ${completion.id}`);
                 return this.createSuccessResponse(completion, request);
             }
             else {
@@ -190,7 +192,7 @@ class LlamaCppClientAdapter {
             }
         }
         catch (error) {
-            console.error("llama.cpp API error:", error);
+            logger.error("llama.cpp API error:", error);
             // Clear cache on connection errors so we re-detect on next request
             const errorMessage = error?.message || String(error);
             if (errorMessage.includes("ECONNREFUSED") ||

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;
         }
     }
@@ -564,8 +566,8 @@ exports.SUPPORTED_MODELS = [
         },
     },
     {
-        id: "gemini-2.5-flash-lite-preview-06-17",
-        name: "Gemini 2.5 Flash-Lite Preview",
+        id: "gemini-2.5-flash-lite",
+        name: "Gemini 2.5 Flash-Lite",
         providerId: "gemini",
         contextWindow: 1000000,
         inputPrice: 0.1,
@@ -588,28 +590,15 @@ exports.SUPPORTED_MODELS = [
             outputType: 'summary',
         },
     },
+    // Google Gemma 3 Models (Open weights, free via Gemini API)
     {
-        id: "gemini-2.0-flash",
-        name: "Gemini 2.0 Flash",
+        id: "gemma-3-27b-it",
+        name: "Gemma 3 27B",
         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",
+        contextWindow: 131072,
+        inputPrice: 0.0,
+        outputPrice: 0.0,
+        description: "Google's largest open model with multimodal capabilities and 128K context (free via Gemini API)",
         maxTokens: 8192,
         supportsImages: true,
         supportsPromptCache: false,

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
      */