@revenium/anthropic 1.0.8 → 1.1.0

package/dist/cjs/constants.js

@@ -4,13 +4,13 @@
  * Centralizes all magic numbers and default values
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ANTHROPIC_PATTERNS = exports.API_ENDPOINTS = exports.ENV_VARS = exports.LOGGING_CONFIG = exports.VALIDATION_CONFIG = exports.RETRY_CONFIG = exports.CIRCUIT_BREAKER_CONFIG = exports.DEFAULT_CONFIG = void 0;
+exports.ANTHROPIC_PATTERNS = exports.API_ENDPOINTS = exports.SUMMARY_PRINTER_CONFIG = exports.ENV_VARS = exports.LOGGING_CONFIG = exports.VALIDATION_CONFIG = exports.RETRY_CONFIG = exports.CIRCUIT_BREAKER_CONFIG = exports.DEFAULT_CONFIG = void 0;
 /**
  * Default configuration values
  */
 exports.DEFAULT_CONFIG = {
     /** Default Revenium API base URL */
-    REVENIUM_BASE_URL: 'https://api.revenium.ai',
+    REVENIUM_BASE_URL: "https://api.revenium.ai",
     /** Default API timeout in milliseconds */
     API_TIMEOUT: 5000,
     /** Default maximum retries for failed API calls */
@@ -25,6 +25,10 @@ exports.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
@@ -63,9 +67,9 @@ exports.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 */
@@ -86,39 +90,56 @@ exports.VALIDATION_CONFIG = {
  */
 exports.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
  */
 exports.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
+ */
+exports.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
  */
 exports.API_ENDPOINTS = {
     /** Revenium AI completions endpoint */
-    AI_COMPLETIONS: '/meter/v2/ai/completions',
+    AI_COMPLETIONS: "/meter/v2/ai/completions",
 };
 /**
  * Anthropic model patterns
@@ -128,17 +149,17 @@ exports.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

package/dist/cjs/tracking.js

@@ -15,8 +15,21 @@ const config_1 = require("./config");
 const circuit_breaker_1 = require("./utils/circuit-breaker");
 const error_handling_1 = require("./utils/error-handling");
 const constants_1 = require("./constants");
+const trace_fields_1 = require("./utils/trace-fields");
+const summary_printer_1 = require("./utils/summary-printer");
 // Global logger
 const logger = (0, config_1.getLogger)();
+if (typeof process !== "undefined") {
+    process.on("uncaughtException", (error) => {
+        if (error.name === "AbortError") {
+            return;
+        }
+        if (error.stack && error.stack.includes("tracking.ts")) {
+            return;
+        }
+        throw error;
+    });
+}
 /**
  * Send tracking data to Revenium API with resilience patterns
  */
@@ -34,7 +47,8 @@ async function sendReveniumMetrics(data) {
         isStreamed: data.isStreamed,
     });
     // Build payload using exact structure from working implementations
-    const payload = buildReveniumPayload(data);
+    // Built early so we can print summary even if Revenium tracking fails
+    const payload = await buildReveniumPayload(data);
     // Create request options
     const requestOptions = {
         method: "POST",
@@ -50,10 +64,6 @@ async function sendReveniumMetrics(data) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), requestOptions.timeout);
     requestOptions.signal = controller.signal;
-    // Handle abort signal errors to prevent unhandled error events
-    controller.signal.addEventListener("abort", () => {
-        // Silently handle abort - this is expected behavior for timeouts
-    });
     try {
         // Execute with circuit breaker and retry logic
         await (0, circuit_breaker_1.executeWithCircuitBreaker)(async () => {
@@ -66,9 +76,12 @@ async function sendReveniumMetrics(data) {
                 let response;
                 try {
                     response = await (0, node_fetch_1.default)(`${config.reveniumBaseUrl}${constants_1.API_ENDPOINTS.AI_COMPLETIONS}`, requestOptions);
+                    if (response.body) {
+                        response.body.once("error", () => { });
+                        response.body.resume();
+                    }
                 }
                 catch (fetchError) {
-                    // Handle AbortError and other fetch errors
                     if (fetchError instanceof Error && fetchError.name === "AbortError") {
                         throw new Error(`Request timeout after ${requestOptions.timeout}ms`);
                     }
@@ -91,6 +104,17 @@ async function sendReveniumMetrics(data) {
                     status: response.status,
                     duration: data.duration,
                 });
+                try {
+                    await response.text();
+                }
+                catch (bodyError) {
+                    logger.debug("Error reading response body (non-critical)", {
+                        requestId,
+                        error: bodyError instanceof Error
+                            ? bodyError.message
+                            : String(bodyError),
+                    });
+                }
                 return response;
             }, config.maxRetries ?? constants_1.DEFAULT_CONFIG.MAX_RETRIES);
         });
