@revenium/anthropic 1.0.8 → 1.1.0

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

@@ -0,0 +1,106 @@
+import { getLogger } from "../config.js";
+const logger = getLogger();
+let cachedRegion = null;
+let regionCached = false;
+export function getEnvironment() {
+    const env = process.env.REVENIUM_ENVIRONMENT ||
+        process.env.NODE_ENV ||
+        process.env.DEPLOYMENT_ENV ||
+        null;
+    if (env && env.length > 255) {
+        logger.warn(`environment exceeds max length of 255 characters. Truncating.`);
+        return env.substring(0, 255).trim();
+    }
+    return env ? env.trim() : null;
+}
+export async function getRegion() {
+    if (regionCached) {
+        return cachedRegion;
+    }
+    const envRegion = process.env.AWS_REGION ||
+        process.env.AZURE_REGION ||
+        process.env.GCP_REGION ||
+        process.env.REVENIUM_REGION;
+    if (envRegion) {
+        cachedRegion = envRegion.trim();
+        regionCached = true;
+        return cachedRegion;
+    }
+    try {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 1000);
+        const response = await fetch("http://169.254.169.254/latest/meta-data/placement/region", {
+            signal: controller.signal,
+        });
+        clearTimeout(timeoutId);
+        if (!response.ok) {
+            cachedRegion = null;
+            regionCached = true;
+            return null;
+        }
+        const text = await response.text();
+        cachedRegion = text.trim();
+        regionCached = true;
+        return cachedRegion;
+    }
+    catch (error) {
+        cachedRegion = null;
+        regionCached = true;
+        return null;
+    }
+}
+export function getCredentialAlias() {
+    const alias = process.env.REVENIUM_CREDENTIAL_ALIAS || null;
+    if (alias && alias.length > 255) {
+        logger.warn(`credentialAlias exceeds max length of 255 characters. Truncating.`);
+        return alias.substring(0, 255).trim();
+    }
+    return alias ? alias.trim() : null;
+}
+export function getTraceType() {
+    const traceType = process.env.REVENIUM_TRACE_TYPE;
+    if (!traceType) {
+        return null;
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(traceType)) {
+        logger.warn(`Invalid trace_type format: ${traceType}. Must be alphanumeric with hyphens/underscores only.`);
+        return null;
+    }
+    if (traceType.length > 128) {
+        logger.warn(`trace_type exceeds max length of 128 characters: ${traceType}. Truncating.`);
+        return traceType.substring(0, 128);
+    }
+    return traceType;
+}
+export function getTraceName() {
+    const traceName = process.env.REVENIUM_TRACE_NAME;
+    if (!traceName) {
+        return null;
+    }
+    if (traceName.length > 256) {
+        logger.warn(`trace_name exceeds max length of 256 characters. Truncating.`);
+        return traceName.substring(0, 256);
+    }
+    return traceName;
+}
+export function detectOperationSubtype(requestBody) {
+    if (requestBody && requestBody.tools && requestBody.tools.length > 0) {
+        return "function_call";
+    }
+    return null;
+}
+export function getParentTransactionId() {
+    return process.env.REVENIUM_PARENT_TRANSACTION_ID || null;
+}
+export function getTransactionName() {
+    return process.env.REVENIUM_TRANSACTION_NAME || null;
+}
+export function getRetryNumber() {
+    const retryNum = process.env.REVENIUM_RETRY_NUMBER;
+    if (retryNum) {
+        const parsed = parseInt(retryNum, 10);
+        return isNaN(parsed) ? 0 : parsed;
+    }
+    return 0;
+}
+//# sourceMappingURL=trace-fields.js.map

package/dist/esm/utils/validation.js

@@ -2,7 +2,7 @@
  * Validation utilities for Anthropic middleware
  * Provides type-safe validation with detailed error reporting
  */
-import { VALIDATION_CONFIG, ANTHROPIC_PATTERNS } 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
  */
