@revenium/anthropic 1.0.0

package/dist/cjs/wrapper.js

@@ -0,0 +1,374 @@
+"use strict";
+/**
+ * Anthropic SDK wrapper with type safety and structured error handling
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.patchAnthropic = patchAnthropic;
+exports.unpatchAnthropic = unpatchAnthropic;
+exports.isAnthropicPatched = isAnthropicPatched;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const config_1 = require("./config");
+const tracking_1 = require("./tracking");
+const validation_1 = require("./utils/validation");
+const error_handling_1 = require("./utils/error-handling");
+const crypto_1 = require("crypto");
+// Global logger
+const logger = (0, config_1.getLogger)();
+/**
+ * Global patching context
+ */
+const patchingContext = {
+    originalMethods: {},
+    isPatched: false,
+    patchedInstances: new WeakSet()
+};
+/**
+ * Get the Messages prototype using sophisticated prototype access
+ * Uses multiple fallback strategies to access the Anthropic Messages class prototype
+ */
+function getMessagesPrototype() {
+    try {
+        // Method 1: Try to access through the constructor's prototype chain
+        // Look for the Messages constructor in the Anthropic module
+        // The Anthropic SDK typically exposes internal classes through the constructor
+        if (sdk_1.default?.Messages)
+            return sdk_1.default?.Messages?.prototype;
+        // Method 2: Try to access through the constructor's static properties
+        const anthropicConstructor = sdk_1.default;
+        if (anthropicConstructor?._Messages)
+            return anthropicConstructor?._Messages?.prototype;
+        // Method 3: Create a minimal instance with the real API key if available
+        // Fallback approach when direct prototype access methods fail
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            throw new error_handling_1.AnthropicPatchingError('Unable to access Anthropic Messages prototype: No API key available and direct prototype access failed');
+        }
+        const minimalInstance = new sdk_1.default({ apiKey });
+        const messagesPrototype = Object.getPrototypeOf(minimalInstance.messages);
+        // Clean up the minimal instance immediately
+        // Note: The instance will be garbage collected, but the prototype reference remains
+        return messagesPrototype;
+    }
+    catch (error) {
+        // If all methods fail, throw a descriptive error
+        throw new error_handling_1.AnthropicPatchingError(`Unable to access Anthropic Messages prototype: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Patch Anthropic SDK by modifying prototype methods
+ */
+function patchAnthropic() {
+    if (patchingContext.isPatched)
+        return;
+    try {
+        // Access the Messages class prototype using sophisticated prototype access
+        const messagesPrototype = getMessagesPrototype();
+        if (!messagesPrototype)
+            throw new error_handling_1.AnthropicPatchingError('Unable to access Anthropic Messages prototype');
+        // Store original methods
+        patchingContext.originalMethods.create = messagesPrototype?.create;
+        patchingContext.originalMethods.stream = messagesPrototype?.stream;
+        if (!patchingContext.originalMethods?.create) {
+            throw new error_handling_1.AnthropicPatchingError('Unable to find original create method');
+        }
+        // Patch the create method
+        const patchedCreateFunction = function (params, options) {
+            return patchedCreateMethod.call(this, params, options);
+        };
+        messagesPrototype.create = patchedCreateFunction;
+        // Patch the stream method if it exists
+        if (patchingContext.originalMethods?.stream) {
+            messagesPrototype.stream = function (params, options) {
+                return patchedStreamMethod.call(this, params, options);
+            };
+        }
+        patchingContext.isPatched = true;
+        logger.info('Anthropic SDK patched successfully');
+    }
+    catch (error) {
+        const errorContext = (0, error_handling_1.createErrorContext)()
+            .with('patchingAttempt', true)
+            .build();
+        (0, error_handling_1.handleError)(error, logger, errorContext);
+        if (error instanceof error_handling_1.AnthropicPatchingError)
+            throw error;
+        throw new error_handling_1.AnthropicPatchingError(`Failed to patch Anthropic SDK: ${error instanceof Error ? error.message : String(error)}`, errorContext);
+    }
+}
+/**
+ * Unpatch Anthropic SDK (restore original methods)
+ */
+function unpatchAnthropic() {
+    if (!patchingContext.isPatched)
+        return;
+    try {
+        // Access the Messages class prototype using sophisticated prototype access
+        const messagesPrototype = getMessagesPrototype();
+        if (messagesPrototype && patchingContext.originalMethods.create) {
+            messagesPrototype.create = patchingContext.originalMethods.create;
+        }
+        if (messagesPrototype && patchingContext.originalMethods.stream) {
+            messagesPrototype.stream = patchingContext.originalMethods?.stream;
+        }
+        patchingContext.isPatched = false;
+        patchingContext.originalMethods = {};
+        logger.info('Anthropic SDK unpatched successfully');
+    }
+    catch (error) {
+        const errorContext = (0, error_handling_1.createErrorContext)()
+            .with('unpatchingAttempt', true)
+            .build();
+        (0, error_handling_1.handleError)(error, logger, errorContext);
+        throw new error_handling_1.AnthropicPatchingError(`Failed to unpatch Anthropic SDK: ${error instanceof Error ? error.message : String(error)}`, errorContext);
+    }
+}
+/**
+ * Check if Anthropic SDK is patched
+ */
+function isAnthropicPatched() {
+    return patchingContext.isPatched;
+}
+/**
+ * Handle streaming response by collecting chunks and extracting usage data
+ */
+async function handleStreamingResponse(stream, context) {
+    const { requestId, model, metadata, requestTime, startTime } = context;
+    // Create a new async generator that collects chunks and tracks usage
+    async function* trackingStream() {
+        const chunks = [];
+        let firstTokenTime;
+        try {
+            for await (const chunk of stream) {
+                // Track first token time
+                if (!firstTokenTime && chunk.type === 'content_block_delta') {
+                    firstTokenTime = Date.now();
+                }
+                chunks.push(chunk);
+                yield chunk;
+            }
+            // After stream completes, extract usage and track
+            const endTime = Date.now();
+            const responseTime = new Date();
+            const duration = endTime - startTime;
+            logger.debug('Stream completed, extracting usage', {
+                requestId,
+                chunkCount: chunks.length,
+                duration
+            });
+            const usage = (0, tracking_1.extractUsageFromStream)(chunks);
+            // Create tracking data
+            const trackingData = {
+                requestId,
+                model,
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                cacheCreationTokens: usage.cacheCreationTokens,
+                cacheReadTokens: usage.cacheReadTokens,
+                duration,
+                isStreamed: true,
+                stopReason: usage.stopReason,
+                metadata,
+                requestTime,
+                responseTime
+            };
+            // Track usage asynchronously
+            (0, tracking_1.trackUsageAsync)(trackingData);
+            logger.debug('Anthropic streaming request completed successfully', {
+                requestId,
+                model,
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                duration
+            });
+        }
+        catch (error) {
+            logger.error('Error processing streaming response', {
+                requestId,
+                error: error instanceof Error ? error.message : String(error)
+            });
+            throw error;
+        }
+    }
+    return trackingStream();
+}
+/**
+ * Patched create method implementation
+ */
+async function patchedCreateMethod(params, options) {
+    const requestId = (0, crypto_1.randomUUID)();
+    const startTime = Date.now();
+    const requestTime = new Date();
+    logger.debug('Intercepted Anthropic messages.create call', {
+        requestId,
+        model: params.model,
+        hasMetadata: !!params.usageMetadata,
+        isStreaming: !!params.stream
+    });
+    // Validate parameters
+    const validation = (0, validation_1.validateAnthropicMessageParams)(params);
+    if (!validation.isValid) {
+        logger.warn('Invalid Anthropic parameters detected', {
+            requestId,
+            errors: validation.errors,
+            warnings: validation.warnings
+        });
+    }
+    // Extract and validate metadata
+    const metadata = (0, validation_1.validateUsageMetadata)(params.usageMetadata || {});
+    // Remove usageMetadata from params before calling original method
+    const { usageMetadata, ...cleanParams } = params;
+    try {
+        // Call original method
+        const originalCreate = patchingContext.originalMethods.create;
+        if (!originalCreate)
+            throw new error_handling_1.RequestProcessingError('Original create method not available');
+        const response = await originalCreate.call(this, cleanParams, options);
+        // Check if this is a streaming response
+        const isStreaming = !!params.stream;
+        if (!isStreaming) {
+            const endTime = Date.now();
+            const duration = endTime - startTime;
+            const responseTime = new Date();
+            // Extract usage information
+            const usage = (0, tracking_1.extractUsageFromResponse)(response);
+            // Create tracking data
+            const trackingData = {
+                requestId,
+                model: params.model,
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                cacheCreationTokens: usage.cacheCreationTokens,
+                cacheReadTokens: usage.cacheReadTokens,
+                duration,
+                isStreamed: false,
+                stopReason: usage.stopReason,
+                metadata,
+                requestTime,
+                responseTime
+            };
+            // Track usage asynchronously
+            (0, tracking_1.trackUsageAsync)(trackingData);
+            logger.debug('Anthropic request completed successfully', {
+                requestId,
+                model: params.model,
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                duration
+            });
+            return response;
+        }
+        // Handle streaming response - need to collect chunks and extract usage
+        return handleStreamingResponse(response, {
+            requestId,
+            model: params.model,
+            metadata,
+            requestTime,
+            startTime
+        });
+    }
+    catch (error) {
+        const endTime = Date.now();
+        const duration = endTime - startTime;
+        const errorContext = (0, error_handling_1.createErrorContext)()
+            .withRequestId(requestId)
+            .withModel(params.model)
+            .withDuration(duration)
+            .build();
+        (0, error_handling_1.handleError)(error, logger, errorContext);
+        throw error;
+    }
+}
+/**
+ * Patched stream method implementation
+ */
+async function* patchedStreamMethod(params, options) {
+    const requestId = (0, crypto_1.randomUUID)();
+    const startTime = Date.now();
+    const requestTime = new Date();
+    const responseTime = new Date();
+    const chunks = [];
+    let firstTokenTime;
+    logger.debug('Intercepted Anthropic messages.stream call', {
+        requestId,
+        model: params.model,
+        hasMetadata: !!params.usageMetadata
+    });
+    // Validate parameters
+    const validation = (0, validation_1.validateAnthropicMessageParams)(params);
+    if (!validation.isValid) {
+        logger.warn('Invalid Anthropic streaming parameters detected', {
+            requestId,
+            errors: validation.errors,
+            warnings: validation.warnings
+        });
+    }
+    // Extract and validate metadata
+    const metadata = (0, validation_1.validateUsageMetadata)(params.usageMetadata || {});
+    // Remove usageMetadata from params before calling original method
+    const { usageMetadata, ...cleanParams } = params;
+    try {
+        // Call original stream method
+        const originalStream = patchingContext.originalMethods?.stream;
+        if (!originalStream) {
+            throw new error_handling_1.StreamProcessingError('Original stream method not available');
+        }
+        const stream = originalStream.call(this, cleanParams, options);
+        for await (const chunk of stream) {
+            // Track first token time
+            if (!firstTokenTime && chunk.type === 'content_block_delta') {
+                firstTokenTime = Date.now();
+            }
+            chunks.push(chunk);
+            yield chunk;
+        }
+        const endTime = Date.now();
+        const duration = endTime - startTime;
+        const timeToFirstToken = firstTokenTime ? firstTokenTime - startTime : undefined;
+        // Extract usage information from all chunks
+        const usage = (0, tracking_1.extractUsageFromStream)(chunks);
+        // Create tracking data
+        const trackingData = {
+            requestId,
+            model: params.model,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cacheCreationTokens: usage.cacheCreationTokens,
+            cacheReadTokens: usage.cacheReadTokens,
+            duration,
+            isStreamed: true,
+            stopReason: usage.stopReason,
+            metadata,
+            requestTime,
+            responseTime,
+            timeToFirstToken
+        };
+        // Track usage asynchronously
+        (0, tracking_1.trackUsageAsync)(trackingData);
+        logger.debug('Anthropic streaming request completed successfully', {
+            requestId,
+            model: params.model,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            duration,
+            timeToFirstToken,
+            chunkCount: chunks.length
+        });
+    }
+    catch (error) {
+        const endTime = Date.now();
+        const duration = endTime - startTime;
+        const errorContext = (0, error_handling_1.createErrorContext)()
+            .withRequestId(requestId)
+            .withModel(params.model)
+            .withDuration(duration)
+            .with('isStreaming', true)
+            .with('chunkCount', chunks.length)
+            .build();
+        (0, error_handling_1.handleError)(error, logger, errorContext);
+        throw error;
+    }
+}
+//# sourceMappingURL=wrapper.js.map

package/dist/esm/config.js

@@ -0,0 +1,197 @@
+import { validateReveniumConfig } from './utils/validation.js';
+import { DEFAULT_CONFIG, ENV_VARS, LOGGING_CONFIG } from './constants.js';
+/**
+ * Simple console logger implementation for Anthropic middleware
+ */
+class ConsoleLogger {
+    isDebugEnabled() {
+        return process.env[ENV_VARS.DEBUG] === 'true';
+    }
+    formatMessage(level, message, context) {
+        const timestamp = new Date().toISOString();
+        const prefix = `[${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
+ */
+export const defaultLogger = new ConsoleLogger();
+/**
+ * Load configuration from environment variables
+ */
+function loadConfigFromEnvironment() {
+    const env = {
+        reveniumApiKey: process.env[ENV_VARS.REVENIUM_API_KEY],
+        reveniumBaseUrl: process.env[ENV_VARS.REVENIUM_BASE_URL],
+        anthropicApiKey: process.env[ENV_VARS.ANTHROPIC_API_KEY],
+        debug: process.env[ENV_VARS.DEBUG] === 'true',
+        logLevel: process.env[ENV_VARS.LOG_LEVEL],
+        apiTimeout: process.env[ENV_VARS.API_TIMEOUT],
+        failSilent: process.env[ENV_VARS.FAIL_SILENT],
+        maxRetries: process.env[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 || DEFAULT_CONFIG.REVENIUM_BASE_URL,
+        anthropicApiKey: env.anthropicApiKey,
+        apiTimeout,
+        failSilent,
+        maxRetries
+    };
+}
+/**
+ * Validate Revenium configuration with enhanced error reporting
+ */
+export function validateConfig(config) {
+    const validation = 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 = defaultLogger;
+/**
+ * Get the current global configuration
+ */
+export function getConfig() {
+    return globalConfig;
+}
+/**
+ * Set the global configuration
+ */
+export 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
+ */
+export function getLogger() {
+    return globalLogger;
+}
+/**
+ * Set a custom logger
+ */
+export function setLogger(logger) {
+    globalLogger = logger;
+    globalLogger.debug('Custom logger set for Revenium middleware');
+}
+/**
+ * Initialize configuration from environment variables
+ */
+export 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 ${ENV_VARS.REVENIUM_API_KEY} environment variable`);
+        globalLogger.info(`Set ${ENV_VARS.REVENIUM_API_KEY} to enable automatic tracking`);
+    }
+    return false;
+}
+/**
+ * Get configuration status
+ */
+export 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
+ */
+export function validateCurrentConfig() {
+    if (!globalConfig)
+        return false;
+    try {
+        const validation = validateReveniumConfig(globalConfig);
+        return validation.isValid;
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=config.js.map