@revenium/anthropic 1.0.9 → 1.1.1

package/dist/cjs/utils/validation.js

@@ -18,30 +18,30 @@ const constants_1 = require("../constants");
  * Type guard for checking if a value is a non-null object
  */
 function isObject(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
+    return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
  * Type guard for checking if a value is a string
  */
 function isString(value) {
-    return typeof value === 'string';
+    return typeof value === "string";
 }
 /**
  * Type guard for checking if a value is a number
  */
 function isNumber(value) {
-    return typeof value === 'number' && !isNaN(value);
+    return typeof value === "number" && !isNaN(value);
 }
 /**
  * Type guard for checking if a value is a boolean
  */
 function isBoolean(value) {
-    return typeof value === 'boolean';
+    return typeof value === "boolean";
 }
 /**
  * Validate and extract string from unknown value
  */
-function validateString(value, defaultValue = '') {
+function validateString(value, defaultValue = "") {
     return isString(value) ? value : defaultValue;
 }
 /**
@@ -60,8 +60,14 @@ function validateUsageMetadata(metadata) {
     const validated = {};
     // Validate string fields
     const stringFields = [
-        'traceId', 'taskType', 'organizationId',
-        'subscriptionId', 'productId', 'agent'
+        "traceId",
+        "taskType",
+        "organizationId",
+        "organizationName",
+        "subscriptionId",
+        "productId",
+        "productName",
+        "agent",
     ];
     for (const field of stringFields) {
         const value = metadata[field];
@@ -74,21 +80,25 @@ function validateUsageMetadata(metadata) {
     if (isObject(subscriberData)) {
         const subscriber = {};
         // Validate subscriber.id
-        if (isString(subscriberData?.id) && subscriberData?.id?.trim()?.length > 0) {
+        if (isString(subscriberData?.id) &&
+            subscriberData?.id?.trim()?.length > 0) {
             subscriber.id = subscriberData?.id?.trim();
         }
         // Validate subscriber.email
-        if (isString(subscriberData?.email) && subscriberData?.email?.trim()?.length > 0) {
+        if (isString(subscriberData?.email) &&
+            subscriberData?.email?.trim()?.length > 0) {
             subscriber.email = subscriberData?.email?.trim();
         }
         // Validate subscriber.credential object
         const credentialData = subscriberData?.credential;
         if (isObject(credentialData)) {
             const credential = {};
-            if (isString(credentialData?.name) && credentialData?.name?.trim()?.length > 0) {
+            if (isString(credentialData?.name) &&
+                credentialData?.name?.trim()?.length > 0) {
                 credential.name = credentialData?.name?.trim();
             }
-            if (isString(credentialData?.value) && credentialData?.value?.trim()?.length > 0) {
+            if (isString(credentialData?.value) &&
+                credentialData?.value?.trim()?.length > 0) {
                 credential.value = credentialData?.value?.trim();
             }
             // Only include credential if it has at least name or value
@@ -102,10 +112,18 @@ function validateUsageMetadata(metadata) {
         }
     }
     // Validate number fields
-    const responseQualityScore = metadata.responseQualityScore;
-    if (isNumber(responseQualityScore) && responseQualityScore >= 0 && responseQualityScore <= 1) {
+    const responseQualityScore = metadata
+        .responseQualityScore;
+    if (isNumber(responseQualityScore) &&
+        responseQualityScore >= 0 &&
+        responseQualityScore <= 1) {
         validated.responseQualityScore = responseQualityScore;
     }
+    // Validate boolean fields
+    const capturePrompts = metadata.capturePrompts;
+    if (typeof capturePrompts === "boolean") {
+        validated.capturePrompts = capturePrompts;
+    }
     return validated;
 }
 /**
@@ -118,96 +136,104 @@ function validateReveniumConfig(config) {
     if (!isObject(config)) {
         return {
             isValid: false,
-            errors: ['Configuration must be an object'],
+            errors: ["Configuration must be an object"],
             warnings: [],
-            suggestions: ['Ensure you are passing a valid configuration object with required fields']
+            suggestions: [
+                "Ensure you are passing a valid configuration object with required fields",
+            ],
         };
     }
     const cfg = config;
     // Validate required Revenium API key
     if (!isString(cfg?.reveniumApiKey)) {
-        errors.push('reveniumApiKey is required and must be a string');
-        suggestions.push('Set REVENIUM_METERING_API_KEY environment variable or provide reveniumApiKey in config');
+        errors.push("reveniumApiKey is required and must be a string");
+        suggestions.push("Set REVENIUM_METERING_API_KEY environment variable or provide reveniumApiKey in config");
     }
     else if (!cfg?.reveniumApiKey?.trim()) {
-        errors.push('reveniumApiKey cannot be empty');
+        errors.push("reveniumApiKey cannot be empty");
     }
     else if (!cfg?.reveniumApiKey?.startsWith(constants_1.VALIDATION_CONFIG.REVENIUM_API_KEY_PREFIX)) {
         errors.push(`reveniumApiKey must start with "${constants_1.VALIDATION_CONFIG.REVENIUM_API_KEY_PREFIX}"`);
-        suggestions.push('Obtain a valid Revenium API key from your Revenium dashboard');
+        suggestions.push("Obtain a valid Revenium API key from your Revenium dashboard");
     }
     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');
+        warnings.push("reveniumApiKey appears to be too short - verify it is correct");
     }
     // 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');
+            errors.push("reveniumBaseUrl must be a string if provided");
         }
         else if (!cfg?.reveniumBaseUrl?.trim()) {
-            errors.push('reveniumBaseUrl cannot be empty if provided');
+            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');
+                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]'];
+                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');
+                    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');
+                errors.push("reveniumBaseUrl must be a valid URL");
+                suggestions.push("Use format: https://api.revenium.ai");
             }
         }
     }
     // Validate optional Anthropic API key
     if (cfg?.anthropicApiKey !== undefined && !isString(cfg?.anthropicApiKey)) {
-        errors.push('anthropicApiKey must be a string if provided');
+        errors.push("anthropicApiKey must be a string if provided");
     }
-    else if (cfg?.anthropicApiKey !== undefined && cfg?.anthropicApiKey?.trim()?.length === 0) {
-        warnings.push('anthropicApiKey is empty - API calls may fail');
+    else if (cfg?.anthropicApiKey !== undefined &&
+        cfg?.anthropicApiKey?.trim()?.length === 0) {
+        warnings.push("anthropicApiKey is empty - API calls may fail");
     }
-    else if (cfg?.anthropicApiKey && !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
     if (cfg?.apiTimeout !== undefined && !isNumber(cfg?.apiTimeout)) {
-        errors.push('apiTimeout must be a number if provided');
+        errors.push("apiTimeout must be a number if provided");
     }
-    else if (cfg?.apiTimeout !== undefined && cfg?.apiTimeout < constants_1.VALIDATION_CONFIG.MIN_API_TIMEOUT) {
+    else if (cfg?.apiTimeout !== undefined &&
+        cfg?.apiTimeout < constants_1.VALIDATION_CONFIG.MIN_API_TIMEOUT) {
         errors.push(`apiTimeout must be at least ${constants_1.VALIDATION_CONFIG.MIN_API_TIMEOUT}ms`);
     }
-    else if (cfg?.apiTimeout !== undefined && cfg?.apiTimeout > constants_1.VALIDATION_CONFIG.MAX_API_TIMEOUT) {
+    else if (cfg?.apiTimeout !== undefined &&
+        cfg?.apiTimeout > constants_1.VALIDATION_CONFIG.MAX_API_TIMEOUT) {
         errors.push(`apiTimeout must not exceed ${constants_1.VALIDATION_CONFIG.MAX_API_TIMEOUT}ms`);
     }
-    else if (cfg?.apiTimeout !== undefined && cfg?.apiTimeout < constants_1.VALIDATION_CONFIG.LOW_TIMEOUT_WARNING_THRESHOLD) {
-        warnings.push('apiTimeout is very low - may cause timeouts for slow networks');
+    else if (cfg?.apiTimeout !== undefined &&
+        cfg?.apiTimeout < constants_1.VALIDATION_CONFIG.LOW_TIMEOUT_WARNING_THRESHOLD) {
+        warnings.push("apiTimeout is very low - may cause timeouts for slow networks");
     }
     // Validate optional failSilent
     if (cfg?.failSilent && !isBoolean(cfg?.failSilent)) {
-        errors.push('failSilent must be a boolean if provided');
+        errors.push("failSilent must be a boolean if provided");
     }
     // Validate optional maxRetries using constants
     if (cfg?.maxRetries !== undefined && !isNumber(cfg?.maxRetries)) {
-        errors.push('maxRetries must be a number if provided');
+        errors.push("maxRetries must be a number if provided");
     }
     else if (cfg?.maxRetries !== undefined && cfg?.maxRetries < 0) {
-        errors.push('maxRetries cannot be negative');
+        errors.push("maxRetries cannot be negative");
     }
-    else if (cfg?.maxRetries !== undefined && cfg?.maxRetries > constants_1.VALIDATION_CONFIG.MAX_RETRY_ATTEMPTS) {
+    else if (cfg?.maxRetries !== undefined &&
+        cfg?.maxRetries > constants_1.VALIDATION_CONFIG.MAX_RETRY_ATTEMPTS) {
         errors.push(`maxRetries should not exceed ${constants_1.VALIDATION_CONFIG.MAX_RETRY_ATTEMPTS}`);
     }
     else if (cfg?.maxRetries !== undefined && cfg?.maxRetries === 0) {
-        warnings.push('maxRetries is 0 - no retry attempts will be made');
+        warnings.push("maxRetries is 0 - no retry attempts will be made");
     }
     // Validate optional printSummary
     if (cfg?.printSummary !== undefined) {
-        const validPrintSummaryValues = [true, false, 'human', 'json'];
+        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");
@@ -216,10 +242,10 @@ function validateReveniumConfig(config) {
     // Validate optional teamId
     if (cfg?.teamId !== undefined) {
         if (!isString(cfg?.teamId)) {
-            errors.push('teamId must be a string if provided');
+            errors.push("teamId must be a string if provided");
         }
         else if (cfg?.teamId?.trim()?.length === 0) {
-            errors.push('teamId cannot be empty if provided');
+            errors.push("teamId cannot be empty if provided");
         }
     }
     if (errors.length > 0) {
@@ -227,16 +253,16 @@ function validateReveniumConfig(config) {
             isValid: false,
             errors,
             warnings,
-            suggestions
+            suggestions,
         };
     }
     // Determine validated printSummary value
     let validatedPrintSummary;
-    if (cfg?.printSummary === true || cfg?.printSummary === 'human') {
-        validatedPrintSummary = 'human';
+    if (cfg?.printSummary === true || cfg?.printSummary === "human") {
+        validatedPrintSummary = "human";
     }
-    else if (cfg?.printSummary === 'json') {
-        validatedPrintSummary = 'json';
+    else if (cfg?.printSummary === "json") {
+        validatedPrintSummary = "json";
     }
     else if (cfg?.printSummary === false) {
         validatedPrintSummary = false;
@@ -244,20 +270,27 @@ function validateReveniumConfig(config) {
     // Build validated config (apply default for reveniumBaseUrl if not provided)
     const validatedConfig = {
         reveniumApiKey: cfg?.reveniumApiKey,
-        reveniumBaseUrl: isString(cfg?.reveniumBaseUrl) ? cfg?.reveniumBaseUrl : constants_1.DEFAULT_CONFIG.REVENIUM_BASE_URL,
-        anthropicApiKey: isString(cfg?.anthropicApiKey) ? cfg?.anthropicApiKey : undefined,
+        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,
         printSummary: validatedPrintSummary,
-        teamId: isString(cfg?.teamId) ? cfg?.teamId?.trim() : undefined
+        teamId: isString(cfg?.teamId) ? cfg?.teamId?.trim() : undefined,
+        capturePrompts: isBoolean(cfg?.capturePrompts)
+            ? cfg?.capturePrompts
+            : undefined,
     };
     return {
         isValid: true,
         errors: [],
         warnings,
         config: validatedConfig,
-        suggestions: suggestions.length > 0 ? suggestions : undefined
+        suggestions: suggestions.length > 0 ? suggestions : undefined,
     };
 }
 /**
@@ -269,27 +302,27 @@ function validateAnthropicMessageParams(params) {
     if (!isObject(params)) {
         return {
             isValid: false,
-            errors: ['Message parameters must be an object'],
-            warnings: []
+            errors: ["Message parameters must be an object"],
+            warnings: [],
         };
     }
     const data = params;
     // Validate required model field
     if (!isString(data?.model)) {
-        errors.push('model field is required and must be a string');
+        errors.push("model field is required and must be a string");
     }
     else if (data?.model?.trim()?.length === 0) {
-        errors.push('model field cannot be empty');
+        errors.push("model field cannot be empty");
     }
     else if (!constants_1.ANTHROPIC_PATTERNS.CLAUDE_MODEL_PATTERN.test(data?.model)) {
         warnings.push('Model name does not contain "claude" - verify it is a valid Anthropic model');
     }
     // Validate required messages array
     if (!Array.isArray(data?.messages)) {
-        errors.push('messages field is required and must be an array');
+        errors.push("messages field is required and must be an array");
     }
     else if (data?.messages?.length === 0) {
-        errors.push('messages array cannot be empty');
+        errors.push("messages array cannot be empty");
     }
     else {
         // Validate message structure
@@ -302,37 +335,40 @@ function validateAnthropicMessageParams(params) {
             if (!isString(msg.role)) {
                 errors.push(`Message at index ${index} must have a role field`);
             }
-            else if (!['user', 'assistant', 'system'].includes(msg.role)) {
+            else if (!["user", "assistant", "system"].includes(msg.role)) {
                 warnings.push(`Message at index ${index} has unusual role: ${msg.role}`);
             }
-            if (msg?.content && !isString(msg?.content) && !Array.isArray(msg?.content)) {
+            if (msg?.content &&
+                !isString(msg?.content) &&
+                !Array.isArray(msg?.content)) {
                 warnings.push(`Message at index ${index} content should be a string or array`);
             }
         });
     }
     // Validate optional parameters
     if (!isNumber(data?.max_tokens)) {
-        warnings.push('max_tokens should be a number');
+        warnings.push("max_tokens should be a number");
     }
     else if (data?.max_tokens <= 0) {
-        warnings.push('max_tokens should be positive');
+        warnings.push("max_tokens should be positive");
     }
     else if (data?.max_tokens > constants_1.VALIDATION_CONFIG.HIGH_MAX_TOKENS_THRESHOLD) {
-        warnings.push('max_tokens is very high - verify this is intended');
+        warnings.push("max_tokens is very high - verify this is intended");
     }
     if (!isNumber(data?.temperature)) {
-        warnings.push('temperature should be a number');
+        warnings.push("temperature should be a number");
     }
-    else if (data?.temperature < constants_1.VALIDATION_CONFIG.MIN_TEMPERATURE || data?.temperature > constants_1.VALIDATION_CONFIG.MAX_TEMPERATURE) {
+    else if (data?.temperature < constants_1.VALIDATION_CONFIG.MIN_TEMPERATURE ||
+        data?.temperature > constants_1.VALIDATION_CONFIG.MAX_TEMPERATURE) {
         warnings.push(`temperature should be between ${constants_1.VALIDATION_CONFIG.MIN_TEMPERATURE} and ${constants_1.VALIDATION_CONFIG.MAX_TEMPERATURE} for Anthropic models`);
     }
     if (data?.stream && !isBoolean(data?.stream)) {
-        warnings.push('stream should be a boolean');
+        warnings.push("stream should be a boolean");
     }
     return {
         isValid: errors.length === 0,
         errors,
-        warnings
+        warnings,
     };
 }
 //# sourceMappingURL=validation.js.map

package/dist/cjs/wrapper.js

@@ -14,6 +14,8 @@ const config_1 = require("./config");
 const tracking_1 = require("./tracking");
 const validation_1 = require("./utils/validation");
 const error_handling_1 = require("./utils/error-handling");
+const prompt_extraction_1 = require("./utils/prompt-extraction");
+const trace_fields_1 = require("./utils/trace-fields");
 const crypto_1 = require("crypto");
 // Global logger
 const logger = (0, config_1.getLogger)();
@@ -136,6 +138,65 @@ function unpatchAnthropic() {
 function isAnthropicPatched() {
     return patchingContext.isPatched;
 }
+/**
+ * Reconstruct a response object from streaming chunks for prompt capture
+ */
+function reconstructResponseFromChunks(chunks, model) {
+    const contentBlocks = [];
+    let stopReason;
+    let stopSequence;
+    const usage = {};
+    for (const chunk of chunks) {
+        if (chunk.type === "content_block_start" && chunk.content_block) {
+            contentBlocks.push({ ...chunk.content_block });
+        }
+        else if (chunk.type === "content_block_delta" && chunk.delta) {
+            const lastBlock = contentBlocks[contentBlocks.length - 1];
+            if (lastBlock && chunk.delta.type === "text_delta") {
+                if (lastBlock.type === "text") {
+                    lastBlock.text = (lastBlock.text || "") + (chunk.delta.text || "");
+                }
+            }
+            else if (lastBlock && chunk.delta.type === "input_json_delta") {
+                if (lastBlock.type === "tool_use") {
+                    lastBlock.input = lastBlock.input || "";
+                    lastBlock.input +=
+                        chunk.delta.partial_json || "";
+                }
+            }
+        }
+        else if (chunk.type === "message_delta" && chunk.delta) {
+            const delta = chunk.delta;
+            if (delta.stop_reason) {
+                stopReason = delta.stop_reason;
+            }
+            if (delta.stop_sequence) {
+                stopSequence = delta.stop_sequence;
+            }
+        }
+        else if (chunk.type === "message_start" && chunk.message?.usage) {
+            Object.assign(usage, chunk.message.usage);
+        }
+        else if (chunk.usage) {
+            Object.assign(usage, chunk.usage);
+        }
+    }
+    return {
+        id: `reconstructed-${Date.now()}`,
+        type: "message",
+        role: "assistant",
+        content: contentBlocks,
+        model,
+        stop_reason: stopReason || "end_turn",
+        stop_sequence: stopSequence,
+        usage: {
+            input_tokens: usage.input_tokens || 0,
+            output_tokens: usage.output_tokens || 0,
+            cache_creation_input_tokens: usage.cache_creation_input_tokens,
+            cache_read_input_tokens: usage.cache_read_input_tokens,
+        },
+    };
+}
 /**
  * Handle streaming response by collecting chunks and extracting usage data
  */
@@ -168,6 +229,10 @@ async function handleStreamingResponse(stream, context) {
                 timeToFirstToken,
             });
             const usage = (0, tracking_1.extractUsageFromStream)(chunks);
+            let reconstructedResponse = undefined;
+            if ((0, prompt_extraction_1.shouldCapturePrompts)(metadata)) {
+                reconstructedResponse = reconstructResponseFromChunks(chunks, model);
+            }
             // Create tracking data
             const trackingData = {
                 requestId,
@@ -184,6 +249,8 @@ async function handleStreamingResponse(stream, context) {
                 responseTime,
                 timeToFirstToken,
                 requestBody: requestBody,
+                response: reconstructedResponse,
+                hasVisionContent: (0, trace_fields_1.detectVisionContent)(requestBody),
             };
             // Track usage asynchronously
             (0, tracking_1.trackUsageAsync)(trackingData);
@@ -245,6 +312,8 @@ async function patchedCreateMethod(params, options) {
             const responseTime = new Date();
             // Extract usage information
             const usage = (0, tracking_1.extractUsageFromResponse)(response);
+            // Detect vision content
+            const hasVisionContent = (0, trace_fields_1.detectVisionContent)(params);
             // Create tracking data
             const trackingData = {
                 requestId,
@@ -259,7 +328,9 @@ async function patchedCreateMethod(params, options) {
                 metadata,
                 requestTime,
                 responseTime,
+                hasVisionContent,
                 requestBody: params,
+                response,
             };
             // Track usage asynchronously
             (0, tracking_1.trackUsageAsync)(trackingData);
@@ -344,6 +415,12 @@ async function* patchedStreamMethod(params, options) {
             : undefined;
         // Extract usage information from all chunks
         const usage = (0, tracking_1.extractUsageFromStream)(chunks);
+        // Detect vision content
+        const hasVisionContent = (0, trace_fields_1.detectVisionContent)(params);
+        let reconstructedResponse = undefined;
+        if ((0, prompt_extraction_1.shouldCapturePrompts)(metadata)) {
+            reconstructedResponse = reconstructResponseFromChunks(chunks, params.model);
+        }
         // Create tracking data
         const trackingData = {
             requestId,
@@ -359,7 +436,9 @@ async function* patchedStreamMethod(params, options) {
             requestTime,
             responseTime,
             timeToFirstToken,
+            hasVisionContent,
             requestBody: params,
+            response: reconstructedResponse,
         };
         // Track usage asynchronously
         (0, tracking_1.trackUsageAsync)(trackingData);