@revenium/anthropic 1.0.8 → 1.1.0

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
@@ -46,8 +46,8 @@ function getMessagesPrototype() {
         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. ' +
-                'Provide ANTHROPIC_API_KEY environment variable or pass anthropicApiKey in config.');
+            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);
@@ -65,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) {
@@ -91,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)
@@ -120,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);
@@ -140,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 = [];
@@ -148,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);
@@ -158,12 +158,14 @@ async function handleStreamingResponse(stream, context) {
             const endTime = Date.now();
             const responseTime = new Date();
             const duration = endTime - startTime;
-            const timeToFirstToken = firstTokenTime ? firstTokenTime - startTime : undefined;
-            logger.debug('Stream completed, extracting usage', {
+            const timeToFirstToken = firstTokenTime
+                ? firstTokenTime - startTime
+                : undefined;
+            logger.debug("Stream completed, extracting usage", {
                 requestId,
                 chunkCount: chunks.length,
                 duration,
-                timeToFirstToken
+                timeToFirstToken,
             });
             const usage = (0, tracking_1.extractUsageFromStream)(chunks);
             // Create tracking data
@@ -180,22 +182,23 @@ async function handleStreamingResponse(stream, context) {
                 metadata,
                 requestTime,
                 responseTime,
-                timeToFirstToken
+                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;
         }
@@ -209,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
@@ -232,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;
@@ -255,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;
         }
@@ -274,7 +278,8 @@ async function patchedCreateMethod(params, options) {
             model: params.model,
             metadata,
             requestTime,
-            startTime
+            startTime,
+            requestBody: params,
         });
     }
     catch (error) {
@@ -299,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
@@ -321,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);
@@ -334,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
@@ -351,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) {
@@ -372,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

@@ -1,31 +1,31 @@
-import { validateReveniumConfig } from './utils/validation.js';
-import { DEFAULT_CONFIG, ENV_VARS, LOGGING_CONFIG } from './constants.js';
+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';
+        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)}` : '';
+        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));
+            console.debug(this.formatMessage("DEBUG", message, context));
         }
     }
     info(message, context) {
-        console.info(this.formatMessage('INFO', message, context));
+        console.info(this.formatMessage("INFO", message, context));
     }
     warn(message, context) {
-        console.warn(this.formatMessage('WARN', message, context));
+        console.warn(this.formatMessage("WARN", message, context));
     }
     error(message, context) {
-        console.error(this.formatMessage('ERROR', message, context));
+        console.error(this.formatMessage("ERROR", message, context));
     }
 }
 /**
@@ -40,14 +40,32 @@ function loadConfigFromEnvironment() {
         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',
+        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]
+        maxRetries: process.env[ENV_VARS.MAX_RETRIES],
+        printSummary: process.env[ENV_VARS.PRINT_SUMMARY],
+        teamId: process.env[ENV_VARS.TEAM_ID],
+        capturePrompts: process.env[ENV_VARS.CAPTURE_PROMPTS],
     };
     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
  */
@@ -56,15 +74,20 @@ function createConfigFromEnvironment(env) {
         return null;
     }
     const apiTimeout = env.apiTimeout ? parseInt(env.apiTimeout, 10) : undefined;
-    const failSilent = env.failSilent !== 'false'; // Default to true
+    const failSilent = env.failSilent !== "false"; // Default to true
     const maxRetries = env.maxRetries ? parseInt(env.maxRetries, 10) : undefined;
+    const printSummary = parsePrintSummary(env.printSummary);
+    const capturePrompts = env.capturePrompts === "true";
     return {
         reveniumApiKey: env.reveniumApiKey,
         reveniumBaseUrl: env.reveniumBaseUrl || DEFAULT_CONFIG.REVENIUM_BASE_URL,
         anthropicApiKey: env.anthropicApiKey,
         apiTimeout,
         failSilent,
-        maxRetries
+        maxRetries,
+        printSummary,
+        teamId: env.teamId?.trim(),
+        capturePrompts,
     };
 }
 /**
@@ -74,18 +97,18 @@ export function validateConfig(config) {
     const validation = validateReveniumConfig(config);
     if (!validation.isValid) {
         // Log detailed validation errors
-        getLogger().error('Configuration validation failed', {
+        getLogger().error("Configuration validation failed", {
             errors: validation.errors,
             warnings: validation.warnings,
-            suggestions: validation.suggestions
+            suggestions: validation.suggestions,
         });
         // Create detailed error message
-        let errorMessage = 'Configuration validation failed:\n';
+        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';
+            errorMessage += "\nSuggestions:\n";
             validation.suggestions.forEach((suggestion) => {
                 errorMessage += `  • ${suggestion}\n`;
             });
@@ -94,8 +117,8 @@ export function validateConfig(config) {
     }
     // Log warnings if any
     if (validation.warnings && validation.warnings.length > 0) {
-        getLogger().warn('Configuration warnings', {
-            warnings: validation.warnings
+        getLogger().warn("Configuration warnings", {
+            warnings: validation.warnings,
         });
     }
 }
@@ -112,14 +135,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;
-    globalLogger.debug('Revenium configuration updated', {
-        baseUrl: config.reveniumBaseUrl,
-        hasApiKey: !!config.reveniumApiKey,
-        hasAnthropicKey: !!config.anthropicApiKey
+    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: globalConfig.reveniumBaseUrl,
+        hasApiKey: !!globalConfig.reveniumApiKey,
+        hasAnthropicKey: !!globalConfig.anthropicApiKey,
     });
 }
 /**
@@ -133,7 +184,7 @@ export function getLogger() {
  */
 export function setLogger(logger) {
     globalLogger = logger;
-    globalLogger.debug('Custom logger set for Revenium middleware');
+    globalLogger.debug("Custom logger set for Revenium middleware");
 }
 /**
  * Initialize configuration from environment variables
@@ -144,12 +195,12 @@ export function initializeConfig() {
     if (config) {
         try {
             setConfig(config);
-            globalLogger.debug('Revenium middleware initialized from environment variables');
+            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)
+            globalLogger.error("Failed to initialize Revenium configuration", {
+                error: error instanceof Error ? error.message : String(error),
             });
             return false;
         }
@@ -170,14 +221,14 @@ export function getConfigStatus() {
             hasConfig: false,
             hasApiKey: false,
             hasAnthropicKey: false,
-            baseUrl: ''
+            baseUrl: "",
         };
     }
     return {
         hasConfig: true,
         hasApiKey: !!globalConfig.reveniumApiKey,
         hasAnthropicKey: !!globalConfig.anthropicApiKey,
-        baseUrl: globalConfig.reveniumBaseUrl
+        baseUrl: globalConfig.reveniumBaseUrl,
     };
 }
 /**

package/dist/esm/constants.js

@@ -7,7 +7,7 @@
  */
 export const DEFAULT_CONFIG = {
     /** Default Revenium API base URL */
-    REVENIUM_BASE_URL: 'https://api.revenium.ai',
+    REVENIUM_BASE_URL: "https://api.revenium.ai",
     /** Default API timeout in milliseconds */
     API_TIMEOUT: 5000,
     /** Default maximum retries for failed API calls */
@@ -22,6 +22,10 @@ export const DEFAULT_CONFIG = {
     MAX_RETRY_ATTEMPTS: 10,
     /** Warning threshold for low API timeout */
     LOW_TIMEOUT_WARNING_THRESHOLD: 3000,
+    /** Default prompt capture behavior */
+    CAPTURE_PROMPTS: false,
+    /** Maximum size for each prompt field in characters (50KB) */
+    MAX_PROMPT_SIZE: 50000,
 };
 /**
  * Circuit breaker configuration constants
@@ -60,9 +64,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 +87,56 @@ 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",
+    /** Prompt capture mode */
+    CAPTURE_PROMPTS: "REVENIUM_CAPTURE_PROMPTS",
+};
+/**
+ * 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 +146,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