@@ -128,29 +128,31 @@ export function validateReveniumConfig(config) {
     else if (cfg?.reveniumApiKey?.length < VALIDATION_CONFIG.MIN_API_KEY_LENGTH) {
         warnings.push('reveniumApiKey appears to be too short - verify it is correct');
     }
-    // Validate Revenium base URL
-    if (!isString(cfg?.reveniumBaseUrl)) {
-        errors.push('reveniumBaseUrl is required and must be a string');
-    }
-    else if (!cfg?.reveniumBaseUrl?.trim()) {
-        errors.push('reveniumBaseUrl cannot be empty');
-    }
-    else {
-        try {
-            const url = new URL(cfg?.reveniumBaseUrl);
-            if (!url.protocol.startsWith('http')) {
-                errors.push('reveniumBaseUrl must use HTTP or HTTPS protocol');
+    // 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');
+        }
+        else if (!cfg?.reveniumBaseUrl?.trim()) {
+            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');
+                }
+                // Check for localhost/development hostnames (IPv4, IPv6, and named)
+                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');
+                }
             }
-            // Check for localhost/development hostnames (IPv4, IPv6, and named)
-            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');
+            catch {
+                errors.push('reveniumBaseUrl must be a valid URL');
+                suggestions.push('Use format: https://api.revenium.ai');
             }
         }
