@revenium/anthropic 1.0.0

package/dist/types/utils/circuit-breaker.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Circuit breaker pattern implementation for handling repeated failures
+ */
+/**
+ * Circuit breaker states
+ */
+export declare enum CircuitState {
+    CLOSED = "CLOSED",// Normal operation
+    OPEN = "OPEN",// Failing fast
+    HALF_OPEN = "HALF_OPEN"
+}
+/**
+ * Circuit breaker configuration
+ */
+export interface CircuitBreakerConfig {
+    /** Number of failures before opening circuit */
+    failureThreshold: number;
+    /** Time in ms to wait before attempting recovery */
+    recoveryTimeout: number;
+    /** Number of successful calls needed to close circuit from half-open */
+    successThreshold: number;
+    /** Time window in ms for counting failures */
+    timeWindow: number;
+}
+/**
+ * Default circuit breaker configuration
+ */
+export declare const DEFAULT_CIRCUIT_CONFIG: CircuitBreakerConfig;
+/**
+ * Circuit breaker implementation
+ */
+export declare class CircuitBreaker {
+    private config;
+    private state;
+    private failureCount;
+    private successCount;
+    private lastFailureTime;
+    private failures;
+    private lastCleanupTime;
+    private readonly maxFailureHistorySize;
+    constructor(config?: CircuitBreakerConfig);
+    /**
+     * Execute a function with circuit breaker protection
+     */
+    execute<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Check if circuit breaker allows execution
+     */
+    canExecute(): boolean;
+    /**
+     * Get current circuit breaker state
+     */
+    getState(): CircuitState;
+    /**
+     * Get circuit breaker statistics
+     */
+    getStats(): {
+        state: CircuitState;
+        failureCount: number;
+        successCount: number;
+        recentFailures: number;
+        timeUntilRecovery?: number;
+    };
+    /**
+     * Reset circuit breaker to closed state
+     */
+    reset(): void;
+    /**
+     * Handle successful execution
+     */
+    private onSuccess;
+    /**
+     * Handle failed execution
+     */
+    private onFailure;
+    /**
+     * Check if we should attempt recovery from open state
+     */
+    private shouldAttemptRecovery;
+    /**
+     * Remove old failure timestamps outside the time window
+     */
+    private cleanupOldFailures;
+    /**
+     * Perform periodic cleanup to prevent memory leaks
+     * Only runs cleanup if enough time has passed since last cleanup
+     */
+    private performPeriodicCleanup;
+}
+/**
+ * Get or create the global circuit breaker instance
+ */
+export declare function getCircuitBreaker(config?: Partial<CircuitBreakerConfig>): CircuitBreaker;
+/**
+ * Reset the global circuit breaker
+ */
+export declare function resetCircuitBreaker(): void;
+/**
+ * Check if the global circuit breaker allows execution
+ */
+export declare function canExecuteRequest(): boolean;
+/**
+ * Execute a function with global circuit breaker protection
+ */
+export declare function executeWithCircuitBreaker<T>(fn: () => Promise<T>): Promise<T>;
+/**
+ * Get global circuit breaker statistics
+ */
+export declare function getCircuitBreakerStats(): ReturnType<CircuitBreaker['getStats']>;
+//# sourceMappingURL=circuit-breaker.d.ts.map

