@revenium/anthropic 1.0.8 → 1.0.9

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

@@ -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

@@ -109,6 +109,21 @@ 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";
+};
+/**
+ * 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;
     }