-        catch {
-            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)) {
@@ -192,6 +194,23 @@ export function validateReveniumConfig(config) {
     else if (cfg?.maxRetries !== undefined && cfg?.maxRetries === 0) {
         warnings.push('maxRetries is 0 - no retry attempts will be made');
     }
+    // Validate optional printSummary
+    if (cfg?.printSummary !== undefined) {
+        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");
+        }
+    }
+    // Validate optional teamId
+    if (cfg?.teamId !== undefined) {
+        if (!isString(cfg?.teamId)) {
+            errors.push('teamId must be a string if provided');
+        }
+        else if (cfg?.teamId?.trim()?.length === 0) {
+            errors.push('teamId cannot be empty if provided');
+        }
+    }
     if (errors.length > 0) {
         return {
             isValid: false,
@@ -200,14 +219,27 @@ export function validateReveniumConfig(config) {
             suggestions
         };
     }
-    // Build validated config
+    // Determine validated printSummary value
+    let validatedPrintSummary;
+    if (cfg?.printSummary === true || cfg?.printSummary === 'human') {
+        validatedPrintSummary = 'human';
+    }
+    else if (cfg?.printSummary === 'json') {
+        validatedPrintSummary = 'json';
+    }
+    else if (cfg?.printSummary === false) {
+        validatedPrintSummary = false;
+    }
+    // Build validated config (apply default for reveniumBaseUrl if not provided)
     const validatedConfig = {
         reveniumApiKey: cfg?.reveniumApiKey,
-        reveniumBaseUrl: cfg?.reveniumBaseUrl,
+        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
+        maxRetries: isNumber(cfg?.maxRetries) ? cfg?.maxRetries : undefined,
+        printSummary: validatedPrintSummary,
+        teamId: isString(cfg?.teamId) ? cfg?.teamId?.trim() : undefined
     };
     return {
         isValid: true,

package/dist/esm/wrapper.js

@@ -1,12 +1,12 @@
 /**
  * Anthropic SDK wrapper with type safety and structured error handling
  */
-import Anthropic from '@anthropic-ai/sdk';
-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 { randomUUID } from 'crypto';
+import Anthropic from "@anthropic-ai/sdk";
+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 { randomUUID } from "crypto";
 // Global logger
 const logger = getLogger();
 /**
@@ -15,7 +15,7 @@ const logger = getLogger();
 const patchingContext = {
     originalMethods: {},
     isPatched: false,
-    patchedInstances: new WeakSet()
+    patchedInstances: new WeakSet(),
 };
 /**
  * Get the Messages prototype using sophisticated prototype access
@@ -38,8 +38,8 @@ function getMessagesPrototype() {
         const config = getConfig();
         const apiKey = config?.anthropicApiKey ?? process.env.ANTHROPIC_API_KEY;
         if (!apiKey) {
-            throw new AnthropicPatchingError('Unable to access Anthropic Messages prototype: No API key available and direct prototype access failed. ' +
-                'Provide ANTHROPIC_API_KEY environment variable or pass anthropicApiKey in config.');
+            throw new AnthropicPatchingError("Unable to access Anthropic Messages prototype: No API key available and direct prototype access failed. " +
+                "Provide ANTHROPIC_API_KEY environment variable or pass anthropicApiKey in config.");
         }
         const minimalInstance = new Anthropic({ apiKey });
         const messagesPrototype = Object.getPrototypeOf(minimalInstance.messages);
@@ -57,19 +57,19 @@ function getMessagesPrototype() {
  */
 export function patchAnthropic() {
     if (patchingContext.isPatched) {
-        logger.debug('Anthropic SDK already patched, skipping duplicate initialization');
+        logger.debug("Anthropic SDK already patched, skipping duplicate initialization");
         return;
     }
     try {
         // Access the Messages class prototype using sophisticated prototype access
         const messagesPrototype = getMessagesPrototype();
         if (!messagesPrototype)
-            throw new AnthropicPatchingError('Unable to access Anthropic Messages prototype');
+            throw new AnthropicPatchingError("Unable to access Anthropic Messages prototype");
         // Store original methods
         patchingContext.originalMethods.create = messagesPrototype?.create;
         patchingContext.originalMethods.stream = messagesPrototype?.stream;
         if (!patchingContext.originalMethods?.create) {
-            throw new AnthropicPatchingError('Unable to find original create method');
+            throw new AnthropicPatchingError("Unable to find original create method");
         }
         // Patch the create method
         const patchedCreateFunction = function (params, options) {
@@ -83,11 +83,11 @@ export function patchAnthropic() {
             };
         }
         patchingContext.isPatched = true;
-        logger.info('Anthropic SDK patched successfully');
+        logger.info("Anthropic SDK patched successfully");
     }
     catch (error) {
         const errorContext = createErrorContext()
-            .with('patchingAttempt', true)
+            .with("patchingAttempt", true)
             .build();
         handleError(error, logger, errorContext);
         if (error instanceof AnthropicPatchingError)
@@ -112,11 +112,11 @@ export function unpatchAnthropic() {
         }
         patchingContext.isPatched = false;
         patchingContext.originalMethods = {};
-        logger.info('Anthropic SDK unpatched successfully');
+        logger.info("Anthropic SDK unpatched successfully");
     }
     catch (error) {
         const errorContext = createErrorContext()
-            .with('unpatchingAttempt', true)
+            .with("unpatchingAttempt", true)
             .build();
         handleError(error, logger, errorContext);
         throw new AnthropicPatchingError(`Failed to unpatch Anthropic SDK: ${error instanceof Error ? error.message : String(error)}`, errorContext);
@@ -132,7 +132,7 @@ export function isAnthropicPatched() {
  * Handle streaming response by collecting chunks and extracting usage data
  */
 async function handleStreamingResponse(stream, context) {
-    const { requestId, model, metadata, requestTime, startTime } = context;
+    const { requestId, model, metadata, requestTime, startTime, requestBody } = context;
     // Create a new async generator that collects chunks and tracks usage
     async function* trackingStream() {
         const chunks = [];
@@ -140,7 +140,7 @@ async function handleStreamingResponse(stream, context) {
         try {
             for await (const chunk of stream) {
                 // Track first token time
-                if (!firstTokenTime && chunk.type === 'content_block_delta') {
+                if (!firstTokenTime && chunk.type === "content_block_delta") {
                     firstTokenTime = Date.now();
                 }
                 chunks.push(chunk);
@@ -150,12 +150,14 @@ async function handleStreamingResponse(stream, context) {
             const endTime = Date.now();
             const responseTime = new Date();
             const duration = endTime - startTime;
-            const timeToFirstToken = firstTokenTime ? firstTokenTime - startTime : undefined;
-            logger.debug('Stream completed, extracting usage', {
+            const timeToFirstToken = firstTokenTime
+                ? firstTokenTime - startTime
+                : undefined;
+            logger.debug("Stream completed, extracting usage", {
                 requestId,
                 chunkCount: chunks.length,
                 duration,
-                timeToFirstToken
+                timeToFirstToken,
             });
             const usage = extractUsageFromStream(chunks);
             // Create tracking data
@@ -172,22 +174,23 @@ async function handleStreamingResponse(stream, context) {
                 metadata,
                 requestTime,
                 responseTime,
-                timeToFirstToken
+                timeToFirstToken,
+                requestBody: requestBody,
             };
             // Track usage asynchronously
             trackUsageAsync(trackingData);
-            logger.debug('Anthropic streaming request completed successfully', {
+            logger.debug("Anthropic streaming request completed successfully", {
                 requestId,
                 model,
                 inputTokens: usage.inputTokens,
                 outputTokens: usage.outputTokens,
-                duration
+                duration,
             });
         }
         catch (error) {
-            logger.error('Error processing streaming response', {
+            logger.error("Error processing streaming response", {
                 requestId,
-                error: error instanceof Error ? error.message : String(error)
+                error: error instanceof Error ? error.message : String(error),
             });
             throw error;
         }
@@ -201,19 +204,19 @@ async function patchedCreateMethod(params, options) {
     const requestId = randomUUID();
     const startTime = Date.now();
     const requestTime = new Date();
-    logger.debug('Intercepted Anthropic messages.create call', {
+    logger.debug("Intercepted Anthropic messages.create call", {
         requestId,
         model: params.model,
         hasMetadata: !!params.usageMetadata,
-        isStreaming: !!params.stream
+        isStreaming: !!params.stream,
     });
     // Validate parameters
     const validation = validateAnthropicMessageParams(params);
     if (!validation.isValid) {
-        logger.warn('Invalid Anthropic parameters detected', {
+        logger.warn("Invalid Anthropic parameters detected", {
             requestId,
             errors: validation.errors,
-            warnings: validation.warnings
+            warnings: validation.warnings,
         });
     }
     // Extract and validate metadata
@@ -224,7 +227,7 @@ async function patchedCreateMethod(params, options) {
         // Call original method
         const originalCreate = patchingContext.originalMethods.create;
         if (!originalCreate)
-            throw new RequestProcessingError('Original create method not available');
+            throw new RequestProcessingError("Original create method not available");
         const response = await originalCreate.call(this, cleanParams, options);
         // Check if this is a streaming response
         const isStreaming = !!params.stream;
@@ -247,16 +250,17 @@ async function patchedCreateMethod(params, options) {
                 stopReason: usage.stopReason,
                 metadata,
                 requestTime,
-                responseTime
+                responseTime,
+                requestBody: params,
             };
             // Track usage asynchronously
             trackUsageAsync(trackingData);
-            logger.debug('Anthropic request completed successfully', {
+            logger.debug("Anthropic request completed successfully", {
                 requestId,
                 model: params.model,
                 inputTokens: usage.inputTokens,
                 outputTokens: usage.outputTokens,
-                duration
+                duration,
             });
             return response;
         }
@@ -266,7 +270,8 @@ async function patchedCreateMethod(params, options) {
             model: params.model,
             metadata,
             requestTime,
-            startTime
+            startTime,
+            requestBody: params,
         });
     }
     catch (error) {
@@ -291,18 +296,18 @@ async function* patchedStreamMethod(params, options) {
     const responseTime = new Date();
     const chunks = [];
     let firstTokenTime;
-    logger.debug('Intercepted Anthropic messages.stream call', {
+    logger.debug("Intercepted Anthropic messages.stream call", {
         requestId,
         model: params.model,
-        hasMetadata: !!params.usageMetadata
+        hasMetadata: !!params.usageMetadata,
     });
     // Validate parameters
     const validation = validateAnthropicMessageParams(params);
     if (!validation.isValid) {
-        logger.warn('Invalid Anthropic streaming parameters detected', {
+        logger.warn("Invalid Anthropic streaming parameters detected", {
             requestId,
             errors: validation.errors,
-            warnings: validation.warnings
+            warnings: validation.warnings,
         });
     }
     // Extract and validate metadata
@@ -313,12 +318,12 @@ async function* patchedStreamMethod(params, options) {
         // Call original stream method
         const originalStream = patchingContext.originalMethods?.stream;
         if (!originalStream) {
-            throw new StreamProcessingError('Original stream method not available');
+            throw new StreamProcessingError("Original stream method not available");
         }
         const stream = originalStream.call(this, cleanParams, options);
         for await (const chunk of stream) {
             // Track first token time
-            if (!firstTokenTime && chunk.type === 'content_block_delta') {
+            if (!firstTokenTime && chunk.type === "content_block_delta") {
                 firstTokenTime = Date.now();
             }
             chunks.push(chunk);
@@ -326,7 +331,9 @@ async function* patchedStreamMethod(params, options) {
         }
         const endTime = Date.now();
         const duration = endTime - startTime;
-        const timeToFirstToken = firstTokenTime ? firstTokenTime - startTime : undefined;
+        const timeToFirstToken = firstTokenTime
+            ? firstTokenTime - startTime
+            : undefined;
         // Extract usage information from all chunks
         const usage = extractUsageFromStream(chunks);
         // Create tracking data
@@ -343,18 +350,19 @@ async function* patchedStreamMethod(params, options) {
             metadata,
             requestTime,
             responseTime,
-            timeToFirstToken
+            timeToFirstToken,
+            requestBody: params,
         };
         // Track usage asynchronously
         trackUsageAsync(trackingData);
-        logger.debug('Anthropic streaming request completed successfully', {
+        logger.debug("Anthropic streaming request completed successfully", {
             requestId,
             model: params.model,
             inputTokens: usage.inputTokens,
             outputTokens: usage.outputTokens,
             duration,
             timeToFirstToken,
-            chunkCount: chunks.length
+            chunkCount: chunks.length,
         });
     }
     catch (error) {
@@ -364,8 +372,8 @@ async function* patchedStreamMethod(params, options) {
             .withRequestId(requestId)
             .withModel(params.model)
             .withDuration(duration)
-            .with('isStreaming', true)
-            .with('chunkCount', chunks.length)
+            .with("isStreaming", true)
+            .with("chunkCount", chunks.length)
             .build();
         handleError(error, logger, errorContext);
         throw error;

package/dist/types/config.d.ts

@@ -1,4 +1,4 @@
-import { ReveniumConfig, Logger } from './types';
+import { ReveniumConfig, Logger } from "./types";
 /**
  * Default console logger implementation
  */
@@ -13,6 +13,7 @@ export declare function validateConfig(config: ReveniumConfig): void;
 export declare function getConfig(): ReveniumConfig | null;
 /**
  * Set the global configuration
+ * Uses the normalized config from validation (with defaults applied and fields trimmed)
  */
 export declare function setConfig(config: ReveniumConfig): void;
 /**

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
@@ -109,6 +113,23 @@ export declare const ENV_VARS: {
     readonly FAIL_SILENT: "REVENIUM_FAIL_SILENT";
     /** Maximum retries */
     readonly MAX_RETRIES: "REVENIUM_MAX_RETRIES";
+    /** Print summary mode (true/false/human/json) */
+    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
+ */
+export declare const SUMMARY_PRINTER_CONFIG: {
+    /** Maximum number of retries when fetching cost metrics */
+    readonly MAX_RETRIES: 3;
+    /** Delay between retries in milliseconds */
+    readonly RETRY_DELAY: 2000;
+    /** Fetch timeout in milliseconds (prevents hung requests from keeping Node process alive) */
+    readonly FETCH_TIMEOUT: 10000;
 };
 /**
  * API endpoints

package/dist/types/types/anthropic-augmentation.d.ts

@@ -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
  */
 import { UsageMetadata } from "../types";
 export {};
@@ -109,36 +47,6 @@ declare module "@anthropic-ai/sdk/resources/messages" {
          * - **Multi-tenancy**: Organize usage by organizationId
          * - **Quality Monitoring**: Track response quality scores
          * - **Custom Analytics**: Add custom fields for specific business needs
-         *
-         * @example Basic user tracking
-         * ```typescript
-         * usageMetadata: {
-         *   subscriber: { id: 'user-123', email: 'user@example.com' },
-         *   organizationId: 'my-company'
-         * }
-         * ```
-         *
-         * @example Session and task tracking
-         * ```typescript
-         * usageMetadata: {
-         *   traceId: 'session-abc-123',
-         *   taskType: 'customer-support',
-         *   productId: 'help-desk'
-         * }
-         * ```
-         *
-         * @example Advanced analytics
-         * ```typescript
-         * usageMetadata: {
-         *   subscriber: { id: 'user-456' },
-         *   taskType: 'content-generation',
-         *   responseQualityScore: 0.95,
-         *   customMetric: 'high-priority'
-         * }
-         * ```
-         *
-         * @public
-         * @since 1.1.0
          */
         usageMetadata?: UsageMetadata;
     }