@revenium/anthropic 1.1.1 → 1.1.4

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.1.4] - 2026-03-03
+
+### Fixed
+
+- Use canonical model name from API response for pricing resolution
+- Use resolved model in streaming error context
+
+## [1.1.3] - 2026-02-19
+
+### Changed
+
+- Version bump (1.1.2 blocked by npm registry)
+
+## [1.1.2] - 2026-02-18
+
+### Changed
+
+- Version bump for npm publish with updated changelog
+
+## [1.1.1] - 2026-02-18
+
+### Added
+
+- Tool metering support with meter_tool event tracking
+- Output fields feature for tool metering documentation
+- Fetch timeout configuration for API calls
+
+### Fixed
+
+- Removed dead response.text() call in sendToolEvent
+- Tests updated to use global fetch mock
+- Used native fetch in tool-tracker module
+
 ## [1.1.0] - 2026-01-20
 
 ### Added
@@ -20,6 +53,7 @@ All notable changes to this project will be documented in this file.
 
 - Added terminal cost/metrics summary output after each API call
 - Added distributed tracing support with 10 visualization fields
+- Added CI/CD workflows for automated testing and integration
 
 ### Fixed
 
@@ -128,6 +162,10 @@ All notable changes to this project will be documented in this file.
 - Configurable retry logic
 - Debug logging support
 
+[1.1.3]: https://github.com/revenium/revenium-middleware-anthropic-node/releases/tag/v1.1.3
+[1.1.2]: https://github.com/revenium/revenium-middleware-anthropic-node/releases/tag/v1.1.2
+[1.1.1]: https://github.com/revenium/revenium-middleware-anthropic-node/releases/tag/v1.1.1
+[1.1.0]: https://github.com/revenium/revenium-middleware-anthropic-node/releases/tag/v1.1.0
 [1.0.9]: https://github.com/revenium/revenium-middleware-anthropic-node/releases/tag/v1.0.9
 [1.0.8]: https://github.com/revenium/revenium-middleware-anthropic-node/releases/tag/v1.0.8
 [1.0.7]: https://github.com/revenium/revenium-middleware-anthropic-node/releases/tag/v1.0.7

package/README.md

