@revenium/anthropic 1.0.0

package/dist/cjs/config.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultLogger = void 0;
+exports.validateConfig = validateConfig;
+exports.getConfig = getConfig;
+exports.setConfig = setConfig;
+exports.getLogger = getLogger;
+exports.setLogger = setLogger;
+exports.initializeConfig = initializeConfig;
+exports.getConfigStatus = getConfigStatus;
+exports.validateCurrentConfig = validateCurrentConfig;
+const validation_1 = require("./utils/validation");
+const constants_1 = require("./constants");
+/**
+ * Simple console logger implementation for Anthropic middleware
+ */
+class ConsoleLogger {
+    isDebugEnabled() {
+        return process.env[constants_1.ENV_VARS.DEBUG] === 'true';
+    }
+    formatMessage(level, message, context) {
+        const timestamp = new Date().toISOString();
+        const prefix = `[${constants_1.LOGGING_CONFIG.MIDDLEWARE_NAME}${level === 'DEBUG' ? ' Debug' : ''}]`;
+        const contextStr = context ? ` ${JSON.stringify(context)}` : '';
+        return `${timestamp} ${prefix} ${message}${contextStr}`;
+    }
+    debug(message, context) {
+        if (this.isDebugEnabled()) {
+            console.debug(this.formatMessage('DEBUG', message, context));
+        }
+    }
+    info(message, context) {
+        console.info(this.formatMessage('INFO', message, context));
+    }
+    warn(message, context) {
+        console.warn(this.formatMessage('WARN', message, context));
+    }
+    error(message, context) {
+        console.error(this.formatMessage('ERROR', message, context));
+    }
+}
+/**
+ * Default console logger implementation
+ */
+exports.defaultLogger = new ConsoleLogger();
+/**
+ * Load configuration from environment variables
+ */
+function loadConfigFromEnvironment() {
+    const env = {
+        reveniumApiKey: process.env[constants_1.ENV_VARS.REVENIUM_API_KEY],
+        reveniumBaseUrl: process.env[constants_1.ENV_VARS.REVENIUM_BASE_URL],
+        anthropicApiKey: process.env[constants_1.ENV_VARS.ANTHROPIC_API_KEY],
+        debug: process.env[constants_1.ENV_VARS.DEBUG] === 'true',
+        logLevel: process.env[constants_1.ENV_VARS.LOG_LEVEL],
+        apiTimeout: process.env[constants_1.ENV_VARS.API_TIMEOUT],
+        failSilent: process.env[constants_1.ENV_VARS.FAIL_SILENT],
+        maxRetries: process.env[constants_1.ENV_VARS.MAX_RETRIES]
+    };
+    return env;
+}
+/**
+ * Convert environment config to Revenium config
+ */
+function createConfigFromEnvironment(env) {
+    if (!env.reveniumApiKey) {
+        return null;
+    }
+    const apiTimeout = env.apiTimeout ? parseInt(env.apiTimeout, 10) : undefined;
+    const failSilent = env.failSilent !== 'false'; // Default to true
+    const maxRetries = env.maxRetries ? parseInt(env.maxRetries, 10) : undefined;
+    return {
+        reveniumApiKey: env.reveniumApiKey,
+        reveniumBaseUrl: env.reveniumBaseUrl || constants_1.DEFAULT_CONFIG.REVENIUM_BASE_URL,
+        anthropicApiKey: env.anthropicApiKey,
+        apiTimeout,
+        failSilent,
+        maxRetries
+    };
+}
+/**
+ * Validate Revenium configuration with enhanced error reporting
+ */
+function validateConfig(config) {
+    const validation = (0, validation_1.validateReveniumConfig)(config);
+    if (!validation.isValid) {
+        // Log detailed validation errors
+        getLogger().error('Configuration validation failed', {
+            errors: validation.errors,
+            warnings: validation.warnings,
+            suggestions: validation.suggestions
+        });
+        // Create detailed error message
+        let errorMessage = 'Configuration validation failed:\n';
+        validation.errors.forEach((error, index) => {
+            errorMessage += `  ${index + 1}. ${error}\n`;
+        });
+        if (validation.suggestions && validation.suggestions.length > 0) {
+            errorMessage += '\nSuggestions:\n';
+            validation.suggestions.forEach((suggestion) => {
+                errorMessage += `  • ${suggestion}\n`;
+            });
+        }
+        throw new Error(errorMessage.trim());
+    }
+    // Log warnings if any
+    if (validation.warnings && validation.warnings.length > 0) {
+        getLogger().warn('Configuration warnings', {
+            warnings: validation.warnings
+        });
+    }
+}
+/**
+ * Global configuration instance
+ */
+let globalConfig = null;
+let globalLogger = exports.defaultLogger;
+/**
+ * Get the current global configuration
+ */
+function getConfig() {
+    return globalConfig;
+}
+/**
+ * Set the global configuration
+ */
+function setConfig(config) {
+    validateConfig(config);
+    globalConfig = config;
+    globalLogger.debug('Revenium configuration updated', {
+        baseUrl: config.reveniumBaseUrl,
+        hasApiKey: !!config.reveniumApiKey,
+        hasAnthropicKey: !!config.anthropicApiKey
+    });
+}
+/**
+ * Get the current logger
+ */
+function getLogger() {
+    return globalLogger;
+}
+/**
+ * Set a custom logger
+ */
+function setLogger(logger) {
+    globalLogger = logger;
+    globalLogger.debug('Custom logger set for Revenium middleware');
+}
+/**
+ * Initialize configuration from environment variables
+ */
+function initializeConfig() {
+    const env = loadConfigFromEnvironment();
+    const config = createConfigFromEnvironment(env);
+    if (config) {
+        try {
+            setConfig(config);
+            globalLogger.debug('Revenium middleware initialized from environment variables');
+            return true;
+        }
+        catch (error) {
+            globalLogger.error('Failed to initialize Revenium configuration', {
+                error: error instanceof Error ? error.message : String(error)
+            });
+            return false;
+        }
+    }
+    // Log what's missing for easier debugging
+    if (!env.reveniumApiKey) {
+        globalLogger.warn(`Revenium middleware not initialized. Missing ${constants_1.ENV_VARS.REVENIUM_API_KEY} environment variable`);
+        globalLogger.info(`Set ${constants_1.ENV_VARS.REVENIUM_API_KEY} to enable automatic tracking`);
+    }
+    return false;
+}
+/**
+ * Get configuration status
+ */
+function getConfigStatus() {
+    if (!globalConfig) {
+        return {
+            hasConfig: false,
+            hasApiKey: false,
+            hasAnthropicKey: false,
+            baseUrl: ''
+        };
+    }
+    return {
+        hasConfig: true,
+        hasApiKey: !!globalConfig.reveniumApiKey,
+        hasAnthropicKey: !!globalConfig.anthropicApiKey,
+        baseUrl: globalConfig.reveniumBaseUrl
+    };
+}
+/**
+ * Validate current configuration
+ */
+function validateCurrentConfig() {
+    if (!globalConfig)
+        return false;
+    try {
+        const validation = (0, validation_1.validateReveniumConfig)(globalConfig);
+        return validation.isValid;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/cjs/constants.js

@@ -0,0 +1,144 @@
+"use strict";
+/**
+ * Configuration constants for Revenium Anthropic middleware
+ * Centralizes all magic numbers and default values
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANTHROPIC_PATTERNS = exports.API_ENDPOINTS = exports.ENV_VARS = exports.LOGGING_CONFIG = exports.VALIDATION_CONFIG = exports.RETRY_CONFIG = exports.CIRCUIT_BREAKER_CONFIG = exports.DEFAULT_CONFIG = void 0;
+/**
+ * Default configuration values
+ */
+exports.DEFAULT_CONFIG = {
+    /** Default Revenium API base URL */
+    REVENIUM_BASE_URL: 'https://api.revenium.io/meter',
+    /** Default API timeout in milliseconds */
+    API_TIMEOUT: 5000,
+    /** Default maximum retries for failed API calls */
+    MAX_RETRIES: 3,
+    /** Default fail silent behavior */
+    FAIL_SILENT: true,
+    /** Minimum allowed API timeout */
+    MIN_API_TIMEOUT: 1000,
+    /** Maximum allowed API timeout */
+    MAX_API_TIMEOUT: 60000,
+    /** Maximum allowed retry attempts */
+    MAX_RETRY_ATTEMPTS: 10,
+    /** Warning threshold for low API timeout */
+    LOW_TIMEOUT_WARNING_THRESHOLD: 3000,
+};
+/**
+ * Circuit breaker configuration constants
+ */
+exports.CIRCUIT_BREAKER_CONFIG = {
+    /** Default number of failures before opening circuit */
+    FAILURE_THRESHOLD: 5,
+    /** Default recovery timeout in milliseconds (30 seconds) */
+    RECOVERY_TIMEOUT: 30000,
+    /** Default number of successful calls needed to close circuit */
+    SUCCESS_THRESHOLD: 3,
+    /** Default time window for counting failures (1 minute) */
+    TIME_WINDOW: 60000,
+    /** Maximum failure history size to prevent memory leaks */
+    MAX_FAILURE_HISTORY_SIZE: 1000,
+    /** Periodic cleanup interval (5 minutes) */
+    CLEANUP_INTERVAL: 300000,
+    /** Cleanup trigger threshold for failures array size */
+    CLEANUP_SIZE_THRESHOLD: 100,
+};
+/**
+ * Retry configuration constants
+ */
+exports.RETRY_CONFIG = {
+    /** Base delay for exponential backoff in milliseconds */
+    BASE_DELAY: 1000,
+    /** Maximum delay for exponential backoff */
+    MAX_DELAY: 5000,
+    /** Jitter factor for randomizing delays */
+    JITTER_FACTOR: 0.1,
+};
+/**
+ * Validation constants
+ */
+exports.VALIDATION_CONFIG = {
+    /** Minimum API key length */
+    MIN_API_KEY_LENGTH: 20,
+    /** Required API key prefix for Revenium */
+    REVENIUM_API_KEY_PREFIX: 'hak_',
+    /** Required API key prefix for Anthropic */
+    ANTHROPIC_API_KEY_PREFIX: 'sk-ant-',
+    /** Maximum tokens warning threshold */
+    HIGH_MAX_TOKENS_THRESHOLD: 4096,
+    /** Temperature range */
+    MIN_TEMPERATURE: 0,
+    MAX_TEMPERATURE: 1,
+    /** Response quality score range */
+    MIN_QUALITY_SCORE: 0,
+    MAX_QUALITY_SCORE: 1,
+    /** API timeout constraints */
+    MIN_API_TIMEOUT: 1000,
+    MAX_API_TIMEOUT: 60000,
+    LOW_TIMEOUT_WARNING_THRESHOLD: 3000,
+    /** Retry constraints */
+    MAX_RETRY_ATTEMPTS: 10,
+};
+/**
+ * Logging constants
+ */
+exports.LOGGING_CONFIG = {
+    /** Middleware name for log prefixes */
+    MIDDLEWARE_NAME: 'Revenium',
+    /** User agent string for API requests */
+    USER_AGENT: 'revenium-middleware-anthropic-node/1.0.0',
+    /** Debug environment variable name */
+    DEBUG_ENV_VAR: 'REVENIUM_DEBUG',
+};
+/**
+ * Environment variable names
+ */
+exports.ENV_VARS = {
+    /** Revenium API key */
+    REVENIUM_API_KEY: 'REVENIUM_METERING_API_KEY',
+    /** Revenium base URL */
+    REVENIUM_BASE_URL: 'REVENIUM_METERING_BASE_URL',
+    /** Anthropic API key */
+    ANTHROPIC_API_KEY: 'ANTHROPIC_API_KEY',
+    /** Debug mode */
+    DEBUG: 'REVENIUM_DEBUG',
+    /** Log level */
+    LOG_LEVEL: 'REVENIUM_LOG_LEVEL',
+    /** API timeout */
+    API_TIMEOUT: 'REVENIUM_API_TIMEOUT',
+    /** Fail silent mode */
+    FAIL_SILENT: 'REVENIUM_FAIL_SILENT',
+    /** Maximum retries */
+    MAX_RETRIES: 'REVENIUM_MAX_RETRIES',
+};
+/**
+ * API endpoints
+ */
+exports.API_ENDPOINTS = {
+    /** Revenium AI completions endpoint */
+    AI_COMPLETIONS: '/v2/ai/completions',
+};
+/**
+ * Anthropic model patterns
+ */
+exports.ANTHROPIC_PATTERNS = {
+    /** Pattern to identify Claude models */
+    CLAUDE_MODEL_PATTERN: /claude/i,
+    /** Known Anthropic stop reasons */
+    STOP_REASONS: {
+        END_TURN: 'end_turn',
+        MAX_TOKENS: 'max_tokens',
+        STOP_SEQUENCE: 'stop_sequence',
+        TOOL_USE: 'tool_use',
+    },
+    /** Revenium stop reason mappings */
+    REVENIUM_STOP_REASON_MAP: {
+        'end_turn': 'END',
+        'max_tokens': 'TOKEN_LIMIT',
+        'stop_sequence': 'END_SEQUENCE',
+        'tool_use': 'END',
+    },
+};
+//# sourceMappingURL=constants.js.map

package/dist/cjs/index.js

@@ -0,0 +1,148 @@
+"use strict";
+/**
+ * Modern Revenium Anthropic Middleware
+ * Clean architecture without backward compatibility constraints
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateUsageMetadata = exports.validateAnthropicMessageParams = exports.validateReveniumConfig = exports.canExecuteRequest = exports.resetCircuitBreaker = exports.getCircuitBreakerStats = exports.extractUsageFromStream = exports.trackUsageAsync = exports.sendReveniumMetrics = exports.isAnthropicPatched = exports.unpatchAnthropic = exports.patchAnthropic = exports.validateCurrentConfig = exports.getConfigStatus = exports.getConfig = exports.getLogger = exports.setLogger = exports.setConfig = void 0;
+exports.initialize = initialize;
+exports.configure = configure;
+exports.isInitialized = isInitialized;
+exports.getStatus = getStatus;
+exports.trackAnthropicCall = trackAnthropicCall;
+exports.reset = reset;
+// Import type augmentations to extend Anthropic types with usageMetadata
+require("./types/anthropic-augmentation");
+const config_1 = require("./config");
+const wrapper_1 = require("./wrapper");
+const tracking_1 = require("./tracking");
+const circuit_breaker_1 = require("./utils/circuit-breaker");
+// Export configuration functions
+var config_2 = require("./config");
+Object.defineProperty(exports, "setConfig", { enumerable: true, get: function () { return config_2.setConfig; } });
+Object.defineProperty(exports, "setLogger", { enumerable: true, get: function () { return config_2.setLogger; } });
+Object.defineProperty(exports, "getLogger", { enumerable: true, get: function () { return config_2.getLogger; } });
+Object.defineProperty(exports, "getConfig", { enumerable: true, get: function () { return config_2.getConfig; } });
+Object.defineProperty(exports, "getConfigStatus", { enumerable: true, get: function () { return config_2.getConfigStatus; } });
+Object.defineProperty(exports, "validateCurrentConfig", { enumerable: true, get: function () { return config_2.validateCurrentConfig; } });
+// Export wrapper control functions
+var wrapper_2 = require("./wrapper");
+Object.defineProperty(exports, "patchAnthropic", { enumerable: true, get: function () { return wrapper_2.patchAnthropic; } });
+Object.defineProperty(exports, "unpatchAnthropic", { enumerable: true, get: function () { return wrapper_2.unpatchAnthropic; } });
+Object.defineProperty(exports, "isAnthropicPatched", { enumerable: true, get: function () { return wrapper_2.isAnthropicPatched; } });
+// Export tracking functions
+var tracking_2 = require("./tracking");
+Object.defineProperty(exports, "sendReveniumMetrics", { enumerable: true, get: function () { return tracking_2.sendReveniumMetrics; } });
+Object.defineProperty(exports, "trackUsageAsync", { enumerable: true, get: function () { return tracking_2.trackUsageAsync; } });
+Object.defineProperty(exports, "extractUsageFromStream", { enumerable: true, get: function () { return tracking_2.extractUsageFromStream; } });
+// Export utility functions
+var circuit_breaker_2 = require("./utils/circuit-breaker");
+Object.defineProperty(exports, "getCircuitBreakerStats", { enumerable: true, get: function () { return circuit_breaker_2.getCircuitBreakerStats; } });
+Object.defineProperty(exports, "resetCircuitBreaker", { enumerable: true, get: function () { return circuit_breaker_2.resetCircuitBreaker; } });
+Object.defineProperty(exports, "canExecuteRequest", { enumerable: true, get: function () { return circuit_breaker_2.canExecuteRequest; } });
+var validation_1 = require("./utils/validation");
+Object.defineProperty(exports, "validateReveniumConfig", { enumerable: true, get: function () { return validation_1.validateReveniumConfig; } });
+Object.defineProperty(exports, "validateAnthropicMessageParams", { enumerable: true, get: function () { return validation_1.validateAnthropicMessageParams; } });
+Object.defineProperty(exports, "validateUsageMetadata", { enumerable: true, get: function () { return validation_1.validateUsageMetadata; } });
+/**
+ * Initialize the Revenium middleware with configuration from environment variables
+ * This function can be called explicitly for better error handling and control
+ *
+ *
+ *
+ */
+// Global logger
+const logger = (0, config_1.getLogger)();
+function initialize() {
+    const initialized = (0, config_1.initializeConfig)();
+    if (!initialized) {
+        throw new Error("Failed to initialize Revenium middleware: missing required environment variables. " +
+            "Set REVENIUM_METERING_API_KEY or call configure() with manual configuration.");
+    }
+    try {
+        (0, wrapper_1.patchAnthropic)();
+        logger.info("Revenium Anthropic middleware initialized successfully");
+        logger.debug("Environment variables found and configuration loaded");
+    }
+    catch (patchError) {
+        const errorMessage = patchError instanceof Error ? patchError.message : String(patchError);
+        throw new Error(`Failed to patch Anthropic SDK: ${errorMessage}`);
+    }
+}
+/**
+ * Auto-initialization with graceful fallback
+ * Attempts to initialize automatically but doesn't throw on failure
+ */
+function autoInitialize() {
+    try {
+        initialize();
+    }
+    catch (error) {
+        // Log debug message but don't throw - allow manual configuration later
+        logger.debug("Auto-initialization failed, manual configuration required", {
+            error: error instanceof Error ? error.message : String(error),
+            suggestion: "Call initialize() or configure() explicitly for detailed error information",
+        });
+    }
+}
+// Perform auto-initialization with graceful fallback
+autoInitialize();
+/**
+ * Manual initialization with custom configuration
+ */
+function configure(config) {
+    (0, config_1.setConfig)(config);
+    (0, wrapper_1.patchAnthropic)();
+    (0, config_1.getLogger)().info("Revenium Anthropic middleware configured successfully");
+}
+/**
+ * Check if the middleware is properly initialized
+ */
+function isInitialized() {
+    return (0, wrapper_1.isAnthropicPatched)() && !!(0, config_1.getConfig)();
+}
+/**
+ * Get comprehensive middleware status
+ */
+function getStatus() {
+    const configStatus = (0, config_1.getConfigStatus)();
+    const circuitBreakerStats = (0, circuit_breaker_1.getCircuitBreakerStats)();
+    let anthropicVersion;
+    try {
+        // Try to get Anthropic version - use dynamic require for compatibility
+        const anthropicPackage = globalThis.require?.("@anthropic-ai/sdk/package.json");
+        anthropicVersion = anthropicPackage?.version;
+    }
+    catch {
+        // Ignore if we can't get the version
+    }
+    return {
+        initialized: isInitialized(),
+        patched: (0, wrapper_1.isAnthropicPatched)(),
+        hasConfig: configStatus.hasConfig,
+        anthropicVersion,
+        circuitBreakerState: circuitBreakerStats.state,
+    };
+}
+/**
+ * Manually track an Anthropic API call (for cases where auto-patching isn't used)
+ */
+function trackAnthropicCall(trackingData) {
+    return (0, tracking_1.trackUsageAsync)(trackingData);
+}
+/**
+ * Reset middleware to initial state (useful for testing)
+ */
+function reset() {
+    try {
+        (0, wrapper_1.unpatchAnthropic)();
+        (0, circuit_breaker_1.resetCircuitBreaker)();
+        logger.debug("Middleware reset completed");
+    }
+    catch (error) {
+        logger.error("Error during middleware reset", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+//# sourceMappingURL=index.js.map