@revenium/anthropic 1.0.8 → 1.1.0

package/dist/esm/tracking.js

@@ -6,8 +6,21 @@ import { getConfig, getLogger } from "./config.js";
 import { executeWithCircuitBreaker } from "./utils/circuit-breaker.js";
 import { withRetry, ReveniumApiError, createErrorContext, handleError, } from "./utils/error-handling.js";
 import { DEFAULT_CONFIG, API_ENDPOINTS, LOGGING_CONFIG, ANTHROPIC_PATTERNS, } from "./constants.js";
+import { getEnvironment, getRegion, getCredentialAlias, getTraceType, getTraceName, detectOperationSubtype, getParentTransactionId, getTransactionName, getRetryNumber, } from "./utils/trace-fields.js";
+import { printUsageSummary } from "./utils/summary-printer.js";
 // Global logger
 const logger = 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
  */
@@ -25,7 +38,8 @@ export 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",
@@ -41,10 +55,6 @@ export 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 executeWithCircuitBreaker(async () => {
@@ -57,9 +67,12 @@ export async function sendReveniumMetrics(data) {
                 let response;
                 try {
                     response = await fetch(`${config.reveniumBaseUrl}${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`);
                     }
@@ -82,6 +95,17 @@ export 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 ?? DEFAULT_CONFIG.MAX_RETRIES);
         });
@@ -102,19 +126,28 @@ export 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
+        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 = {};
@@ -125,23 +158,26 @@ function buildReveniumPayload(data) {
             }
         }
     }
+    const environment = getEnvironment();
+    const region = await getRegion();
+    const credentialAlias = getCredentialAlias();
+    const traceType = getTraceType();
+    const traceName = getTraceName();
+    const parentTransactionId = getParentTransactionId();
+    const transactionName = getTransactionName();
+    const retryNumber = getRetryNumber();
+    const operationSubtype = 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,
@@ -150,10 +186,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,
     };
 }
 /**
@@ -175,7 +232,6 @@ export 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", {
@@ -185,6 +241,12 @@ export 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 = createErrorContext()
             .withRequestId(trackingData.requestId)
             .withModel(trackingData.model)

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

@@ -18,68 +18,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
  */
 export {};
 //# sourceMappingURL=anthropic-augmentation.js.map

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