@@ -111,19 +135,28 @@ async function sendReveniumMetrics(data) {
     }
     finally {
         clearTimeout(timeoutId);
+        // Print usage summary regardless of whether Revenium tracking succeeded or failed
+        // This ensures users see the summary "after each Anthropic API request" as documented
+        (0, summary_printer_1.printUsageSummary)(payload);
     }
 }
 /**
  * Build Revenium payload from tracking data
  */
-function buildReveniumPayload(data) {
+async function buildReveniumPayload(data) {
     const now = new Date().toISOString();
     const requestTime = data.requestTime.toISOString();
     const completionStartTime = data.responseTime.toISOString();
     // Standard known fields
     const knownFields = new Set([
-        'taskType', 'agent', 'organizationId', 'productId', 'subscriber',
-        'subscriptionId', 'traceId', 'responseQualityScore'
+        "taskType",
+        "agent",
+        "organizationId",
+        "productId",
+        "subscriber",
+        "subscriptionId",
+        "traceId",
+        "responseQualityScore",
     ]);
     // Extract custom fields (anything NOT in the standard 8 fields)
     const customFields = {};
@@ -134,23 +167,26 @@ function buildReveniumPayload(data) {
             }
         }
     }
+    const environment = (0, trace_fields_1.getEnvironment)();
+    const region = await (0, trace_fields_1.getRegion)();
+    const credentialAlias = (0, trace_fields_1.getCredentialAlias)();
+    const traceType = (0, trace_fields_1.getTraceType)();
+    const traceName = (0, trace_fields_1.getTraceName)();
+    const parentTransactionId = (0, trace_fields_1.getParentTransactionId)();
+    const transactionName = (0, trace_fields_1.getTransactionName)();
+    const retryNumber = (0, trace_fields_1.getRetryNumber)();
+    const operationSubtype = (0, trace_fields_1.detectOperationSubtype)(data.requestBody);
     return {
         stopReason: getStopReason(data.stopReason),
         costType: "AI",
         isStreamed: data.isStreamed,
-        taskType: data.metadata?.taskType,
-        agent: data.metadata?.agent,
         operationType: "CHAT",
         inputTokenCount: data.inputTokens,
         outputTokenCount: data.outputTokens,
-        reasoningTokenCount: 0, // Anthropic doesn't currently have reasoning tokens
+        reasoningTokenCount: 0,
         cacheCreationTokenCount: data.cacheCreationTokens || 0,
         cacheReadTokenCount: data.cacheReadTokens || 0,
         totalTokenCount: data.inputTokens + data.outputTokens,
-        organizationId: data.metadata?.organizationId,
-        productId: data.metadata?.productId,
-        subscriber: data.metadata?.subscriber, // Pass through nested subscriber object directly
-        subscriptionId: data.metadata?.subscriptionId,
         model: data.model,
         transactionId: data.requestId,
         responseTime: now,
@@ -159,10 +195,31 @@ function buildReveniumPayload(data) {
         requestTime: requestTime,
         completionStartTime: completionStartTime,
         timeToFirstToken: data.timeToFirstToken || 0,
-        traceId: data.metadata?.traceId,
-        responseQualityScore: data.metadata?.responseQualityScore, // Fixed: Now sending to Revenium
         middlewareSource: "nodejs",
-        ...customFields, // Preserve any custom metadata fields
+        ...(data.metadata?.taskType && { taskType: data.metadata.taskType }),
+        ...(data.metadata?.agent && { agent: data.metadata.agent }),
+        ...(data.metadata?.organizationId && {
+            organizationId: data.metadata.organizationId,
+        }),
+        ...(data.metadata?.productId && { productId: data.metadata.productId }),
+        ...(data.metadata?.subscriber && { subscriber: data.metadata.subscriber }),
+        ...(data.metadata?.subscriptionId && {
+            subscriptionId: data.metadata.subscriptionId,
+        }),
+        ...(data.metadata?.traceId && { traceId: data.metadata.traceId }),
+        ...(data.metadata?.responseQualityScore !== undefined && {
+            responseQualityScore: data.metadata.responseQualityScore,
+        }),
+        ...(environment && { environment }),
+        ...(region && { region }),
+        ...(credentialAlias && { credentialAlias }),
+        ...(traceType && { traceType }),
+        ...(traceName && { traceName }),
+        ...(parentTransactionId && { parentTransactionId }),
+        ...(transactionName && { transactionName }),
+        ...(retryNumber !== undefined && { retryNumber }),
+        ...(operationSubtype && { operationSubtype }),
+        ...customFields,
     };
 }
 /**
@@ -184,7 +241,6 @@ function trackUsageAsync(trackingData) {
         return logger.warn("Revenium configuration not available - skipping tracking", {
             requestId: trackingData.requestId,
         });
-    // Run tracking in background without awaiting
     sendReveniumMetrics(trackingData)
         .then(() => {
         logger.debug("Revenium tracking completed successfully", {
@@ -194,6 +250,12 @@ function trackUsageAsync(trackingData) {
         });
     })
         .catch((error) => {
+        if (error instanceof Error && error.name === "AbortError") {
+            logger.debug("Metrics request aborted (process exiting)", {
+                requestId: trackingData.requestId,
+            });
+            return;
+        }
         const errorContext = (0, error_handling_1.createErrorContext)()
             .withRequestId(trackingData.requestId)
             .withModel(trackingData.model)

package/dist/cjs/types/anthropic-augmentation.js

@@ -19,68 +19,6 @@
  * - **Automatic Validation**: TypeScript validates the structure at compile time
  * - **Better Developer Experience**: Auto-completion and error detection
  *
- * ## Usage Examples:
- *
- * ### Basic Usage:
- * ```typescript
- * import '@revenium/anthropic';
- * import Anthropic from '@anthropic-ai/sdk';
- *
- * const anthropic = new Anthropic();
- *
- * const response = await anthropic.messages.create({
- *   model: 'claude-3-5-sonnet-latest',
- *   max_tokens: 1024,
- *   messages: [{ role: 'user', content: 'Hello!' }],
- *   usageMetadata: {  // TypeScript recognizes this natively
- *     subscriber: { id: 'user-123', email: 'user@example.com' },
- *     organizationId: 'my-company',
- *     taskType: 'customer-support',
- *     traceId: 'session-abc-123'
- *   }
- * });
- * ```
- *
- * ### Streaming Usage:
- * ```typescript
- * const stream = await anthropic.messages.stream({
- *   model: 'claude-3-5-sonnet-latest',
- *   max_tokens: 1024,
- *   messages: [{ role: 'user', content: 'Generate a report' }],
- *   usageMetadata: {
- *     taskType: 'content-generation',
- *     productId: 'report-generator',
- *     responseQualityScore: 0.95
- *   }
- * });
- * ```
- *
- * ### Advanced Usage with All Fields:
- * ```typescript
- * const response = await anthropic.messages.create({
- *   model: 'claude-3-5-sonnet-latest',
- *   max_tokens: 2048,
- *   messages: [{ role: 'user', content: 'Complex analysis task' }],
- *   usageMetadata: {
- *     subscriber: {
- *       id: 'user-456',
- *       email: 'analyst@company.com',
- *       credential: { name: 'api-key', value: 'sk-...' }
- *     },
- *     traceId: 'analysis-session-789',
- *     taskType: 'data-analysis',
- *     organizationId: 'enterprise-client',
- *     subscriptionId: 'premium-plan',
- *     productId: 'analytics-suite',
- *     agent: 'data-analyst-bot',
- *     responseQualityScore: 0.98,
- *     customField: 'custom-value'  // Extensible with custom fields
- *   }
- * });
- * ```
- *
- * @public
- * @since 1.1.0
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=anthropic-augmentation.js.map

package/dist/cjs/utils/prompt-extraction.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldCapturePrompts = shouldCapturePrompts;
+exports.extractPrompts = extractPrompts;
+const constants_1 = require("../constants");
+const config_1 = require("../config");
+function sanitizeCredentials(text) {
+    const patterns = [
+        {
+            regex: /sk-proj-[a-zA-Z0-9_-]{48,}/g,
+            replacement: "sk-proj-***REDACTED***",
+        },
+        { regex: /sk-[a-zA-Z0-9_-]{20,}/g, replacement: "sk-***REDACTED***" },
+        {
+            regex: /Bearer\s+[a-zA-Z0-9_\-\.]+/gi,
+            replacement: "Bearer ***REDACTED***",
+        },
+        {
+            regex: /api[_-]?key["\s:=]+[a-zA-Z0-9_\-\.\+\/=]{20,}/gi,
+            replacement: "api_key: ***REDACTED***",
+        },
+        {
+            regex: /token["\s:=]+[a-zA-Z0-9_\-\.]{20,}/gi,
+            replacement: "token: ***REDACTED***",
+        },
+        {
+            regex: /password["\s:=]+[^\s"']{8,}/gi,
+            replacement: "password: ***REDACTED***",
+        },
+    ];
+    let sanitized = text;
+    for (const pattern of patterns) {
+        sanitized = sanitized.replace(pattern.regex, pattern.replacement);
+    }
+    return sanitized;
+}
+function truncateString(str, maxLength) {
+    const sanitized = sanitizeCredentials(str);
+    if (sanitized.length <= maxLength) {
+        return { value: sanitized, truncated: false };
+    }
+    return { value: sanitized.substring(0, maxLength), truncated: true };
+}
+function extractSystemPrompt(params) {
+    if (!params.system) {
+        return "";
+    }
+    if (typeof params.system === "string") {
+        return params.system;
+    }
+    if (Array.isArray(params.system)) {
+        return params.system
+            .map((block) => {
+            if (block.type === "text") {
+                return block.text;
+            }
+            if (block.type === "image") {
+                return "[IMAGE]";
+            }
+            return "";
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    return "";
+}
+function extractInputMessages(params) {
+    if (!params.messages || params.messages.length === 0) {
+        return "";
+    }
+    return params.messages
+        .map((message) => {
+        const role = message.role;
+        let content = "";
+        if (typeof message.content === "string") {
+            content = message.content;
+        }
+        else if (Array.isArray(message.content)) {
+            content = message.content
+                .map((block) => {
+                if (block.type === "text") {
+                    return block.text;
+                }
+                if (block.type === "image") {
+                    return "[IMAGE]";
+                }
+                if (block.type === "tool_use") {
+                    const toolName = block.name || "unknown";
+                    return `[TOOL_USE: ${toolName}]`;
+                }
+                if (block.type === "tool_result") {
+                    return "[TOOL_RESULT]";
+                }
+                return "";
+            })
+                .filter(Boolean)
+                .join("\n");
+        }
+        return `[${role}]\n${content}`;
+    })
+        .join("\n\n");
+}
+function extractOutputResponse(response) {
+    if (!response.content || response.content.length === 0) {
+        return "";
+    }
+    return response.content
+        .map((block) => {
+        if (block.type === "text") {
+            return block.text;
+        }
+        if (block.type === "tool_use") {
+            return `[TOOL_USE: ${block.name}]`;
+        }
+        return "";
+    })
+        .filter(Boolean)
+        .join("\n");
+}
+function shouldCapturePrompts(metadata) {
+    if (metadata?.capturePrompts !== undefined) {
+        return metadata.capturePrompts;
+    }
+    const config = (0, config_1.getConfig)();
+    if (config?.capturePrompts !== undefined) {
+        return config.capturePrompts;
+    }
+    return constants_1.DEFAULT_CONFIG.CAPTURE_PROMPTS;
+}
+function extractPrompts(params, response, metadata) {
+    if (!shouldCapturePrompts(metadata)) {
+        return null;
+    }
+    const maxSize = constants_1.DEFAULT_CONFIG.MAX_PROMPT_SIZE;
+    let anyTruncated = false;
+    const systemPromptRaw = extractSystemPrompt(params);
+    const systemPromptResult = truncateString(systemPromptRaw, maxSize);
+    anyTruncated = anyTruncated || systemPromptResult.truncated;
+    const inputMessagesRaw = extractInputMessages(params);
+    const inputMessagesResult = truncateString(inputMessagesRaw, maxSize);
+    anyTruncated = anyTruncated || inputMessagesResult.truncated;
+    const outputResponseRaw = extractOutputResponse(response);
+    const outputResponseResult = truncateString(outputResponseRaw, maxSize);
+    anyTruncated = anyTruncated || outputResponseResult.truncated;
+    const hasAnyContent = systemPromptResult.value ||
+        inputMessagesResult.value ||
+        outputResponseResult.value;
+    if (!hasAnyContent) {
+        return null;
+    }
+    return {
+        systemPrompt: systemPromptResult.value || undefined,
+        inputMessages: inputMessagesResult.value || undefined,
+        outputResponse: outputResponseResult.value || undefined,
+        promptsTruncated: anyTruncated,
+    };
+}
+//# sourceMappingURL=prompt-extraction.js.map