package/dist/types/utils/error-handling.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Error handling utilities for Anthropic middleware with structured errors and context building
+ */
+/**
+ * Base error class for Revenium middleware errors
+ */
+export declare class ReveniumError extends Error {
+    readonly code: string;
+    readonly context?: Record<string, unknown>;
+    constructor(message: string, code: string, context?: Record<string, unknown>);
+}
+/**
+ * Configuration-related errors
+ */
+export declare class ConfigurationError extends ReveniumError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Anthropic SDK patching errors
+ */
+export declare class AnthropicPatchingError extends ReveniumError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Request processing errors
+ */
+export declare class RequestProcessingError extends ReveniumError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Revenium API communication errors
+ */
+export declare class ReveniumApiError extends ReveniumError {
+    readonly statusCode?: number;
+    readonly responseBody?: string;
+    constructor(message: string, statusCode?: number, responseBody?: string, context?: Record<string, unknown>);
+}
+/**
+ * Validation errors
+ */
+export declare class ValidationError extends ReveniumError {
+    readonly validationErrors: string[];
+    constructor(message: string, validationErrors: string[], context?: Record<string, unknown>);
+}
+/**
+ * Stream processing errors
+ */
+export declare class StreamProcessingError extends ReveniumError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error context builder for consistent error reporting
+ */
+export declare class ErrorContext {
+    private context;
+    /**
+     * Add request ID to error context
+     */
+    withRequestId(requestId: string): this;
+    /**
+     * Add model information to error context
+     */
+    withModel(model: string): this;
+    /**
+     * Add duration to error context
+     */
+    withDuration(duration: number): this;
+    /**
+     * Add HTTP status to error context
+     */
+    withStatus(status: number): this;
+    /**
+     * Add custom field to error context
+     */
+    with(key: string, value: unknown): this;
+    /**
+     * Build the context object
+     */
+    build(): Record<string, unknown>;
+}
+/**
+ * Safe error message extraction
+ */
+export declare function getErrorMessage(error: unknown): string;
+/**
+ * Safe error stack extraction
+ */
+export declare function getErrorStack(error: unknown): string | undefined;
+/**
+ * Create error context builder
+ */
+export declare function createErrorContext(): ErrorContext;
+/**
+ * Handle and log errors consistently
+ */
+export declare function handleError(error: unknown, logger: {
+    error: (message: string, context?: Record<string, unknown>) => void;
+}, context?: Record<string, unknown>): void;
+/**
+ * Wrap async function with error handling
+ */
+export declare function withErrorHandling<T extends unknown[], R>(fn: (...args: T) => Promise<R>, errorHandler: (error: unknown, ...args: T) => void): (...args: T) => Promise<R | undefined>;
+/**
+ * Retry function with exponential backoff
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number, // Convert to attempts for backward compatibility
+baseDelay?: number): Promise<T>;
+//# sourceMappingURL=error-handling.d.ts.map

package/dist/types/utils/validation.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Validation utilities for Anthropic middleware
+ * Provides type-safe validation with detailed error reporting
+ */
+import { ReveniumConfig, UsageMetadata } from '../types';
+/**
+ * Type guard for checking if a value is a non-null object
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Type guard for checking if a value is a string
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Type guard for checking if a value is a number
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Type guard for checking if a value is a boolean
+ */
+export declare function isBoolean(value: unknown): value is boolean;
+/**
+ * Validate and extract string from unknown value
+ */
+export declare function validateString(value: unknown, defaultValue?: string): string;
+/**
+ * Validate and extract number from unknown value
+ */
+export declare function validateNumber(value: unknown, defaultValue?: number): number;
+/**
+ * Validate usage metadata object with Anthropic-specific considerations
+ */
+export declare function validateUsageMetadata(metadata: unknown): UsageMetadata;
+/**
+ * Configuration validation result interface
+ */
+interface ConfigValidationResult {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+    config?: ReveniumConfig;
+    suggestions?: string[];
+}
+/**
+ * Comprehensive Revenium configuration validation for Anthropic
+ */
+export declare function validateReveniumConfig(config: unknown): ConfigValidationResult;
+/**
+ * Validate Anthropic message creation parameters
+ */
+export declare function validateAnthropicMessageParams(params: unknown): {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+};
+export {};
+//# sourceMappingURL=validation.d.ts.map

package/dist/types/wrapper.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Anthropic SDK wrapper with type safety and structured error handling
+ */
+/**
+ * Patch Anthropic SDK by modifying prototype methods
+ */
+export declare function patchAnthropic(): void;
+/**
+ * Unpatch Anthropic SDK (restore original methods)
+ */
+export declare function unpatchAnthropic(): void;
+/**
+ * Check if Anthropic SDK is patched
+ */
+export declare function isAnthropicPatched(): boolean;
+//# sourceMappingURL=wrapper.d.ts.map

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@revenium/anthropic",
+  "version": "1.0.0",
+  "description": "Transparent TypeScript middleware for automatic Revenium usage tracking with Anthropic Claude AI",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/esm/index.js"
+      },
+      "require": {
+        "types": "./dist/types/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+  },
+  "scripts": {
+    "build": "npm run build:cjs && npm run build:esm && npm run build:types && npm run fix-esm",
+    "build:cjs": "tsc -p tsconfig.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:types": "tsc -p tsconfig.types.json",
+    "fix-esm": "node scripts/fix-esm-imports.js",
+    "dev": "tsc --watch",
+    "test": "npm run build && echo 'Build successful - no automated tests configured'",
+    "example": "npm run build && tsx examples/basic-usage.ts",
+    "example:basic": "npm run build && tsx examples/basic-usage.ts",
+    "example:advanced": "npm run build && tsx examples/advanced-features.ts",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "keywords": [
+    "anthropic",
+    "claude",
+    "revenium",
+    "middleware",
+    "typescript",
+    "nodejs",
+    "usage-tracking",
+    "metering",
+    "ai"
+  ],
+  "author": "Revenium",
+  "license": "MIT",
+  "dependencies": {
+    "node-fetch": "^3.3.2"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/sdk": ">=0.24.0"
+  },
+  "devDependencies": {
+    "@anthropic-ai/sdk": "^0.55.1",
+    "@types/node": "^20.0.0",
+    "@types/node-fetch": "^2.6.12",
+    "dotenv": "^16.5.0",
+    "rimraf": "^6.0.1",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.20.3",
+    "typescript": "^5.8.3"
+  },
+  "files": [
+    "dist/cjs/**/*.js",
+    "dist/esm/**/*.js",
+    "dist/types/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}