@revenium/anthropic 1.0.9 → 1.1.1

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

package/dist/esm/wrapper.js

@@ -6,6 +6,8 @@ import { getLogger, getConfig } from "./config.js";
 import { trackUsageAsync, extractUsageFromResponse, extractUsageFromStream, } from "./tracking.js";
 import { validateAnthropicMessageParams, validateUsageMetadata, } from "./utils/validation.js";
 import { AnthropicPatchingError, RequestProcessingError, StreamProcessingError, createErrorContext, handleError, } from "./utils/error-handling.js";
+import { shouldCapturePrompts } from "./utils/prompt-extraction.js";
+import { detectVisionContent } from "./utils/trace-fields.js";
 import { randomUUID } from "crypto";
 // Global logger
 const logger = getLogger();
@@ -128,6 +130,65 @@ export function unpatchAnthropic() {
 export 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
  */
@@ -160,6 +221,10 @@ async function handleStreamingResponse(stream, context) {
                 timeToFirstToken,
             });
             const usage = extractUsageFromStream(chunks);
+            let reconstructedResponse = undefined;
+            if (shouldCapturePrompts(metadata)) {
+                reconstructedResponse = reconstructResponseFromChunks(chunks, model);
+            }
             // Create tracking data
             const trackingData = {
                 requestId,
@@ -176,6 +241,8 @@ async function handleStreamingResponse(stream, context) {
                 responseTime,
                 timeToFirstToken,
                 requestBody: requestBody,
+                response: reconstructedResponse,
+                hasVisionContent: detectVisionContent(requestBody),
             };
             // Track usage asynchronously
             trackUsageAsync(trackingData);
@@ -237,6 +304,8 @@ async function patchedCreateMethod(params, options) {
             const responseTime = new Date();
             // Extract usage information
             const usage = extractUsageFromResponse(response);
+            // Detect vision content
+            const hasVisionContent = detectVisionContent(params);
             // Create tracking data
             const trackingData = {
                 requestId,
@@ -251,7 +320,9 @@ async function patchedCreateMethod(params, options) {
                 metadata,
                 requestTime,
                 responseTime,
+                hasVisionContent,
                 requestBody: params,
+                response,
             };
             // Track usage asynchronously
             trackUsageAsync(trackingData);
@@ -336,6 +407,12 @@ async function* patchedStreamMethod(params, options) {
             : undefined;
         // Extract usage information from all chunks
         const usage = extractUsageFromStream(chunks);
+        // Detect vision content
+        const hasVisionContent = detectVisionContent(params);
+        let reconstructedResponse = undefined;
+        if (shouldCapturePrompts(metadata)) {
+            reconstructedResponse = reconstructResponseFromChunks(chunks, params.model);
+        }
         // Create tracking data
         const trackingData = {
             requestId,
@@ -351,7 +428,9 @@ async function* patchedStreamMethod(params, options) {
             requestTime,
             responseTime,
             timeToFirstToken,
+            hasVisionContent,
             requestBody: params,
+            response: reconstructedResponse,
         };
         // Track usage asynchronously
         trackUsageAsync(trackingData);

package/dist/types/config.d.ts

@@ -1,4 +1,4 @@
-import { ReveniumConfig, Logger } from './types';
+import { ReveniumConfig, Logger } from "./types";
 /**
  * Default console logger implementation
  */

package/dist/types/constants.d.ts

@@ -22,6 +22,10 @@ export declare const DEFAULT_CONFIG: {
     readonly MAX_RETRY_ATTEMPTS: 10;
     /** Warning threshold for low API timeout */
     readonly LOW_TIMEOUT_WARNING_THRESHOLD: 3000;
+    /** Default prompt capture behavior */
+    readonly CAPTURE_PROMPTS: false;
+    /** Maximum size for each prompt field in characters (50KB) */
+    readonly MAX_PROMPT_SIZE: 50000;
 };
 /**
  * Circuit breaker configuration constants
@@ -113,6 +117,8 @@ export declare const ENV_VARS: {
     readonly PRINT_SUMMARY: "REVENIUM_PRINT_SUMMARY";
     /** Team ID for cost metrics retrieval */
     readonly TEAM_ID: "REVENIUM_TEAM_ID";
+    /** Prompt capture mode */
+    readonly CAPTURE_PROMPTS: "REVENIUM_CAPTURE_PROMPTS";
 };
 /**
  * Summary printer configuration

package/dist/types/types.d.ts

@@ -47,6 +47,8 @@ export interface ReveniumConfig {
     printSummary?: boolean | SummaryFormat;
     /** Revenium team ID for fetching cost metrics from the API. If not provided, the summary will still be printed but without cost information. */
     teamId?: string;
+    /** Whether to capture and send prompts to Revenium API (default: false) */
+    capturePrompts?: boolean;
 }
 /**
  * Usage metadata for enhanced tracking and analytics
@@ -58,16 +60,28 @@ export interface UsageMetadata {
     traceId?: string;
     /** Classification of AI operation (e.g., 'customer-support', 'content-generation', 'code-review') */
     taskType?: string;
-    /** Customer organization identifier for multi-tenant applications */
+    /** Customer organization name for multi-tenant applications (used for lookup/auto-creation) */
+    organizationName?: string;
+    /**
+     * @deprecated Use organizationName instead. This field will be removed in a future version.
+     * Customer organization identifier for multi-tenant applications
+     */
     organizationId?: string;
     /** Reference to billing plan or subscription tier */
     subscriptionId?: string;
-    /** Product or feature identifier that is using AI services */
+    /** Product or feature name that is using AI services (used for lookup/auto-creation) */
+    productName?: string;
+    /**
+     * @deprecated Use productName instead. This field will be removed in a future version.
+     * Product or feature identifier that is using AI services
+     */
     productId?: string;
     /** Agent or bot identifier for automated systems */
     agent?: string;
     /** Quality score of AI response (0.0-1.0) for performance tracking */
     responseQualityScore?: number;
+    /** Per-call override for prompt capture (overrides environment variable and config) */
+    capturePrompts?: boolean;
     /** Allow additional custom fields for extensibility */
     [key: string]: unknown;
 }
@@ -129,8 +143,12 @@ export interface TrackingData {
     responseTime: Date;
     /** Time to first token in milliseconds (for streaming responses) */
     timeToFirstToken?: number;
+    /** Whether the request contains vision/image content */
+    hasVisionContent?: boolean;
     /** Request body containing Anthropic message parameters */
     requestBody?: AnthropicMessageParams;
+    /** Response data from Anthropic API */
+    response?: AnthropicResponse;
 }
 /**
  * Internal payload structure for Revenium API
@@ -161,10 +179,10 @@ export interface ReveniumPayload {
     cacheReadTokenCount: number;
     /** Total token count (sum of all token types) */
     totalTokenCount: number;
-    /** Organization identifier for multi-tenant tracking */
-    organizationId?: string;
-    /** Product identifier */
-    productId?: string;
+    /** Organization name for multi-tenant tracking (used for lookup/auto-creation) */
+    organizationName?: string;
+    /** Product name (used for lookup/auto-creation) */
+    productName?: string;
     /** Subscriber information */
     subscriber?: Subscriber;
     /** Subscription identifier */
@@ -197,9 +215,14 @@ export interface ReveniumPayload {
     parentTransactionId?: string;
     transactionName?: string;
     region?: string;
+    hasVisionContent?: boolean;
     credentialAlias?: string;
     traceType?: string;
     traceName?: string;
+    systemPrompt?: string;
+    inputMessages?: string;
+    outputResponse?: string;
+    promptsTruncated?: boolean;
 }
 /**
  * Anthropic content block types for message validation
@@ -328,8 +351,14 @@ export interface AnthropicMessageParams {
     stream?: boolean;
     /** Sequences that will stop generation */
     stop_sequences?: string[];
-    /** System message to set context */
-    system?: string;
+    /** System message to set context - can be string or array of content blocks */
+    system?: string | Array<{
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        source: unknown;
+    }>;
     /** Available tools for function calling */
     tools?: AnthropicTool[];
     /** Tool usage configuration */
@@ -469,6 +498,7 @@ export interface EnvironmentConfig {
     maxRetries?: string;
     printSummary?: string;
     teamId?: string;
+    capturePrompts?: string;
 }
 /**
  * Summary output format options