@@ -295,6 +295,54 @@ Add business context to track usage by organization, user, task type, or custom
 
 - [examples/advanced-features.ts](https://github.com/revenium/revenium-middleware-anthropic-node/blob/HEAD/examples/advanced-features.ts) - Working examples
 
+## Tool Metering
+
+Track execution of custom tools and external API calls with automatic timing, error handling, and metadata collection.
+
+### Quick Example
+
+```typescript
+import { meterTool, setToolContext } from '@revenium/anthropic';
+
+setToolContext({
+  agent: 'my-agent',
+  traceId: 'session-123'
+});
+
+const result = await meterTool('weather-api', async () => {
+  return await fetch('https://api.example.com/weather');
+}, {
+  operation: 'get_forecast',
+  outputFields: ['temperature', 'humidity']
+});
+```
+
+### Functions
+
+**meterTool(toolId, fn, metadata?)**
+
+Wraps a function with automatic metering. Captures duration, success/failure, and errors. Returns function result unchanged.
+
+**reportToolCall(toolId, report)**
+
+Manually report a tool call that was already executed. Useful when wrapping is not possible.
+
+**Context Management**
+
+- `setToolContext(ctx)` - Set context for all subsequent tool calls
+- `getToolContext()` - Get current context
+- `clearToolContext()` - Clear context
+- `runWithToolContext(ctx, fn)` - Run function with scoped context
+
+### Metadata Options
+
+| Field | Description |
+|-------|-------------|
+| `operation` | Tool operation name (e.g., "search", "scrape") |
+| `outputFields` | Array of field names to auto-extract from result |
+| `usageMetadata` | Custom metrics (e.g., tokens, results count) |
+| `agent`, `traceId`, etc. | Context fields (inherited from setToolContext) |
+
 ## Metadata Fields
 
 The middleware automatically sends the following fields to Revenium's `/meter/v2/ai/completions` endpoint:

package/dist/cjs/index.js

@@ -4,7 +4,7 @@
  * Clean architecture without backward compatibility constraints
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateUsageMetadata = exports.validateAnthropicMessageParams = exports.validateReveniumConfig = exports.canExecuteRequest = exports.resetCircuitBreaker = exports.getCircuitBreakerStats = exports.extractUsageFromStream = exports.trackUsageAsync = exports.sendReveniumMetrics = exports.isAnthropicPatched = exports.unpatchAnthropic = exports.patchAnthropic = exports.validateCurrentConfig = exports.getConfigStatus = exports.getConfig = exports.getLogger = exports.setLogger = exports.setConfig = void 0;
+exports.runWithToolContext = exports.clearToolContext = exports.getToolContext = exports.setToolContext = exports.reportToolCall = exports.meterTool = exports.validateUsageMetadata = exports.validateAnthropicMessageParams = exports.validateReveniumConfig = exports.canExecuteRequest = exports.resetCircuitBreaker = exports.getCircuitBreakerStats = exports.extractUsageFromStream = exports.trackUsageAsync = exports.sendReveniumMetrics = exports.isAnthropicPatched = exports.unpatchAnthropic = exports.patchAnthropic = exports.validateCurrentConfig = exports.getConfigStatus = exports.getConfig = exports.getLogger = exports.setLogger = exports.setConfig = void 0;
 exports.initialize = initialize;
 exports.configure = configure;
 exports.isInitialized = isInitialized;
@@ -44,6 +44,14 @@ var validation_1 = require("./utils/validation");
 Object.defineProperty(exports, "validateReveniumConfig", { enumerable: true, get: function () { return validation_1.validateReveniumConfig; } });
 Object.defineProperty(exports, "validateAnthropicMessageParams", { enumerable: true, get: function () { return validation_1.validateAnthropicMessageParams; } });
 Object.defineProperty(exports, "validateUsageMetadata", { enumerable: true, get: function () { return validation_1.validateUsageMetadata; } });
+var tool_tracker_1 = require("./tool-tracker");
+Object.defineProperty(exports, "meterTool", { enumerable: true, get: function () { return tool_tracker_1.meterTool; } });
+Object.defineProperty(exports, "reportToolCall", { enumerable: true, get: function () { return tool_tracker_1.reportToolCall; } });
+var tool_context_1 = require("./tool-context");
+Object.defineProperty(exports, "setToolContext", { enumerable: true, get: function () { return tool_context_1.setToolContext; } });
+Object.defineProperty(exports, "getToolContext", { enumerable: true, get: function () { return tool_context_1.getToolContext; } });
+Object.defineProperty(exports, "clearToolContext", { enumerable: true, get: function () { return tool_context_1.clearToolContext; } });
+Object.defineProperty(exports, "runWithToolContext", { enumerable: true, get: function () { return tool_context_1.runWithToolContext; } });
 /**
  * Initialize the Revenium middleware with configuration from environment variables
  * This function can be called explicitly for better error handling and control

package/dist/cjs/tool-context.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setToolContext = setToolContext;
+exports.getToolContext = getToolContext;
+exports.clearToolContext = clearToolContext;
+exports.runWithToolContext = runWithToolContext;
+const async_hooks_1 = require("async_hooks");
+const contextStorage = new async_hooks_1.AsyncLocalStorage();
+function setToolContext(ctx) {
+    const current = contextStorage.getStore() ?? {};
+    contextStorage.enterWith({ ...current, ...ctx });
+}
+function getToolContext() {
+    return contextStorage.getStore() ?? {};
+}
+function clearToolContext() {
+    contextStorage.enterWith({});
+}
+function runWithToolContext(ctx, fn) {
+    const merged = { ...getToolContext(), ...ctx };
+    return contextStorage.run(merged, fn);
+}
+//# sourceMappingURL=tool-context.js.map

package/dist/cjs/tool-tracker.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meterTool = meterTool;
+exports.reportToolCall = reportToolCall;
+const crypto_1 = require("crypto");
+const tool_context_1 = require("./tool-context");
+const config_1 = require("./config");
+const constants_1 = require("./constants");
+const MIDDLEWARE_SOURCE = "revenium-anthropic-node";
+const TOOL_EVENTS_ENDPOINT = "/tool/events";
+function isPromise(value) {
+    return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function extractOutputFields(result, fields) {
+    if (typeof result !== "object" || result === null) {
+        return {};
+    }
+    const extracted = {};
+    for (const field of fields) {
+        if (field in result) {
+            extracted[field] = result[field];
+        }
+    }
+    return extracted;
+}
+function buildToolEventPayload(toolId, durationMs, success, metadata, errorMessage) {
+    const context = (0, tool_context_1.getToolContext)();
+    const transactionId = metadata?.transactionId ?? context.transactionId ?? (0, crypto_1.randomUUID)();
+    return {
+        transactionId,
+        toolId,
+        operation: metadata?.operation,
+        durationMs,
+        success,
+        timestamp: new Date().toISOString(),
+        errorMessage,
+        usageMetadata: metadata?.usageMetadata,
+        agent: metadata?.agent ?? context.agent,
+        organizationName: metadata?.organizationName ?? context.organizationName,
+        productName: metadata?.productName ?? context.productName,
+        subscriberCredential: metadata?.subscriberCredential ?? context.subscriberCredential,
+        workflowId: metadata?.workflowId ?? context.workflowId,
+        traceId: metadata?.traceId ?? context.traceId,
+        middlewareSource: MIDDLEWARE_SOURCE,
+    };
+}
+async function sendToolEvent(payload) {
+    const config = (0, config_1.getConfig)();
+    const logger = (0, config_1.getLogger)();
+    if (!config) {
+        logger.warn("Revenium configuration not found, skipping tool event tracking");
+        return;
+    }
+    const url = `${config.reveniumBaseUrl || constants_1.DEFAULT_CONFIG.REVENIUM_BASE_URL}${TOOL_EVENTS_ENDPOINT}`;
+    logger.debug("Sending tool event to Revenium", {
+        url,
+        toolId: payload.toolId,
+        transactionId: payload.transactionId,
+        operation: payload.operation,
+        durationMs: payload.durationMs,
+        success: payload.success,
+    });
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "x-api-key": config.reveniumApiKey,
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal,
+    }).finally(() => clearTimeout(timeoutId));
+    logger.debug("Tool event response", {
+        status: response.status,
+        statusText: response.statusText,
+        transactionId: payload.transactionId,
+        toolId: payload.toolId,
+    });
+    if (!response.ok) {
+        const responseText = await response.text();
+        logger.error("Tool event API error", {
+            status: response.status,
+            statusText: response.statusText,
+            body: responseText,
+            transactionId: payload.transactionId,
+            toolId: payload.toolId,
+        });
+        throw new Error(`Revenium tool event API error: ${response.status} ${response.statusText}`);
+    }
+    logger.debug("Tool event sent successfully", {
+        transactionId: payload.transactionId,
+        toolId: payload.toolId,
+    });
+}
+function dispatchToolEvent(payload) {
+    const logger = (0, config_1.getLogger)();
+    sendToolEvent(payload)
+        .then(() => {
+        logger.debug("Tool event sent successfully", {
+            transactionId: payload.transactionId,
+            toolId: payload.toolId,
+        });
+    })
+        .catch((error) => {
+        logger.warn("Failed to send tool event", {
+            transactionId: payload.transactionId,
+            toolId: payload.toolId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
+function meterTool(toolId, fn, metadata) {
+    const startTime = performance.now();
+    const handleSuccess = (result) => {
+        const durationMs = Math.round(performance.now() - startTime);
+        let finalMetadata = metadata;
+        if (metadata?.outputFields && metadata.outputFields.length > 0) {
+            const extracted = extractOutputFields(result, metadata.outputFields);
+            finalMetadata = {
+                ...metadata,
+                usageMetadata: {
+                    ...metadata.usageMetadata,
+                    ...extracted,
+                },
+            };
+        }
+        const payload = buildToolEventPayload(toolId, durationMs, true, finalMetadata);
+        dispatchToolEvent(payload);
+        return result;
+    };
+    const handleError = (error) => {
+        const durationMs = Math.round(performance.now() - startTime);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const payload = buildToolEventPayload(toolId, durationMs, false, metadata, errorMessage);
+        dispatchToolEvent(payload);
+        throw error;
+    };
+    try {
+        const result = fn();
+        if (isPromise(result)) {
+            return result.then(handleSuccess, handleError);
+        }
+        return Promise.resolve(handleSuccess(result));
+    }
+    catch (error) {
+        return Promise.reject(handleError(error));
+    }
+}
+function reportToolCall(toolId, report) {
+    const context = (0, tool_context_1.getToolContext)();
+    const transactionId = report.transactionId ?? context.transactionId ?? (0, crypto_1.randomUUID)();
+    const payload = {
+        transactionId,
+        toolId,
+        operation: report.operation,
+        durationMs: report.durationMs,
+        success: report.success,
+        timestamp: report.timestamp ?? new Date().toISOString(),
+        errorMessage: report.errorMessage,
+        usageMetadata: report.usageMetadata,
+        agent: report.agent ?? context.agent,
+        organizationName: report.organizationName ?? context.organizationName,
+        productName: report.productName ?? context.productName,
+        subscriberCredential: report.subscriberCredential ?? context.subscriberCredential,
+        workflowId: report.workflowId ?? context.workflowId,
+        traceId: report.traceId ?? context.traceId,
+        middlewareSource: MIDDLEWARE_SOURCE,
+    };
+    dispatchToolEvent(payload);
+}
+//# sourceMappingURL=tool-tracker.js.map

package/dist/cjs/types/tool-metering.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tool-metering.js.map

package/dist/cjs/types.js

@@ -2,5 +2,20 @@
 /**
  * Type definitions for Anthropic middleware
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types/tool-metering"), exports);
 //# sourceMappingURL=types.js.map

package/dist/cjs/wrapper.js

@@ -201,27 +201,29 @@ function reconstructResponseFromChunks(chunks, model) {
  * Handle streaming response by collecting chunks and extracting usage data
  */
 async function handleStreamingResponse(stream, context) {
-    const { requestId, model, metadata, requestTime, startTime, requestBody } = context;
-    // Create a new async generator that collects chunks and tracks usage
+    const { requestId, requestModel, metadata, requestTime, startTime, requestBody } = context;
     async function* trackingStream() {
         const chunks = [];
         let firstTokenTime;
+        let resolvedModel;
         try {
             for await (const chunk of stream) {
-                // Track first token time
                 if (!firstTokenTime && chunk.type === "content_block_delta") {
                     firstTokenTime = Date.now();
                 }
+                if (!resolvedModel && chunk.type === "message_start" && chunk.message?.model) {
+                    resolvedModel = chunk.message.model;
+                }
                 chunks.push(chunk);
                 yield chunk;
             }
-            // After stream completes, extract usage and track
             const endTime = Date.now();
             const responseTime = new Date();
             const duration = endTime - startTime;
             const timeToFirstToken = firstTokenTime
                 ? firstTokenTime - startTime
                 : undefined;
+            const model = resolvedModel ?? requestModel;
             logger.debug("Stream completed, extracting usage", {
                 requestId,
                 chunkCount: chunks.length,
@@ -233,7 +235,6 @@ async function handleStreamingResponse(stream, context) {
             if ((0, prompt_extraction_1.shouldCapturePrompts)(metadata)) {
                 reconstructedResponse = reconstructResponseFromChunks(chunks, model);
             }
-            // Create tracking data
             const trackingData = {
                 requestId,
                 model,
@@ -317,7 +318,7 @@ async function patchedCreateMethod(params, options) {
             // Create tracking data
             const trackingData = {
                 requestId,
-                model: params.model,
+                model: response.model ?? params.model,
                 inputTokens: usage.inputTokens,
                 outputTokens: usage.outputTokens,
                 cacheCreationTokens: usage.cacheCreationTokens,
@@ -336,7 +337,7 @@ async function patchedCreateMethod(params, options) {
             (0, tracking_1.trackUsageAsync)(trackingData);
             logger.debug("Anthropic request completed successfully", {
                 requestId,
-                model: params.model,
+                model: response.model ?? params.model,
                 inputTokens: usage.inputTokens,
                 outputTokens: usage.outputTokens,
                 duration,
@@ -346,7 +347,7 @@ async function patchedCreateMethod(params, options) {
         // Handle streaming response - need to collect chunks and extract usage
         return handleStreamingResponse(response, {
             requestId,
-            model: params.model,
+            requestModel: params.model,
             metadata,
             requestTime,
             startTime,
@@ -375,12 +376,12 @@ async function* patchedStreamMethod(params, options) {
     const responseTime = new Date();
     const chunks = [];
     let firstTokenTime;
+    let resolvedModel;
     logger.debug("Intercepted Anthropic messages.stream call", {
         requestId,
         model: params.model,
         hasMetadata: !!params.usageMetadata,
     });
-    // Validate parameters
     const validation = (0, validation_1.validateAnthropicMessageParams)(params);
     if (!validation.isValid) {
         logger.warn("Invalid Anthropic streaming parameters detected", {
@@ -389,22 +390,21 @@ async function* patchedStreamMethod(params, options) {
             warnings: validation.warnings,
         });
     }
-    // Extract and validate metadata
     const metadata = (0, validation_1.validateUsageMetadata)(params.usageMetadata || {});
-    // Remove usageMetadata from params before calling original method
     const { usageMetadata, ...cleanParams } = params;
     try {
-        // Call original stream method
         const originalStream = patchingContext.originalMethods?.stream;
         if (!originalStream) {
             throw new error_handling_1.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") {
                 firstTokenTime = Date.now();
             }
+            if (!resolvedModel && chunk.type === "message_start" && chunk.message?.model) {
+                resolvedModel = chunk.message.model;
+            }
             chunks.push(chunk);
             yield chunk;
         }
@@ -413,18 +413,16 @@ async function* patchedStreamMethod(params, options) {
         const timeToFirstToken = firstTokenTime
             ? firstTokenTime - startTime
             : undefined;
-        // Extract usage information from all chunks
+        const model = resolvedModel ?? params.model;
         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);
+            reconstructedResponse = reconstructResponseFromChunks(chunks, model);
         }
-        // Create tracking data
         const trackingData = {
             requestId,
-            model: params.model,
+            model,
             inputTokens: usage.inputTokens,
             outputTokens: usage.outputTokens,
             cacheCreationTokens: usage.cacheCreationTokens,
@@ -440,11 +438,10 @@ async function* patchedStreamMethod(params, options) {
             requestBody: params,
             response: reconstructedResponse,
         };
-        // Track usage asynchronously
         (0, tracking_1.trackUsageAsync)(trackingData);
         logger.debug("Anthropic streaming request completed successfully", {
             requestId,
-            model: params.model,
+            model,
             inputTokens: usage.inputTokens,
             outputTokens: usage.outputTokens,
             duration,
@@ -457,7 +454,7 @@ async function* patchedStreamMethod(params, options) {
         const duration = endTime - startTime;
         const errorContext = (0, error_handling_1.createErrorContext)()
             .withRequestId(requestId)
-            .withModel(params.model)
+            .withModel(resolvedModel ?? params.model)
             .withDuration(duration)
             .with("isStreaming", true)
             .with("chunkCount", chunks.length)

package/dist/esm/index.js

@@ -17,6 +17,8 @@ export { sendReveniumMetrics, trackUsageAsync, extractUsageFromStream, } from ".
 // Export utility functions
 export { getCircuitBreakerStats, resetCircuitBreaker, canExecuteRequest, } from "./utils/circuit-breaker.js";
 export { validateReveniumConfig, validateAnthropicMessageParams, validateUsageMetadata, } from "./utils/validation.js";
+export { meterTool, reportToolCall, } from "./tool-tracker.js";
+export { setToolContext, getToolContext, clearToolContext, runWithToolContext, } from "./tool-context.js";
 /**
  * Initialize the Revenium middleware with configuration from environment variables
  * This function can be called explicitly for better error handling and control

package/dist/esm/tool-context.js

@@ -0,0 +1,17 @@
+import { AsyncLocalStorage } from "async_hooks";
+const contextStorage = new AsyncLocalStorage();
+export function setToolContext(ctx) {
+    const current = contextStorage.getStore() ?? {};
+    contextStorage.enterWith({ ...current, ...ctx });
+}
+export function getToolContext() {
+    return contextStorage.getStore() ?? {};
+}
+export function clearToolContext() {
+    contextStorage.enterWith({});
+}
+export function runWithToolContext(ctx, fn) {
+    const merged = { ...getToolContext(), ...ctx };
+    return contextStorage.run(merged, fn);
+}
+//# sourceMappingURL=tool-context.js.map

package/dist/esm/tool-tracker.js

@@ -0,0 +1,169 @@
+import { randomUUID } from "crypto";
+import { getToolContext } from "./tool-context.js";
+import { getConfig, getLogger } from "./config.js";
+import { DEFAULT_CONFIG } from "./constants.js";
+const MIDDLEWARE_SOURCE = "revenium-anthropic-node";
+const TOOL_EVENTS_ENDPOINT = "/tool/events";
+function isPromise(value) {
+    return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function extractOutputFields(result, fields) {
+    if (typeof result !== "object" || result === null) {
+        return {};
+    }
+    const extracted = {};
+    for (const field of fields) {
+        if (field in result) {
+            extracted[field] = result[field];
+        }
+    }
+    return extracted;
+}
+function buildToolEventPayload(toolId, durationMs, success, metadata, errorMessage) {
+    const context = getToolContext();
+    const transactionId = metadata?.transactionId ?? context.transactionId ?? randomUUID();
+    return {
+        transactionId,
+        toolId,
+        operation: metadata?.operation,
+        durationMs,
+        success,
+        timestamp: new Date().toISOString(),
+        errorMessage,
+        usageMetadata: metadata?.usageMetadata,
+        agent: metadata?.agent ?? context.agent,
+        organizationName: metadata?.organizationName ?? context.organizationName,
+        productName: metadata?.productName ?? context.productName,
+        subscriberCredential: metadata?.subscriberCredential ?? context.subscriberCredential,
+        workflowId: metadata?.workflowId ?? context.workflowId,
+        traceId: metadata?.traceId ?? context.traceId,
+        middlewareSource: MIDDLEWARE_SOURCE,
+    };
+}
+async function sendToolEvent(payload) {
+    const config = getConfig();
+    const logger = getLogger();
+    if (!config) {
+        logger.warn("Revenium configuration not found, skipping tool event tracking");
+        return;
+    }
+    const url = `${config.reveniumBaseUrl || DEFAULT_CONFIG.REVENIUM_BASE_URL}${TOOL_EVENTS_ENDPOINT}`;
+    logger.debug("Sending tool event to Revenium", {
+        url,
+        toolId: payload.toolId,
+        transactionId: payload.transactionId,
+        operation: payload.operation,
+        durationMs: payload.durationMs,
+        success: payload.success,
+    });
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "x-api-key": config.reveniumApiKey,
+        },
+        body: JSON.stringify(payload),
+        signal: controller.signal,
+    }).finally(() => clearTimeout(timeoutId));
+    logger.debug("Tool event response", {
+        status: response.status,
+        statusText: response.statusText,
+        transactionId: payload.transactionId,
+        toolId: payload.toolId,
+    });
+    if (!response.ok) {
+        const responseText = await response.text();
+        logger.error("Tool event API error", {
+            status: response.status,
+            statusText: response.statusText,
+            body: responseText,
+            transactionId: payload.transactionId,
+            toolId: payload.toolId,
+        });
+        throw new Error(`Revenium tool event API error: ${response.status} ${response.statusText}`);
+    }
+    logger.debug("Tool event sent successfully", {
+        transactionId: payload.transactionId,
+        toolId: payload.toolId,
+    });
+}
+function dispatchToolEvent(payload) {
+    const logger = getLogger();
+    sendToolEvent(payload)
+        .then(() => {
+        logger.debug("Tool event sent successfully", {
+            transactionId: payload.transactionId,
+            toolId: payload.toolId,
+        });
+    })
+        .catch((error) => {
+        logger.warn("Failed to send tool event", {
+            transactionId: payload.transactionId,
+            toolId: payload.toolId,
+            error: error instanceof Error ? error.message : String(error),
+        });
+    });
+}
+export function meterTool(toolId, fn, metadata) {
+    const startTime = performance.now();
+    const handleSuccess = (result) => {
+        const durationMs = Math.round(performance.now() - startTime);
+        let finalMetadata = metadata;
+        if (metadata?.outputFields && metadata.outputFields.length > 0) {
+            const extracted = extractOutputFields(result, metadata.outputFields);
+            finalMetadata = {
+                ...metadata,
+                usageMetadata: {
+                    ...metadata.usageMetadata,
+                    ...extracted,
+                },
+            };
+        }
+        const payload = buildToolEventPayload(toolId, durationMs, true, finalMetadata);
+        dispatchToolEvent(payload);
+        return result;
+    };
+    const handleError = (error) => {
+        const durationMs = Math.round(performance.now() - startTime);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const payload = buildToolEventPayload(toolId, durationMs, false, metadata, errorMessage);
+        dispatchToolEvent(payload);
+        throw error;
+    };
+    try {
+        const result = fn();
+        if (isPromise(result)) {
+            return result.then(handleSuccess, handleError);
+        }
+        return Promise.resolve(handleSuccess(result));
+    }
+    catch (error) {
+        return Promise.reject(handleError(error));
+    }
+}
+export function reportToolCall(toolId, report) {
+    const context = getToolContext();
+    const transactionId = report.transactionId ?? context.transactionId ?? randomUUID();
+    const payload = {
+        transactionId,
+        toolId,
+        operation: report.operation,
+        durationMs: report.durationMs,
+        success: report.success,
+        timestamp: report.timestamp ?? new Date().toISOString(),
+        errorMessage: report.errorMessage,
+        usageMetadata: report.usageMetadata,
+        agent: report.agent ?? context.agent,
+        organizationName: report.organizationName ?? context.organizationName,
+        productName: report.productName ?? context.productName,
+        subscriberCredential: report.subscriberCredential ?? context.subscriberCredential,
+        workflowId: report.workflowId ?? context.workflowId,
+        traceId: report.traceId ?? context.traceId,
+        middlewareSource: MIDDLEWARE_SOURCE,
+    };
+    dispatchToolEvent(payload);
+}
+//# sourceMappingURL=tool-tracker.js.map

package/dist/esm/types/tool-metering.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tool-metering.js.map

package/dist/esm/types.js

@@ -1,5 +1,5 @@
 /**
  * Type definitions for Anthropic middleware
  */
-export {};
+export * from "./types/tool-metering.js";
 //# sourceMappingURL=types.js.map

package/dist/esm/wrapper.js

@@ -193,27 +193,29 @@ function reconstructResponseFromChunks(chunks, model) {
  * Handle streaming response by collecting chunks and extracting usage data
  */
 async function handleStreamingResponse(stream, context) {
-    const { requestId, model, metadata, requestTime, startTime, requestBody } = context;
-    // Create a new async generator that collects chunks and tracks usage
+    const { requestId, requestModel, metadata, requestTime, startTime, requestBody } = context;
     async function* trackingStream() {
         const chunks = [];
         let firstTokenTime;
+        let resolvedModel;
         try {
             for await (const chunk of stream) {
-                // Track first token time
                 if (!firstTokenTime && chunk.type === "content_block_delta") {
                     firstTokenTime = Date.now();
                 }
+                if (!resolvedModel && chunk.type === "message_start" && chunk.message?.model) {
+                    resolvedModel = chunk.message.model;
+                }
                 chunks.push(chunk);
                 yield chunk;
             }
-            // After stream completes, extract usage and track
             const endTime = Date.now();
             const responseTime = new Date();
             const duration = endTime - startTime;
             const timeToFirstToken = firstTokenTime
                 ? firstTokenTime - startTime
                 : undefined;
+            const model = resolvedModel ?? requestModel;
             logger.debug("Stream completed, extracting usage", {
                 requestId,
                 chunkCount: chunks.length,
@@ -225,7 +227,6 @@ async function handleStreamingResponse(stream, context) {
             if (shouldCapturePrompts(metadata)) {
                 reconstructedResponse = reconstructResponseFromChunks(chunks, model);
             }
-            // Create tracking data
             const trackingData = {
                 requestId,
                 model,
@@ -309,7 +310,7 @@ async function patchedCreateMethod(params, options) {
             // Create tracking data
             const trackingData = {
                 requestId,
-                model: params.model,
+                model: response.model ?? params.model,
                 inputTokens: usage.inputTokens,
                 outputTokens: usage.outputTokens,
                 cacheCreationTokens: usage.cacheCreationTokens,
@@ -328,7 +329,7 @@ async function patchedCreateMethod(params, options) {
             trackUsageAsync(trackingData);
             logger.debug("Anthropic request completed successfully", {
                 requestId,
-                model: params.model,
+                model: response.model ?? params.model,
                 inputTokens: usage.inputTokens,
                 outputTokens: usage.outputTokens,
                 duration,
@@ -338,7 +339,7 @@ async function patchedCreateMethod(params, options) {
         // Handle streaming response - need to collect chunks and extract usage
         return handleStreamingResponse(response, {
             requestId,
-            model: params.model,
+            requestModel: params.model,
             metadata,
             requestTime,
             startTime,
@@ -367,12 +368,12 @@ async function* patchedStreamMethod(params, options) {
     const responseTime = new Date();
     const chunks = [];
     let firstTokenTime;
+    let resolvedModel;
     logger.debug("Intercepted Anthropic messages.stream call", {
         requestId,
         model: params.model,
         hasMetadata: !!params.usageMetadata,
     });
-    // Validate parameters
     const validation = validateAnthropicMessageParams(params);
     if (!validation.isValid) {
         logger.warn("Invalid Anthropic streaming parameters detected", {
@@ -381,22 +382,21 @@ async function* patchedStreamMethod(params, options) {
             warnings: validation.warnings,
         });
     }
-    // Extract and validate metadata
     const metadata = validateUsageMetadata(params.usageMetadata || {});
-    // Remove usageMetadata from params before calling original method
     const { usageMetadata, ...cleanParams } = params;
     try {
-        // Call original stream method
         const originalStream = patchingContext.originalMethods?.stream;
         if (!originalStream) {
             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") {
                 firstTokenTime = Date.now();
             }
+            if (!resolvedModel && chunk.type === "message_start" && chunk.message?.model) {
+                resolvedModel = chunk.message.model;
+            }
             chunks.push(chunk);
             yield chunk;
         }
@@ -405,18 +405,16 @@ async function* patchedStreamMethod(params, options) {
         const timeToFirstToken = firstTokenTime
             ? firstTokenTime - startTime
             : undefined;
-        // Extract usage information from all chunks
+        const model = resolvedModel ?? params.model;
         const usage = extractUsageFromStream(chunks);
-        // Detect vision content
         const hasVisionContent = detectVisionContent(params);
         let reconstructedResponse = undefined;
         if (shouldCapturePrompts(metadata)) {
-            reconstructedResponse = reconstructResponseFromChunks(chunks, params.model);
+            reconstructedResponse = reconstructResponseFromChunks(chunks, model);
         }
-        // Create tracking data
         const trackingData = {
             requestId,
-            model: params.model,
+            model,
             inputTokens: usage.inputTokens,
             outputTokens: usage.outputTokens,
             cacheCreationTokens: usage.cacheCreationTokens,
@@ -432,11 +430,10 @@ async function* patchedStreamMethod(params, options) {
             requestBody: params,
             response: reconstructedResponse,
         };
-        // Track usage asynchronously
         trackUsageAsync(trackingData);
         logger.debug("Anthropic streaming request completed successfully", {
             requestId,
-            model: params.model,
+            model,
             inputTokens: usage.inputTokens,
             outputTokens: usage.outputTokens,
             duration,
@@ -449,7 +446,7 @@ async function* patchedStreamMethod(params, options) {
         const duration = endTime - startTime;
         const errorContext = createErrorContext()
             .withRequestId(requestId)
-            .withModel(params.model)
+            .withModel(resolvedModel ?? params.model)
             .withDuration(duration)
             .with("isStreaming", true)
             .with("chunkCount", chunks.length)

package/dist/types/index.d.ts

@@ -23,13 +23,23 @@ TrackingData,
 /** Configuration validation result with detailed feedback */
 ConfigValidationResult, 
 /** Request validation result for API call validation */
-RequestValidationResult, } from "./types";
+RequestValidationResult, 
+/** Tool context for tool metering */
+ToolContext, 
+/** Tool metadata for tool metering */
+ToolMetadata, 
+/** Tool event payload structure */
+ToolEventPayload, 
+/** Tool call report structure */
+ToolCallReport, } from "./types";
 import type { MiddlewareStatus } from "./types";
 export { setConfig, setLogger, getLogger, getConfig, getConfigStatus, validateCurrentConfig, } from "./config";
 export { patchAnthropic, unpatchAnthropic, isAnthropicPatched, } from "./wrapper";
 export { sendReveniumMetrics, trackUsageAsync, extractUsageFromStream, } from "./tracking";
 export { getCircuitBreakerStats, resetCircuitBreaker, canExecuteRequest, } from "./utils/circuit-breaker";
 export { validateReveniumConfig, validateAnthropicMessageParams, validateUsageMetadata, } from "./utils/validation";
+export { meterTool, reportToolCall, } from "./tool-tracker";
+export { setToolContext, getToolContext, clearToolContext, runWithToolContext, } from "./tool-context";
 export declare function initialize(): void;
 /**
  * Manual initialization with custom configuration

package/dist/types/tool-context.d.ts

@@ -0,0 +1,6 @@
+import { ToolContext } from "./types/tool-metering";
+export declare function setToolContext(ctx: ToolContext): void;
+export declare function getToolContext(): ToolContext;
+export declare function clearToolContext(): void;
+export declare function runWithToolContext<T>(ctx: ToolContext, fn: () => T | Promise<T>): T | Promise<T>;
+//# sourceMappingURL=tool-context.d.ts.map

package/dist/types/tool-tracker.d.ts

@@ -0,0 +1,4 @@
+import { ToolMetadata, ToolCallReport } from "./types/tool-metering";
+export declare function meterTool<T>(toolId: string, fn: () => T | Promise<T>, metadata?: ToolMetadata): Promise<T>;
+export declare function reportToolCall(toolId: string, report: ToolCallReport): void;
+//# sourceMappingURL=tool-tracker.d.ts.map

package/dist/types/types/tool-metering.d.ts

@@ -0,0 +1,47 @@
+export interface ToolContext {
+    agent?: string;
+    organizationName?: string;
+    productName?: string;
+    subscriberCredential?: string;
+    workflowId?: string;
+    traceId?: string;
+    transactionId?: string;
+}
+export interface ToolMetadata extends ToolContext {
+    operation?: string;
+    outputFields?: string[];
+    usageMetadata?: Record<string, unknown>;
+}
+export interface ToolEventPayload {
+    transactionId: string;
+    toolId: string;
+    operation?: string;
+    durationMs: number;
+    success: boolean;
+    timestamp: string;
+    errorMessage?: string;
+    usageMetadata?: Record<string, unknown>;
+    agent?: string;
+    organizationName?: string;
+    productName?: string;
+    subscriberCredential?: string;
+    workflowId?: string;
+    traceId?: string;
+    middlewareSource: string;
+}
+export interface ToolCallReport {
+    operation?: string;
+    durationMs: number;
+    success: boolean;
+    errorMessage?: string;
+    usageMetadata?: Record<string, unknown>;
+    agent?: string;
+    organizationName?: string;
+    productName?: string;
+    subscriberCredential?: string;
+    workflowId?: string;
+    traceId?: string;
+    transactionId?: string;
+    timestamp?: string;
+}
+//# sourceMappingURL=tool-metering.d.ts.map

package/dist/types/types.d.ts

@@ -506,4 +506,5 @@ export interface EnvironmentConfig {
  * - 'json': JSON formatted output for automation/parsing
  */
 export type SummaryFormat = "human" | "json";
+export * from "./types/tool-metering";
 //# sourceMappingURL=types.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenium/anthropic",
-  "version": "1.1.1",
+  "version": "1.1.4",
   "description": "Transparent TypeScript middleware for automatic Revenium usage tracking with Anthropic Claude AI",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
@@ -24,9 +24,17 @@
     "build:types": "tsc -p tsconfig.types.json",
     "fix-esm": "node scripts/fix-esm-imports.js",
     "dev": "tsc --watch",
-    "example": "npm run build && tsx examples/basic.ts",
+    "test": "jest",
+    "test:unit": "jest --testPathPatterns=tests/unit",
+    "test:integration": "jest --testPathPatterns=tests/integration",
+    "test:performance": "jest --testPathPatterns=tests/performance",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "test:e2e": "npm run build && tsx tests/test-trace-fields.ts",
+    "example": "npm run build && tsx examples/getting_started.ts",
     "example:basic": "npm run build && tsx examples/basic.ts",
     "example:advanced": "npm run build && tsx examples/advanced.ts",
+    "example:metadata": "npm run build && tsx examples/metadata.ts",
     "clean": "rimraf dist",
     "prepublishOnly": "npm run clean && npm run build"
   },
@@ -59,10 +67,13 @@
   },
   "devDependencies": {
     "@anthropic-ai/sdk": "^0.55.1",
+    "@types/jest": "^30.0.0",
     "@types/node": "^20.0.0",
     "@types/node-fetch": "^2.6.12",
     "dotenv": "^16.5.0",
+    "jest": "^30.2.0",
     "rimraf": "^6.0.1",
+    "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "tsx": "^4.20.3",
     "typescript": "^5.8.3"