@revenium/anthropic 1.0.0

package/dist/esm/utils/validation.js

@@ -0,0 +1,296 @@
+/**
+ * Validation utilities for Anthropic middleware
+ * Provides type-safe validation with detailed error reporting
+ */
+import { VALIDATION_CONFIG, ANTHROPIC_PATTERNS } from '../constants.js';
+/**
+ * Type guard for checking if a value is a non-null object
+ */
+export function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Type guard for checking if a value is a string
+ */
+export function isString(value) {
+    return typeof value === 'string';
+}
+/**
+ * Type guard for checking if a value is a number
+ */
+export function isNumber(value) {
+    return typeof value === 'number' && !isNaN(value);
+}
+/**
+ * Type guard for checking if a value is a boolean
+ */
+export function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+/**
+ * Validate and extract string from unknown value
+ */
+export function validateString(value, defaultValue = '') {
+    return isString(value) ? value : defaultValue;
+}
+/**
+ * Validate and extract number from unknown value
+ */
+export function validateNumber(value, defaultValue = 0) {
+    return isNumber(value) ? value : defaultValue;
+}
+/**
+ * Validate usage metadata object with Anthropic-specific considerations
+ */
+export function validateUsageMetadata(metadata) {
+    if (!isObject(metadata)) {
+        return {};
+    }
+    const validated = {};
+    // Validate string fields
+    const stringFields = [
+        'traceId', 'taskId', 'taskType', 'subscriberEmail', 'subscriberId',
+        'subscriberCredentialName', 'subscriberCredential', 'organizationId',
+        'subscriptionId', 'productId', 'agent'
+    ];
+    for (const field of stringFields) {
+        const value = metadata[field];
+        if (isString(value) && value.trim().length > 0) {
+            validated[field] = value.trim();
+        }
+    }
+    // Validate nested subscriber object
+    const subscriberData = metadata.subscriber;
+    if (isObject(subscriberData)) {
+        const subscriber = {};
+        // Validate subscriber.id
+        if (isString(subscriberData?.id) && subscriberData?.id?.trim()?.length > 0) {
+            subscriber.id = subscriberData?.id?.trim();
+        }
+        // Validate subscriber.email
+        if (isString(subscriberData?.email) && subscriberData?.email?.trim()?.length > 0) {
+            subscriber.email = subscriberData?.email?.trim();
+        }
+        // Validate subscriber.credential object
+        const credentialData = subscriberData?.credential;
+        if (isObject(credentialData)) {
+            const credential = {};
+            if (isString(credentialData?.name) && credentialData?.name?.trim()?.length > 0) {
+                credential.name = credentialData?.name?.trim();
+            }
+            if (isString(credentialData?.value) && credentialData?.value?.trim()?.length > 0) {
+                credential.value = credentialData?.value?.trim();
+            }
+            // Only include credential if it has at least name or value
+            if (credential?.name || credential?.value) {
+                subscriber.credential = credential;
+            }
+        }
+        // Only include subscriber if it has at least one field
+        if (subscriber?.id || subscriber?.email || subscriber?.credential) {
+            validated.subscriber = subscriber;
+        }
+    }
+    // Validate number fields
+    const responseQualityScore = metadata.responseQualityScore;
+    if (isNumber(responseQualityScore) && responseQualityScore >= 0 && responseQualityScore <= 1) {
+        validated.responseQualityScore = responseQualityScore;
+    }
+    return validated;
+}
+/**
+ * Comprehensive Revenium configuration validation for Anthropic
+ */
+export function validateReveniumConfig(config) {
+    const errors = [];
+    const warnings = [];
+    const suggestions = [];
+    if (!isObject(config)) {
+        return {
+            isValid: false,
+            errors: ['Configuration must be an object'],
+            warnings: [],
+            suggestions: ['Ensure you are passing a valid configuration object with required fields']
+        };
+    }
+    const cfg = config;
+    // Validate required Revenium API key
+    if (!isString(cfg?.reveniumApiKey)) {
+        errors.push('reveniumApiKey is required and must be a string');
+        suggestions.push('Set REVENIUM_METERING_API_KEY environment variable or provide reveniumApiKey in config');
+    }
+    else if (!cfg?.reveniumApiKey?.trim()) {
+        errors.push('reveniumApiKey cannot be empty');
+    }
+    else if (!cfg?.reveniumApiKey?.startsWith(VALIDATION_CONFIG.REVENIUM_API_KEY_PREFIX)) {
+        errors.push(`reveniumApiKey must start with "${VALIDATION_CONFIG.REVENIUM_API_KEY_PREFIX}"`);
+        suggestions.push('Obtain a valid Revenium API key from your Revenium dashboard');
+    }
+    else if (cfg?.reveniumApiKey?.length < VALIDATION_CONFIG.MIN_API_KEY_LENGTH) {
+        warnings.push('reveniumApiKey appears to be too short - verify it is correct');
+    }
+    // Validate Revenium base URL
+    if (!isString(cfg?.reveniumBaseUrl)) {
+        errors.push('reveniumBaseUrl is required and must be a string');
+    }
+    else if (!cfg?.reveniumBaseUrl?.trim()) {
+        errors.push('reveniumBaseUrl cannot be empty');
+    }
+    else {
+        try {
+            const url = new URL(cfg?.reveniumBaseUrl);
+            if (!url.protocol.startsWith('http')) {
+                errors.push('reveniumBaseUrl must use HTTP or HTTPS protocol');
+            }
+            // Check for localhost/development hostnames (IPv4, IPv6, and named)
+            const localhostHostnames = ['localhost', '127.0.0.1', '::1', '[::1]'];
+            if (localhostHostnames.includes(url.hostname)) {
+                warnings.push('Using localhost for Revenium API - ensure this is intended for development');
+            }
+        }
+        catch {
+            errors.push('reveniumBaseUrl must be a valid URL');
+            suggestions.push('Use format: https://api.revenium.io/meter');
+        }
+    }
+    // Validate optional Anthropic API key
+    if (!isString(cfg?.anthropicApiKey)) {
+        errors.push('anthropicApiKey must be a string if provided');
+    }
+    else if (cfg?.anthropicApiKey?.trim()?.length === 0) {
+        warnings.push('anthropicApiKey is empty - API calls may fail');
+    }
+    else if (!cfg?.anthropicApiKey?.startsWith(VALIDATION_CONFIG.ANTHROPIC_API_KEY_PREFIX)) {
+        warnings.push(`anthropicApiKey does not start with "${VALIDATION_CONFIG.ANTHROPIC_API_KEY_PREFIX}" - verify it is correct`);
+    }
+    // Validate optional timeout using constants
+    if (cfg?.apiTimeout !== undefined && !isNumber(cfg?.apiTimeout)) {
+        errors.push('apiTimeout must be a number if provided');
+    }
+    else if (cfg?.apiTimeout !== undefined && cfg?.apiTimeout < VALIDATION_CONFIG.MIN_API_TIMEOUT) {
+        errors.push(`apiTimeout must be at least ${VALIDATION_CONFIG.MIN_API_TIMEOUT}ms`);
+    }
+    else if (cfg?.apiTimeout !== undefined && cfg?.apiTimeout > VALIDATION_CONFIG.MAX_API_TIMEOUT) {
+        errors.push(`apiTimeout must not exceed ${VALIDATION_CONFIG.MAX_API_TIMEOUT}ms`);
+    }
+    else if (cfg?.apiTimeout !== undefined && cfg?.apiTimeout < VALIDATION_CONFIG.LOW_TIMEOUT_WARNING_THRESHOLD) {
+        warnings.push('apiTimeout is very low - may cause timeouts for slow networks');
+    }
+    // Validate optional failSilent
+    if (cfg?.failSilent && !isBoolean(cfg?.failSilent)) {
+        errors.push('failSilent must be a boolean if provided');
+    }
+    // Validate optional maxRetries using constants
+    if (cfg?.maxRetries !== undefined && !isNumber(cfg?.maxRetries)) {
+        errors.push('maxRetries must be a number if provided');
+    }
+    else if (cfg?.maxRetries !== undefined && cfg?.maxRetries < 0) {
+        errors.push('maxRetries cannot be negative');
+    }
+    else if (cfg?.maxRetries !== undefined && cfg?.maxRetries > VALIDATION_CONFIG.MAX_RETRY_ATTEMPTS) {
+        errors.push(`maxRetries should not exceed ${VALIDATION_CONFIG.MAX_RETRY_ATTEMPTS}`);
+    }
+    else if (cfg?.maxRetries !== undefined && cfg?.maxRetries === 0) {
+        warnings.push('maxRetries is 0 - no retry attempts will be made');
+    }
+    if (errors.length > 0) {
+        return {
+            isValid: false,
+            errors,
+            warnings,
+            suggestions
+        };
+    }
+    // Build validated config
+    const validatedConfig = {
+        reveniumApiKey: cfg?.reveniumApiKey,
+        reveniumBaseUrl: cfg?.reveniumBaseUrl,
+        anthropicApiKey: isString(cfg?.anthropicApiKey) ? cfg?.anthropicApiKey : undefined,
+        apiTimeout: isNumber(cfg?.apiTimeout) ? cfg?.apiTimeout : undefined,
+        failSilent: isBoolean(cfg?.failSilent) ? cfg?.failSilent : undefined,
+        maxRetries: isNumber(cfg?.maxRetries) ? cfg?.maxRetries : undefined
+    };
+    return {
+        isValid: true,
+        errors: [],
+        warnings,
+        config: validatedConfig,
+        suggestions: suggestions.length > 0 ? suggestions : undefined
+    };
+}
+/**
+ * Validate Anthropic message creation parameters
+ */
+export function validateAnthropicMessageParams(params) {
+    const errors = [];
+    const warnings = [];
+    if (!isObject(params)) {
+        return {
+            isValid: false,
+            errors: ['Message parameters must be an object'],
+            warnings: []
+        };
+    }
+    const data = params;
+    // Validate required model field
+    if (!isString(data?.model)) {
+        errors.push('model field is required and must be a string');
+    }
+    else if (data?.model?.trim()?.length === 0) {
+        errors.push('model field cannot be empty');
+    }
+    else if (!ANTHROPIC_PATTERNS.CLAUDE_MODEL_PATTERN.test(data?.model)) {
+        warnings.push('Model name does not contain "claude" - verify it is a valid Anthropic model');
+    }
+    // Validate required messages array
+    if (!Array.isArray(data?.messages)) {
+        errors.push('messages field is required and must be an array');
+    }
+    else if (data?.messages?.length === 0) {
+        errors.push('messages array cannot be empty');
+    }
+    else {
+        // Validate message structure
+        data?.messages?.forEach((message, index) => {
+            if (!isObject(message)) {
+                errors.push(`Message at index ${index} must be an object`);
+                return;
+            }
+            const msg = message;
+            if (!isString(msg.role)) {
+                errors.push(`Message at index ${index} must have a role field`);
+            }
+            else if (!['user', 'assistant', 'system'].includes(msg.role)) {
+                warnings.push(`Message at index ${index} has unusual role: ${msg.role}`);
+            }
+            if (msg?.content && !isString(msg?.content) && !Array.isArray(msg?.content)) {
+                warnings.push(`Message at index ${index} content should be a string or array`);
+            }
+        });
+    }
+    // Validate optional parameters
+    if (!isNumber(data?.max_tokens)) {
+        warnings.push('max_tokens should be a number');
+    }
+    else if (data?.max_tokens <= 0) {
+        warnings.push('max_tokens should be positive');
+    }
+    else if (data?.max_tokens > VALIDATION_CONFIG.HIGH_MAX_TOKENS_THRESHOLD) {
+        warnings.push('max_tokens is very high - verify this is intended');
+    }
+    if (!isNumber(data?.temperature)) {
+        warnings.push('temperature should be a number');
+    }
+    else if (data?.temperature < VALIDATION_CONFIG.MIN_TEMPERATURE || data?.temperature > VALIDATION_CONFIG.MAX_TEMPERATURE) {
+        warnings.push(`temperature should be between ${VALIDATION_CONFIG.MIN_TEMPERATURE} and ${VALIDATION_CONFIG.MAX_TEMPERATURE} for Anthropic models`);
+    }
+    if (data?.stream && !isBoolean(data?.stream)) {
+        warnings.push('stream should be a boolean');
+    }
+    return {
+        isValid: errors.length === 0,
+        errors,
+        warnings
+    };
+}
+//# sourceMappingURL=validation.js.map

