@revenium/anthropic 1.0.7 → 1.0.9

package/dist/cjs/utils/validation.js

@@ -139,38 +139,40 @@ function validateReveniumConfig(config) {
     else if (cfg?.reveniumApiKey?.length < constants_1.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');
+    // Validate Revenium base URL (optional - defaults to https://api.revenium.ai)
+    if (cfg?.reveniumBaseUrl !== undefined) {
+        if (!isString(cfg?.reveniumBaseUrl)) {
+            errors.push('reveniumBaseUrl must be a string if provided');
+        }
+        else if (!cfg?.reveniumBaseUrl?.trim()) {
+            errors.push('reveniumBaseUrl cannot be empty if provided');
+        }
+        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');
+                }
             }
-            // 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.ai');
             }
         }
-        catch {
-            errors.push('reveniumBaseUrl must be a valid URL');
-            suggestions.push('Use format: https://api.revenium.io');
-        }
     }
     // Validate optional Anthropic API key
-    if (!isString(cfg?.anthropicApiKey)) {
+    if (cfg?.anthropicApiKey !== undefined && !isString(cfg?.anthropicApiKey)) {
         errors.push('anthropicApiKey must be a string if provided');
     }
-    else if (cfg?.anthropicApiKey?.trim()?.length === 0) {
+    else if (cfg?.anthropicApiKey !== undefined && cfg?.anthropicApiKey?.trim()?.length === 0) {
         warnings.push('anthropicApiKey is empty - API calls may fail');
     }
-    else if (!cfg?.anthropicApiKey?.startsWith(constants_1.VALIDATION_CONFIG.ANTHROPIC_API_KEY_PREFIX)) {
+    else if (cfg?.anthropicApiKey && !cfg?.anthropicApiKey?.startsWith(constants_1.VALIDATION_CONFIG.ANTHROPIC_API_KEY_PREFIX)) {
         warnings.push(`anthropicApiKey does not start with "${constants_1.VALIDATION_CONFIG.ANTHROPIC_API_KEY_PREFIX}" - verify it is correct`);
     }
     // Validate optional timeout using constants
@@ -203,6 +205,23 @@ function validateReveniumConfig(config) {
     else if (cfg?.maxRetries !== undefined && cfg?.maxRetries === 0) {
         warnings.push('maxRetries is 0 - no retry attempts will be made');
     }
+    // Validate optional printSummary
+    if (cfg?.printSummary !== undefined) {
+        const validPrintSummaryValues = [true, false, 'human', 'json'];
+        if (!validPrintSummaryValues.includes(cfg?.printSummary)) {
+            errors.push("printSummary must be a boolean or one of: 'human', 'json'");
+            suggestions.push("Use printSummary: true, 'human', or 'json' to enable summary output");
+        }
+    }
+    // Validate optional teamId
+    if (cfg?.teamId !== undefined) {
+        if (!isString(cfg?.teamId)) {
+            errors.push('teamId must be a string if provided');
+        }
+        else if (cfg?.teamId?.trim()?.length === 0) {
+            errors.push('teamId cannot be empty if provided');
+        }
+    }
     if (errors.length > 0) {
         return {
             isValid: false,
@@ -211,14 +230,27 @@ function validateReveniumConfig(config) {
             suggestions
         };
     }
-    // Build validated config
+    // Determine validated printSummary value
+    let validatedPrintSummary;
+    if (cfg?.printSummary === true || cfg?.printSummary === 'human') {
+        validatedPrintSummary = 'human';
+    }
+    else if (cfg?.printSummary === 'json') {
+        validatedPrintSummary = 'json';
+    }
+    else if (cfg?.printSummary === false) {
+        validatedPrintSummary = false;
+    }
+    // Build validated config (apply default for reveniumBaseUrl if not provided)
     const validatedConfig = {
         reveniumApiKey: cfg?.reveniumApiKey,
-        reveniumBaseUrl: cfg?.reveniumBaseUrl,
+        reveniumBaseUrl: isString(cfg?.reveniumBaseUrl) ? cfg?.reveniumBaseUrl : constants_1.DEFAULT_CONFIG.REVENIUM_BASE_URL,
         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
+        maxRetries: isNumber(cfg?.maxRetries) ? cfg?.maxRetries : undefined,
+        printSummary: validatedPrintSummary,
+        teamId: isString(cfg?.teamId) ? cfg?.teamId?.trim() : undefined
     };
     return {
         isValid: true,

package/dist/cjs/wrapper.js

@@ -23,7 +23,7 @@ const logger = (0, config_1.getLogger)();
 const patchingContext = {
     originalMethods: {},
     isPatched: false,
-    patchedInstances: new WeakSet()
+    patchedInstances: new WeakSet(),
 };
 /**
  * Get the Messages prototype using sophisticated prototype access
@@ -42,9 +42,12 @@ function getMessagesPrototype() {
             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;
+        // Check config first, then environment variable
+        const config = (0, config_1.getConfig)();
+        const apiKey = config?.anthropicApiKey ?? 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');
+            throw new error_handling_1.AnthropicPatchingError("Unable to access Anthropic Messages prototype: No API key available and direct prototype access failed. " +
+                "Provide ANTHROPIC_API_KEY environment variable or pass anthropicApiKey in config.");
         }
         const minimalInstance = new sdk_1.default({ apiKey });
         const messagesPrototype = Object.getPrototypeOf(minimalInstance.messages);
@@ -62,19 +65,19 @@ function getMessagesPrototype() {
  */
 function patchAnthropic() {
     if (patchingContext.isPatched) {
-        logger.debug('Anthropic SDK already patched, skipping duplicate initialization');
+        logger.debug("Anthropic SDK already patched, skipping duplicate initialization");
         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');
+            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');
+            throw new error_handling_1.AnthropicPatchingError("Unable to find original create method");
         }
         // Patch the create method
         const patchedCreateFunction = function (params, options) {
@@ -88,11 +91,11 @@ function patchAnthropic() {
             };
         }
         patchingContext.isPatched = true;
-        logger.info('Anthropic SDK patched successfully');
+        logger.info("Anthropic SDK patched successfully");
     }
     catch (error) {
         const errorContext = (0, error_handling_1.createErrorContext)()
-            .with('patchingAttempt', true)
+            .with("patchingAttempt", true)
             .build();
         (0, error_handling_1.handleError)(error, logger, errorContext);
         if (error instanceof error_handling_1.AnthropicPatchingError)
@@ -117,11 +120,11 @@ function unpatchAnthropic() {
         }
         patchingContext.isPatched = false;
         patchingContext.originalMethods = {};
-        logger.info('Anthropic SDK unpatched successfully');
+        logger.info("Anthropic SDK unpatched successfully");
     }
     catch (error) {
         const errorContext = (0, error_handling_1.createErrorContext)()
-            .with('unpatchingAttempt', true)
+            .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);
@@ -137,7 +140,7 @@ function isAnthropicPatched() {
  * Handle streaming response by collecting chunks and extracting usage data
  */
 async function handleStreamingResponse(stream, context) {
-    const { requestId, model, metadata, requestTime, startTime } = context;
+    const { requestId, model, metadata, requestTime, startTime, requestBody } = context;
     // Create a new async generator that collects chunks and tracks usage
     async function* trackingStream() {
         const chunks = [];
@@ -145,7 +148,7 @@ async function handleStreamingResponse(stream, context) {
         try {
             for await (const chunk of stream) {
                 // Track first token time
-                if (!firstTokenTime && chunk.type === 'content_block_delta') {
+                if (!firstTokenTime && chunk.type === "content_block_delta") {
                     firstTokenTime = Date.now();
                 }
                 chunks.push(chunk);
@@ -155,10 +158,14 @@ async function handleStreamingResponse(stream, context) {
             const endTime = Date.now();
             const responseTime = new Date();
             const duration = endTime - startTime;
-            logger.debug('Stream completed, extracting usage', {
+            const timeToFirstToken = firstTokenTime
+                ? firstTokenTime - startTime
+                : undefined;
+            logger.debug("Stream completed, extracting usage", {
                 requestId,
                 chunkCount: chunks.length,
-                duration
+                duration,
+                timeToFirstToken,
             });
             const usage = (0, tracking_1.extractUsageFromStream)(chunks);
             // Create tracking data
@@ -174,22 +181,24 @@ async function handleStreamingResponse(stream, context) {
                 stopReason: usage.stopReason,
                 metadata,
                 requestTime,
-                responseTime
+                responseTime,
+                timeToFirstToken,
+                requestBody: requestBody,
             };
             // Track usage asynchronously
             (0, tracking_1.trackUsageAsync)(trackingData);
-            logger.debug('Anthropic streaming request completed successfully', {
+            logger.debug("Anthropic streaming request completed successfully", {
                 requestId,
                 model,
                 inputTokens: usage.inputTokens,
                 outputTokens: usage.outputTokens,
-                duration
+                duration,
             });
         }
         catch (error) {
-            logger.error('Error processing streaming response', {
+            logger.error("Error processing streaming response", {
                 requestId,
-                error: error instanceof Error ? error.message : String(error)
+                error: error instanceof Error ? error.message : String(error),
             });
             throw error;
         }
@@ -203,19 +212,19 @@ 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', {
+    logger.debug("Intercepted Anthropic messages.create call", {
         requestId,
         model: params.model,
         hasMetadata: !!params.usageMetadata,
-        isStreaming: !!params.stream
+        isStreaming: !!params.stream,
     });
     // Validate parameters
     const validation = (0, validation_1.validateAnthropicMessageParams)(params);
     if (!validation.isValid) {
-        logger.warn('Invalid Anthropic parameters detected', {
+        logger.warn("Invalid Anthropic parameters detected", {
             requestId,
             errors: validation.errors,
-            warnings: validation.warnings
+            warnings: validation.warnings,
         });
     }
     // Extract and validate metadata
@@ -226,7 +235,7 @@ async function patchedCreateMethod(params, options) {
         // Call original method
         const originalCreate = patchingContext.originalMethods.create;
         if (!originalCreate)
-            throw new error_handling_1.RequestProcessingError('Original create method not available');
+            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;
@@ -249,16 +258,17 @@ async function patchedCreateMethod(params, options) {
                 stopReason: usage.stopReason,
                 metadata,
                 requestTime,
-                responseTime
+                responseTime,
+                requestBody: params,
             };
             // Track usage asynchronously
             (0, tracking_1.trackUsageAsync)(trackingData);
-            logger.debug('Anthropic request completed successfully', {
+            logger.debug("Anthropic request completed successfully", {
                 requestId,
                 model: params.model,
                 inputTokens: usage.inputTokens,
                 outputTokens: usage.outputTokens,
-                duration
+                duration,
             });
             return response;
         }
@@ -268,7 +278,8 @@ async function patchedCreateMethod(params, options) {
             model: params.model,
             metadata,
             requestTime,
-            startTime
+            startTime,
+            requestBody: params,
         });
     }
     catch (error) {
@@ -293,18 +304,18 @@ async function* patchedStreamMethod(params, options) {
     const responseTime = new Date();
     const chunks = [];
     let firstTokenTime;
-    logger.debug('Intercepted Anthropic messages.stream call', {
+    logger.debug("Intercepted Anthropic messages.stream call", {
         requestId,
         model: params.model,
-        hasMetadata: !!params.usageMetadata
+        hasMetadata: !!params.usageMetadata,
     });
     // Validate parameters
     const validation = (0, validation_1.validateAnthropicMessageParams)(params);
     if (!validation.isValid) {
-        logger.warn('Invalid Anthropic streaming parameters detected', {
+        logger.warn("Invalid Anthropic streaming parameters detected", {
             requestId,
             errors: validation.errors,
-            warnings: validation.warnings
+            warnings: validation.warnings,
         });
     }
     // Extract and validate metadata
@@ -315,12 +326,12 @@ async function* patchedStreamMethod(params, options) {
         // Call original stream method
         const originalStream = patchingContext.originalMethods?.stream;
         if (!originalStream) {
-            throw new error_handling_1.StreamProcessingError('Original stream method not available');
+            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') {
+            if (!firstTokenTime && chunk.type === "content_block_delta") {
                 firstTokenTime = Date.now();
             }
             chunks.push(chunk);
@@ -328,7 +339,9 @@ async function* patchedStreamMethod(params, options) {
         }
         const endTime = Date.now();
         const duration = endTime - startTime;
-        const timeToFirstToken = firstTokenTime ? firstTokenTime - startTime : undefined;
+        const timeToFirstToken = firstTokenTime
+            ? firstTokenTime - startTime
+            : undefined;
         // Extract usage information from all chunks
         const usage = (0, tracking_1.extractUsageFromStream)(chunks);
         // Create tracking data
@@ -345,18 +358,19 @@ async function* patchedStreamMethod(params, options) {
             metadata,
             requestTime,
             responseTime,
-            timeToFirstToken
+            timeToFirstToken,
+            requestBody: params,
         };
         // Track usage asynchronously
         (0, tracking_1.trackUsageAsync)(trackingData);
-        logger.debug('Anthropic streaming request completed successfully', {
+        logger.debug("Anthropic streaming request completed successfully", {
             requestId,
             model: params.model,
             inputTokens: usage.inputTokens,
             outputTokens: usage.outputTokens,
             duration,
             timeToFirstToken,
-            chunkCount: chunks.length
+            chunkCount: chunks.length,
         });
     }
     catch (error) {
@@ -366,8 +380,8 @@ async function* patchedStreamMethod(params, options) {
             .withRequestId(requestId)
             .withModel(params.model)
             .withDuration(duration)
-            .with('isStreaming', true)
-            .with('chunkCount', chunks.length)
+            .with("isStreaming", true)
+            .with("chunkCount", chunks.length)
             .build();
         (0, error_handling_1.handleError)(error, logger, errorContext);
         throw error;

package/dist/esm/config.js

@@ -44,10 +44,27 @@ function loadConfigFromEnvironment() {
         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]
+        maxRetries: process.env[ENV_VARS.MAX_RETRIES],
+        printSummary: process.env[ENV_VARS.PRINT_SUMMARY],
+        teamId: process.env[ENV_VARS.TEAM_ID]
     };
     return env;
 }
+/**
+ * Parse printSummary environment variable value
+ */
+function parsePrintSummary(value) {
+    if (!value)
+        return undefined;
+    const lowerValue = value.toLowerCase();
+    if (lowerValue === 'true' || lowerValue === 'human')
+        return 'human';
+    if (lowerValue === 'json')
+        return 'json';
+    if (lowerValue === 'false')
+        return false;
+    return undefined;
+}
 /**
  * Convert environment config to Revenium config
  */
@@ -58,13 +75,16 @@ function createConfigFromEnvironment(env) {
     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;
+    const printSummary = parsePrintSummary(env.printSummary);
     return {
         reveniumApiKey: env.reveniumApiKey,
         reveniumBaseUrl: env.reveniumBaseUrl || DEFAULT_CONFIG.REVENIUM_BASE_URL,
         anthropicApiKey: env.anthropicApiKey,
         apiTimeout,
         failSilent,
-        maxRetries
+        maxRetries,
+        printSummary,
+        teamId: env.teamId?.trim()
     };
 }
 /**
@@ -112,14 +132,42 @@ export function getConfig() {
 }
 /**
  * Set the global configuration
+ * Uses the normalized config from validation (with defaults applied and fields trimmed)
  */
 export function setConfig(config) {
-    validateConfig(config);
-    globalConfig = 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
+        });
+    }
+    // Use the normalized config from validation (with defaults applied and fields trimmed)
+    globalConfig = validation.config;
     globalLogger.debug('Revenium configuration updated', {
-        baseUrl: config.reveniumBaseUrl,
-        hasApiKey: !!config.reveniumApiKey,
-        hasAnthropicKey: !!config.anthropicApiKey
+        baseUrl: globalConfig.reveniumBaseUrl,
+        hasApiKey: !!globalConfig.reveniumApiKey,
+        hasAnthropicKey: !!globalConfig.anthropicApiKey
     });
 }
 /**

package/dist/esm/constants.js

@@ -7,7 +7,7 @@
  */
 export const DEFAULT_CONFIG = {
     /** Default Revenium API base URL */
-    REVENIUM_BASE_URL: 'https://api.revenium.io',
+    REVENIUM_BASE_URL: "https://api.revenium.ai",
     /** Default API timeout in milliseconds */
     API_TIMEOUT: 5000,
     /** Default maximum retries for failed API calls */
@@ -60,9 +60,9 @@ export const VALIDATION_CONFIG = {
     /** Minimum API key length */
     MIN_API_KEY_LENGTH: 20,
     /** Required API key prefix for Revenium */
-    REVENIUM_API_KEY_PREFIX: 'hak_',
+    REVENIUM_API_KEY_PREFIX: "hak_",
     /** Required API key prefix for Anthropic */
-    ANTHROPIC_API_KEY_PREFIX: 'sk-ant-',
+    ANTHROPIC_API_KEY_PREFIX: "sk-ant-",
     /** Maximum tokens warning threshold */
     HIGH_MAX_TOKENS_THRESHOLD: 4096,
     /** Temperature range */
@@ -83,39 +83,54 @@ export const VALIDATION_CONFIG = {
  */
 export const LOGGING_CONFIG = {
     /** Middleware name for log prefixes */
-    MIDDLEWARE_NAME: 'Revenium',
+    MIDDLEWARE_NAME: "Revenium",
     /** User agent string for API requests */
-    USER_AGENT: 'revenium-middleware-anthropic-node/1.0.0',
+    USER_AGENT: "revenium-middleware-anthropic-node/1.0.0",
     /** Debug environment variable name */
-    DEBUG_ENV_VAR: 'REVENIUM_DEBUG',
+    DEBUG_ENV_VAR: "REVENIUM_DEBUG",
 };
 /**
  * Environment variable names
  */
 export const ENV_VARS = {
     /** Revenium API key */
-    REVENIUM_API_KEY: 'REVENIUM_METERING_API_KEY',
+    REVENIUM_API_KEY: "REVENIUM_METERING_API_KEY",
     /** Revenium base URL */
-    REVENIUM_BASE_URL: 'REVENIUM_METERING_BASE_URL',
+    REVENIUM_BASE_URL: "REVENIUM_METERING_BASE_URL",
     /** Anthropic API key */
-    ANTHROPIC_API_KEY: 'ANTHROPIC_API_KEY',
+    ANTHROPIC_API_KEY: "ANTHROPIC_API_KEY",
     /** Debug mode */
-    DEBUG: 'REVENIUM_DEBUG',
+    DEBUG: "REVENIUM_DEBUG",
     /** Log level */
-    LOG_LEVEL: 'REVENIUM_LOG_LEVEL',
+    LOG_LEVEL: "REVENIUM_LOG_LEVEL",
     /** API timeout */
-    API_TIMEOUT: 'REVENIUM_API_TIMEOUT',
+    API_TIMEOUT: "REVENIUM_API_TIMEOUT",
     /** Fail silent mode */
-    FAIL_SILENT: 'REVENIUM_FAIL_SILENT',
+    FAIL_SILENT: "REVENIUM_FAIL_SILENT",
     /** Maximum retries */
-    MAX_RETRIES: 'REVENIUM_MAX_RETRIES',
+    MAX_RETRIES: "REVENIUM_MAX_RETRIES",
+    /** Print summary mode (true/false/human/json) */
+    PRINT_SUMMARY: "REVENIUM_PRINT_SUMMARY",
+    /** Team ID for cost metrics retrieval */
+    TEAM_ID: "REVENIUM_TEAM_ID",
+};
+/**
+ * Summary printer configuration
+ */
+export const SUMMARY_PRINTER_CONFIG = {
+    /** Maximum number of retries when fetching cost metrics */
+    MAX_RETRIES: 3,
+    /** Delay between retries in milliseconds */
+    RETRY_DELAY: 2000,
+    /** Fetch timeout in milliseconds (prevents hung requests from keeping Node process alive) */
+    FETCH_TIMEOUT: 10000,
 };
 /**
  * API endpoints
  */
 export const API_ENDPOINTS = {
     /** Revenium AI completions endpoint */
-    AI_COMPLETIONS: '/meter/v2/ai/completions',
+    AI_COMPLETIONS: "/meter/v2/ai/completions",
 };
 /**
  * Anthropic model patterns
@@ -125,17 +140,17 @@ export const ANTHROPIC_PATTERNS = {
     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',
+        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',
+        end_turn: "END",
+        max_tokens: "TOKEN_LIMIT",
+        stop_sequence: "END_SEQUENCE",
+        tool_use: "END",
     },
 };
 //# sourceMappingURL=constants.js.map