@revenium/anthropic 1.1.0 → 1.1.1

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);

package/dist/esm/tracking.js

@@ -8,6 +8,7 @@ import { withRetry, ReveniumApiError, createErrorContext, handleError, } from ".
 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";
+import { extractPrompts } from "./utils/prompt-extraction.js";
 // Global logger
 const logger = getLogger();
 if (typeof process !== "undefined") {
@@ -143,7 +144,9 @@ async function buildReveniumPayload(data) {
         "taskType",
         "agent",
         "organizationId",
+        "organizationName",
         "productId",
+        "productName",
         "subscriber",
         "subscriptionId",
         "traceId",
@@ -167,6 +170,10 @@ async function buildReveniumPayload(data) {
     const transactionName = getTransactionName();
     const retryNumber = getRetryNumber();
     const operationSubtype = detectOperationSubtype(data.requestBody);
+    let promptData = null;
+    if (data.requestBody && data.response) {
+        promptData = extractPrompts(data.requestBody, data.response, data.metadata);
+    }
     return {
         stopReason: getStopReason(data.stopReason),
         costType: "AI",
@@ -189,10 +196,12 @@ async function buildReveniumPayload(data) {
         middlewareSource: "nodejs",
         ...(data.metadata?.taskType && { taskType: data.metadata.taskType }),
         ...(data.metadata?.agent && { agent: data.metadata.agent }),
-        ...(data.metadata?.organizationId && {
-            organizationId: data.metadata.organizationId,
+        ...((data.metadata?.organizationName || data.metadata?.organizationId) && {
+            organizationName: data.metadata.organizationName || data.metadata.organizationId,
+        }),
+        ...((data.metadata?.productName || data.metadata?.productId) && {
+            productName: data.metadata.productName || data.metadata.productId,
         }),
-        ...(data.metadata?.productId && { productId: data.metadata.productId }),
         ...(data.metadata?.subscriber && { subscriber: data.metadata.subscriber }),
         ...(data.metadata?.subscriptionId && {
             subscriptionId: data.metadata.subscriptionId,
@@ -210,6 +219,15 @@ async function buildReveniumPayload(data) {
         ...(transactionName && { transactionName }),
         ...(retryNumber !== undefined && { retryNumber }),
         ...(operationSubtype && { operationSubtype }),
+        ...(data.hasVisionContent !== undefined && {
+            hasVisionContent: data.hasVisionContent,
+        }),
+        ...(promptData && {
+            systemPrompt: promptData.systemPrompt,
+            inputMessages: promptData.inputMessages,
+            outputResponse: promptData.outputResponse,
+            promptsTruncated: promptData.promptsTruncated,
+        }),
         ...customFields,
     };
 }

package/dist/esm/utils/trace-fields.js

@@ -89,6 +89,41 @@ export function detectOperationSubtype(requestBody) {
     }
     return null;
 }
+export function detectVisionContent(params) {
+    if (!params) {
+        return false;
+    }
+    try {
+        if (params.messages && Array.isArray(params.messages)) {
+            for (const message of params.messages) {
+                if (!message || typeof message !== "object" || !message.content) {
+                    continue;
+                }
+                if (Array.isArray(message.content)) {
+                    for (const block of message.content) {
+                        if (block && typeof block === "object" && block.type === "image") {
+                            return true;
+                        }
+                    }
+                }
+            }
+        }
+        if (params.system && Array.isArray(params.system)) {
+            for (const block of params.system) {
+                if (block && typeof block === "object" && block.type === "image") {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    catch (error) {
+        logger.debug("Error detecting vision content, defaulting to false", {
+            error: error instanceof Error ? error.message : String(error),
+        });
+        return false;
+    }
+}
 export function getParentTransactionId() {
     return process.env.REVENIUM_PARENT_TRANSACTION_ID || null;
 }

package/dist/esm/utils/validation.js

@@ -2,35 +2,35 @@
  * Validation utilities for Anthropic middleware
  * Provides type-safe validation with detailed error reporting
  */
-import { VALIDATION_CONFIG, ANTHROPIC_PATTERNS, DEFAULT_CONFIG } from '../constants.js';
+import { VALIDATION_CONFIG, ANTHROPIC_PATTERNS, DEFAULT_CONFIG, } from "../constants.js";
 /**
  * Type guard for checking if a value is a non-null object
  */
 export 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
  */
 export function isString(value) {
-    return typeof value === 'string';
+    return typeof value === "string";
 }
 /**
  * Type guard for checking if a value is a number
  */
 export 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
  */
 export function isBoolean(value) {
-    return typeof value === 'boolean';
+    return typeof value === "boolean";
 }
 /**
  * Validate and extract string from unknown value
  */
-export function validateString(value, defaultValue = '') {
+export function validateString(value, defaultValue = "") {
     return isString(value) ? value : defaultValue;
 }
 /**
@@ -49,8 +49,14 @@ export 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];
@@ -63,21 +69,25 @@ export 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
@@ -91,10 +101,18 @@ export 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;
 }
 /**
@@ -107,96 +125,104 @@ export 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(VALIDATION_CONFIG.REVENIUM_API_KEY_PREFIX)) {
         errors.push(`reveniumApiKey must start with "${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 < 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(VALIDATION_CONFIG.ANTHROPIC_API_KEY_PREFIX)) {
+    else if (cfg?.anthropicApiKey &&
+        !cfg?.anthropicApiKey?.startsWith(VALIDATION_CONFIG.ANTHROPIC_API_KEY_PREFIX)) {
         warnings.push(`anthropicApiKey does not start with "${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 < VALIDATION_CONFIG.MIN_API_TIMEOUT) {
+    else if (cfg?.apiTimeout !== undefined &&
+        cfg?.apiTimeout < VALIDATION_CONFIG.MIN_API_TIMEOUT) {
         errors.push(`apiTimeout must be at least ${VALIDATION_CONFIG.MIN_API_TIMEOUT}ms`);
     }
-    else if (cfg?.apiTimeout !== undefined && cfg?.apiTimeout > VALIDATION_CONFIG.MAX_API_TIMEOUT) {
+    else if (cfg?.apiTimeout !== undefined &&
+        cfg?.apiTimeout > VALIDATION_CONFIG.MAX_API_TIMEOUT) {
         errors.push(`apiTimeout must not exceed ${VALIDATION_CONFIG.MAX_API_TIMEOUT}ms`);
     }
-    else if (cfg?.apiTimeout !== undefined && cfg?.apiTimeout < 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 < 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 > VALIDATION_CONFIG.MAX_RETRY_ATTEMPTS) {
+    else if (cfg?.maxRetries !== undefined &&
+        cfg?.maxRetries > VALIDATION_CONFIG.MAX_RETRY_ATTEMPTS) {
         errors.push(`maxRetries should not exceed ${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");
@@ -205,10 +231,10 @@ export 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) {
@@ -216,16 +242,16 @@ export 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;
@@ -233,20 +259,27 @@ export function validateReveniumConfig(config) {
     // Build validated config (apply default for reveniumBaseUrl if not provided)
     const validatedConfig = {
         reveniumApiKey: cfg?.reveniumApiKey,
-        reveniumBaseUrl: isString(cfg?.reveniumBaseUrl) ? cfg?.reveniumBaseUrl : DEFAULT_CONFIG.REVENIUM_BASE_URL,
-        anthropicApiKey: isString(cfg?.anthropicApiKey) ? cfg?.anthropicApiKey : undefined,
+        reveniumBaseUrl: isString(cfg?.reveniumBaseUrl)
+            ? cfg?.reveniumBaseUrl
+            : 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,
     };
 }
 /**
@@ -258,27 +291,27 @@ export 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 (!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
@@ -291,37 +324,40 @@ export 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 > 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 < VALIDATION_CONFIG.MIN_TEMPERATURE || data?.temperature > VALIDATION_CONFIG.MAX_TEMPERATURE) {
+    else if (data?.temperature < VALIDATION_CONFIG.MIN_TEMPERATURE ||
+        data?.temperature > VALIDATION_CONFIG.MAX_TEMPERATURE) {
         warnings.push(`temperature should be between ${VALIDATION_CONFIG.MIN_TEMPERATURE} and ${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