package/dist/esm/wrapper.js

@@ -0,0 +1,366 @@
+/**
+ * Anthropic SDK wrapper with type safety and structured error handling
+ */
+import Anthropic from '@anthropic-ai/sdk';
+import { getLogger } from './config.js';
+import { trackUsageAsync, extractUsageFromResponse, extractUsageFromStream } from './tracking.js';
+import { validateAnthropicMessageParams, validateUsageMetadata } from './utils/validation.js';
+import { AnthropicPatchingError, RequestProcessingError, StreamProcessingError, createErrorContext, handleError } from './utils/error-handling.js';
+import { randomUUID } from 'crypto';
+// Global logger
+const logger = 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 (Anthropic?.Messages)
+            return Anthropic?.Messages?.prototype;
+        // Method 2: Try to access through the constructor's static properties
+        const anthropicConstructor = Anthropic;
+        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 AnthropicPatchingError('Unable to access Anthropic Messages prototype: No API key available and direct prototype access failed');
+        }
+        const minimalInstance = new Anthropic({ 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 AnthropicPatchingError(`Unable to access Anthropic Messages prototype: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Patch Anthropic SDK by modifying prototype methods
+ */
+export function patchAnthropic() {
+    if (patchingContext.isPatched)
+        return;
+    try {
+        // Access the Messages class prototype using sophisticated prototype access
+        const messagesPrototype = getMessagesPrototype();
+        if (!messagesPrototype)
+            throw new 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 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 = createErrorContext()
+            .with('patchingAttempt', true)
+            .build();
+        handleError(error, logger, errorContext);
+        if (error instanceof AnthropicPatchingError)
+            throw error;
+        throw new AnthropicPatchingError(`Failed to patch Anthropic SDK: ${error instanceof Error ? error.message : String(error)}`, errorContext);
+    }
+}
+/**
+ * Unpatch Anthropic SDK (restore original methods)
+ */
+export 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 = createErrorContext()
+            .with('unpatchingAttempt', true)
+            .build();
+        handleError(error, logger, errorContext);
+        throw new AnthropicPatchingError(`Failed to unpatch Anthropic SDK: ${error instanceof Error ? error.message : String(error)}`, errorContext);
+    }
+}
+/**
+ * Check if Anthropic SDK is patched
+ */
+export 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 = 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
+            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 = 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 = validateAnthropicMessageParams(params);
+    if (!validation.isValid) {
+        logger.warn('Invalid Anthropic parameters detected', {
+            requestId,
+            errors: validation.errors,
+            warnings: validation.warnings
+        });
+    }
+    // Extract and validate metadata
+    const metadata = 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 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 = 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
+            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 = createErrorContext()
+            .withRequestId(requestId)
+            .withModel(params.model)
+            .withDuration(duration)
+            .build();
+        handleError(error, logger, errorContext);
+        throw error;
+    }
+}
+/**
+ * Patched stream method implementation
+ */
+async function* patchedStreamMethod(params, options) {
+    const requestId = 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 = 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 = 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 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 = 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
+        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 = createErrorContext()
+            .withRequestId(requestId)
+            .withModel(params.model)
+            .withDuration(duration)
+            .with('isStreaming', true)
+            .with('chunkCount', chunks.length)
+            .build();
+        handleError(error, logger, errorContext);
+        throw error;
+    }
+}
+//# sourceMappingURL=wrapper.js.map