@@ -0,0 +1,154 @@
+import { DEFAULT_CONFIG } from "../constants.js";
+import { getConfig } from "../config.js";
+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");
+}
+export function shouldCapturePrompts(metadata) {
+    if (metadata?.capturePrompts !== undefined) {
+        return metadata.capturePrompts;
+    }
+    const config = getConfig();
+    if (config?.capturePrompts !== undefined) {
+        return config.capturePrompts;
+    }
+    return DEFAULT_CONFIG.CAPTURE_PROMPTS;
+}
+export function extractPrompts(params, response, metadata) {
+    if (!shouldCapturePrompts(metadata)) {
+        return null;
+    }
+    const maxSize = 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

package/dist/esm/utils/summary-printer.js

@@ -0,0 +1,186 @@
+import { getConfig, getLogger } from "../config.js";
+import { DEFAULT_CONFIG, SUMMARY_PRINTER_CONFIG } from "../constants.js";
+const logger = getLogger();
+function delayWithUnref(ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        if (typeof timer.unref === "function") {
+            timer.unref();
+        }
+    });
+}
+async function fetchCompletionMetrics(transactionId, maxRetries = SUMMARY_PRINTER_CONFIG.MAX_RETRIES, retryDelay = SUMMARY_PRINTER_CONFIG.RETRY_DELAY) {
+    const config = getConfig();
+    if (!config) {
+        logger.debug("No config available for summary printing");
+        return null;
+    }
+    if (!config.teamId) {
+        logger.debug("Team ID not configured, skipping cost retrieval for summary");
+        return null;
+    }
+    const baseUrl = (config.reveniumBaseUrl || DEFAULT_CONFIG.REVENIUM_BASE_URL).replace(/\/+$/, "");
+    const url = `${baseUrl}/profitstream/v2/api/sources/metrics/ai/completions`;
+    const teamId = config.teamId.trim();
+    const urlWithParams = `${url}?teamId=${encodeURIComponent(teamId)}&transactionId=${encodeURIComponent(transactionId)}`;
+    logger.debug("Fetching completion metrics", { url: urlWithParams });
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        // Create an AbortController with timeout to prevent hung requests from keeping Node process alive
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), SUMMARY_PRINTER_CONFIG.FETCH_TIMEOUT);
+        // Unref the timer so it doesn't keep the process alive
+        if (typeof timeoutId.unref === "function") {
+            timeoutId.unref();
+        }
+        try {
+            const response = await fetch(urlWithParams, {
+                method: "GET",
+                headers: {
+                    Accept: "application/json",
+                    "x-api-key": config.reveniumApiKey,
+                },
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                try {
+                    await response.text();
+                }
+                catch { }
+                logger.debug(`Completions metrics API returned ${response.status}`, {
+                    attempt: attempt + 1,
+                });
+                if (attempt < maxRetries - 1) {
+                    await delayWithUnref(retryDelay);
+                    continue;
+                }
+                return null;
+            }
+            const data = (await response.json());
+            const completions = data._embedded?.aICompletionMetricResourceList;
+            if (completions && completions.length > 0) {
+                return completions[0];
+            }
+            if (attempt < maxRetries - 1) {
+                logger.debug(`Waiting for metrics to aggregate (attempt ${attempt + 1}/${maxRetries})...`);
+                await delayWithUnref(retryDelay);
+            }
+        }
+        catch (error) {
+            logger.debug("Failed to fetch completion metrics", {
+                error: error instanceof Error ? error.message : String(error),
+                attempt: attempt + 1,
+            });
+            if (attempt < maxRetries - 1) {
+                await delayWithUnref(retryDelay);
+            }
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    return null;
+}
+function isSummaryFormat(value) {
+    return value === "human" || value === "json";
+}
+function formatAndPrintJsonSummary(payload, metrics) {
+    const config = getConfig();
+    const summary = {
+        model: payload.model,
+        provider: payload.provider,
+        durationSeconds: payload.requestDuration / 1000,
+        inputTokenCount: payload.inputTokenCount,
+        outputTokenCount: payload.outputTokenCount,
+        totalTokenCount: payload.totalTokenCount,
+        cost: typeof metrics?.totalCost === "number" ? metrics.totalCost : null,
+    };
+    if (summary.cost === null) {
+        summary.costStatus = config?.teamId ? "pending" : "unavailable";
+    }
+    if (payload.traceId) {
+        summary.traceId = payload.traceId;
+    }
+    console.log(JSON.stringify(summary));
+}
+function formatAndPrintHumanSummary(payload, metrics) {
+    console.log("\n" + "=".repeat(60));
+    console.log("📊 REVENIUM USAGE SUMMARY");
+    console.log("=".repeat(60));
+    console.log(`🤖 Model: ${payload.model}`);
+    console.log(`🏢 Provider: ${payload.provider}`);
+    console.log(`⏱️  Duration: ${(payload.requestDuration / 1000).toFixed(2)}s`);
+    console.log("\n💬 Token Usage:");
+    console.log(`   📥 Input Tokens:  ${(payload.inputTokenCount ?? 0).toLocaleString()}`);
+    console.log(`   📤 Output Tokens: ${(payload.outputTokenCount ?? 0).toLocaleString()}`);
+    console.log(`   📊 Total Tokens:  ${(payload.totalTokenCount ?? 0).toLocaleString()}`);
+    if (typeof metrics?.totalCost === "number") {
+        console.log(`\n💰 Cost: $${metrics.totalCost.toFixed(6)}`);
+    }
+    else {
+        const config = getConfig();
+        if (!config?.teamId) {
+            console.log(`\n💰 Cost: Set REVENIUM_TEAM_ID environment variable to see pricing`);
+        }
+        else {
+            console.log(`\n💰 Cost: (pending aggregation)`);
+        }
+    }
+    if (payload.traceId) {
+        console.log(`\n🔖 Trace ID: ${payload.traceId}`);
+    }
+    console.log("=".repeat(60) + "\n");
+}
+function formatAndPrintSummary(payload, metrics, format) {
+    if (format === "json") {
+        formatAndPrintJsonSummary(payload, metrics);
+    }
+    else {
+        formatAndPrintHumanSummary(payload, metrics);
+    }
+}
+function safeFormatAndPrintSummary(payload, metrics, format) {
+    try {
+        formatAndPrintSummary(payload, metrics, format);
+    }
+    catch (error) {
+        logger.debug("Failed to format and print summary", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+function getSummaryFormat(value) {
+    if (!value)
+        return null;
+    if (value === true)
+        return "human";
+    if (isSummaryFormat(value)) {
+        return value;
+    }
+    return null;
+}
+export function printUsageSummary(payload) {
+    const config = getConfig();
+    const format = getSummaryFormat(config?.printSummary);
+    if (!format) {
+        return;
+    }
+    if (config?.teamId && payload.transactionId) {
+        fetchCompletionMetrics(payload.transactionId)
+            .then((metrics) => {
+            safeFormatAndPrintSummary(payload, metrics, format);
+        })
+            .catch((error) => {
+            logger.debug("Failed to print usage summary with metrics", {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            safeFormatAndPrintSummary(payload, null, format);
+        })
+            .catch(() => {
+            // Final safety catch to prevent unhandled rejections
+        });
+    }
+    else {
+        safeFormatAndPrintSummary(payload, null, format);
+    }
+}
+//# sourceMappingURL=summary-printer.js.map