@juspay/neurolink 7.33.2 → 7.33.4

package/dist/lib/constants/index.js

@@ -0,0 +1,195 @@
+/**
+ * Unified Constants Export
+ *
+ * This file provides a centralized export point for all NeuroLink constants,
+ * replacing magic numbers throughout the codebase with named, documented values.
+ *
+ * Categories:
+ * - Timeouts: Tool execution, provider testing, MCP initialization
+ * - Retry Logic: Backoff strategies, circuit breaker patterns
+ * - Performance: Memory thresholds, concurrency limits, buffer sizes
+ * - Tokens: Provider limits, use-case specific allocations
+ *
+ * @see MAGIC_NUMBER_REFACTORING_ANALYSIS.md for implementation details
+ */
+// ===== TIMEOUT CONSTANTS =====
+export { TOOL_TIMEOUTS, PROVIDER_TIMEOUTS, MCP_TIMEOUTS, CIRCUIT_BREAKER_TIMEOUTS, NETWORK_TIMEOUTS, SYSTEM_TIMEOUTS, DEV_TIMEOUTS, TIMEOUTS, TimeoutUtils, 
+// Legacy compatibility
+DEFAULT_TIMEOUT, PROVIDER_TEST_TIMEOUT, MCP_INIT_TIMEOUT, CIRCUIT_BREAKER_RESET_MS, } from "./timeouts.js";
+// ===== RETRY CONSTANTS =====
+export { RETRY_ATTEMPTS, RETRY_DELAYS, BACKOFF_CONFIG, CIRCUIT_BREAKER, PROVIDER_RETRY, OPERATION_RETRY, RetryUtils, 
+// Legacy compatibility
+DEFAULT_RETRY_ATTEMPTS, DEFAULT_INITIAL_DELAY, DEFAULT_MAX_DELAY, DEFAULT_BACKOFF_MULTIPLIER, CIRCUIT_BREAKER_FAILURE_THRESHOLD, } from "./retry.js";
+// ===== PERFORMANCE CONSTANTS =====
+export { UNIT_CONVERSIONS, TEXT_PREVIEW_LENGTHS, PERFORMANCE_THRESHOLDS, MEMORY_THRESHOLDS, RESPONSE_TIME_THRESHOLDS, CONCURRENCY_LIMITS, BUFFER_SIZES, CACHE_CONFIG, MONITORING_CONFIG, OPTIMIZATION_THRESHOLDS, GC_CONFIG, SERVER_CONFIG, PerformanceUtils, 
+// Legacy compatibility
+HIGH_MEMORY_THRESHOLD, DEFAULT_CONCURRENCY_LIMIT, MAX_CONCURRENCY_LIMIT, SMALL_BUFFER_SIZE, LARGE_BUFFER_SIZE, DEFAULT_CACHE_SIZE, 
+// New convenience exports
+NANOSECOND_TO_MS_DIVISOR, TEXT_PREVIEW_LENGTHS_EXPORT, PERFORMANCE_THRESHOLDS_EXPORT, } from "./performance.js";
+// ===== TOKEN CONSTANTS =====
+export { TOKEN_LIMITS, PROVIDER_TOKEN_LIMITS, USE_CASE_TOKENS, CONTEXT_WINDOWS, TOKEN_ESTIMATION, TokenUtils, 
+// Legacy compatibility
+DEFAULT_MAX_TOKENS, DEFAULT_EVALUATION_MAX_TOKENS, DEFAULT_ANALYSIS_MAX_TOKENS, DEFAULT_DOCUMENTATION_MAX_TOKENS, ANTHROPIC_SAFE, OPENAI_STANDARD, GOOGLE_STANDARD, } from "./tokens.js";
+// ===== COMPOSITE CONFIGURATIONS =====
+/**
+ * Common timeout configurations for different operation types
+ */
+export const OPERATION_TIMEOUTS = {
+    QUICK: PROVIDER_TIMEOUTS.TEST_MS, // Fast operations (health checks, simple queries)
+    STANDARD: TOOL_TIMEOUTS.EXECUTION_DEFAULT_MS, // Standard operations (tool execution, generation)
+    EXTENDED: TOOL_TIMEOUTS.EXECUTION_COMPLEX_MS, // Long operations (complex analysis, large file processing)
+    CRITICAL: TOOL_TIMEOUTS.EXECUTION_BATCH_MS, // Critical operations (system initialization, backup)
+};
+// Import the constants from the individual files for use in composite configurations
+import { PROVIDER_TIMEOUTS, MCP_TIMEOUTS, TimeoutUtils, TOOL_TIMEOUTS, } from "./timeouts.js";
+import { RETRY_ATTEMPTS, RETRY_DELAYS, PROVIDER_RETRY, RetryUtils, } from "./retry.js";
+import { CONCURRENCY_LIMITS, MEMORY_THRESHOLDS, BUFFER_SIZES, } from "./performance.js";
+import { TokenUtils } from "./tokens.js";
+/**
+ * Provider operation configurations combining timeouts and retries
+ */
+export const PROVIDER_OPERATION_CONFIGS = {
+    OPENAI: {
+        timeout: PROVIDER_TIMEOUTS.CONNECTION_MS,
+        maxRetries: PROVIDER_RETRY.OPENAI.maxAttempts,
+        retryDelay: PROVIDER_RETRY.OPENAI.baseDelay,
+    },
+    ANTHROPIC: {
+        timeout: PROVIDER_TIMEOUTS.CONNECTION_MS,
+        maxRetries: PROVIDER_RETRY.ANTHROPIC.maxAttempts,
+        retryDelay: PROVIDER_RETRY.ANTHROPIC.baseDelay,
+    },
+    GOOGLE_AI: {
+        timeout: PROVIDER_TIMEOUTS.CONNECTION_MS,
+        maxRetries: PROVIDER_RETRY.GOOGLE.maxAttempts,
+        retryDelay: PROVIDER_RETRY.GOOGLE.baseDelay,
+    },
+    BEDROCK: {
+        timeout: PROVIDER_TIMEOUTS.CONNECTION_MS,
+        maxRetries: PROVIDER_RETRY.BEDROCK.maxAttempts,
+        retryDelay: PROVIDER_RETRY.BEDROCK.baseDelay,
+    },
+    AZURE: {
+        timeout: PROVIDER_TIMEOUTS.CONNECTION_MS,
+        maxRetries: PROVIDER_RETRY.AZURE.maxAttempts,
+        retryDelay: PROVIDER_RETRY.AZURE.baseDelay,
+    },
+    OLLAMA: {
+        timeout: PROVIDER_TIMEOUTS.CONNECTION_MS,
+        maxRetries: PROVIDER_RETRY.OLLAMA.maxAttempts,
+        retryDelay: PROVIDER_RETRY.OLLAMA.baseDelay,
+    },
+};
+/**
+ * MCP operation configurations for different server types
+ */
+export const MCP_OPERATION_CONFIGS = {
+    INITIALIZATION: {
+        timeout: MCP_TIMEOUTS.INITIALIZATION_MS,
+        maxRetries: RETRY_ATTEMPTS.DEFAULT,
+        retryDelay: RETRY_DELAYS.BASE_MS,
+    },
+    TOOL_DISCOVERY: {
+        timeout: MCP_TIMEOUTS.TOOL_DISCOVERY_MS,
+        maxRetries: RETRY_ATTEMPTS.DEFAULT,
+        retryDelay: RETRY_DELAYS.BASE_MS,
+    },
+    TOOL_EXECUTION: {
+        timeout: MCP_TIMEOUTS.TOOL_DISCOVERY_MS, // Reuse tool discovery timeout
+        maxRetries: RETRY_ATTEMPTS.DEFAULT,
+        retryDelay: RETRY_DELAYS.BASE_MS,
+    },
+    HEALTH_CHECK: {
+        timeout: PROVIDER_TIMEOUTS.TEST_MS, // Use provider test timeout for health checks
+        maxRetries: RETRY_ATTEMPTS.QUICK,
+        retryDelay: RETRY_DELAYS.QUICK_MS,
+    },
+};
+/**
+ * Performance profiles for different system loads
+ */
+export const PERFORMANCE_PROFILES = {
+    LOW_LOAD: {
+        concurrency: CONCURRENCY_LIMITS.LOW_RESOURCE,
+        memoryThreshold: MEMORY_THRESHOLDS.WARNING_MB,
+        bufferSize: BUFFER_SIZES.SMALL_BYTES,
+    },
+    NORMAL_LOAD: {
+        concurrency: CONCURRENCY_LIMITS.DEFAULT,
+        memoryThreshold: MEMORY_THRESHOLDS.WARNING_MB,
+        bufferSize: BUFFER_SIZES.STANDARD_BYTES,
+    },
+    HIGH_LOAD: {
+        concurrency: CONCURRENCY_LIMITS.HIGH_LOAD,
+        memoryThreshold: MEMORY_THRESHOLDS.CRITICAL_MB,
+        bufferSize: BUFFER_SIZES.LARGE_BYTES,
+    },
+    ENTERPRISE: {
+        concurrency: CONCURRENCY_LIMITS.HIGH_LOAD, // Use high load as enterprise default
+        memoryThreshold: MEMORY_THRESHOLDS.LEAK_DETECTION_MB, // Higher threshold for enterprise
+        bufferSize: BUFFER_SIZES.XLARGE_BYTES, // Larger buffers for enterprise
+    },
+};
+// ===== UTILITY FUNCTIONS =====
+/**
+ * Get timeout value with environment-based adjustments
+ */
+export function getTimeout(baseTimeout, environment = "production") {
+    return TimeoutUtils.getEnvironmentTimeout(baseTimeout, environment);
+}
+/**
+ * Get retry configuration for a specific provider
+ */
+export function getProviderRetryConfig(provider) {
+    return RetryUtils.getProviderRetryConfig(provider);
+}
+/**
+ * Map use case to appropriate token limits
+ * @param useCase - Use case category
+ * @returns Token limit for the use case
+ */
+function mapUseCaseToTokenLimit(useCase = "standard") {
+    switch (useCase) {
+        case "conservative":
+            return 4096; // TOKEN_LIMITS.CONSERVATIVE
+        case "standard":
+            return 8192; // TOKEN_LIMITS.STANDARD
+        case "high_capacity":
+            return 16384; // TOKEN_LIMITS.HIGH_CAPACITY
+        default:
+            return 8192; // Default to standard
+    }
+}
+/**
+ * Get token limit for a specific provider and use case
+ * @param provider - Provider name
+ * @param useCase - Use case category that determines token limits
+ * @returns Token limit appropriate for the provider and use case
+ */
+export function getProviderTokenLimit(provider, useCase = "standard") {
+    // Get the base token limit for the use case
+    const useCaseLimit = mapUseCaseToTokenLimit(useCase);
+    // Get the provider's default limit (without specific model)
+    const providerLimit = TokenUtils.getProviderTokenLimit(provider);
+    // Return the minimum of use case limit and provider limit for safety
+    return Math.min(useCaseLimit, providerLimit);
+}
+/**
+ * Get performance configuration for current system load
+ */
+export function getPerformanceConfig(load = "normal") {
+    const upper = load.toUpperCase();
+    const loadKey = (upper === "ENTERPRISE" ? "ENTERPRISE" : `${upper}_LOAD`);
+    return PERFORMANCE_PROFILES[loadKey] ?? PERFORMANCE_PROFILES.NORMAL_LOAD;
+}
+// ===== VERSION AND METADATA =====
+/**
+ * Constants system metadata
+ */
+export const CONSTANTS_METADATA = {
+    VERSION: "1.0.0",
+    LAST_UPDATED: "2025-01-27",
+    TOTAL_CONSTANTS: 300,
+    CATEGORIES: ["timeouts", "retry", "performance", "tokens"],
+    COMPATIBILITY: "backward_compatible",
+};

package/dist/lib/constants/performance.d.ts

@@ -0,0 +1,366 @@
+/**
+ * Performance and Resource Constants for NeuroLink
+ *
+ * Centralized performance configuration to replace magic numbers throughout the codebase.
+ * Includes memory thresholds, concurrency limits, buffer sizes, and cache configurations.
+ *
+ * @fileoverview Performance constants for optimal resource utilization
+ * @author NeuroLink Team
+ * @version 1.0.0
+ */
+/**
+ * Unit conversion constants
+ * Common conversion factors to replace magic numbers
+ */
+export declare const UNIT_CONVERSIONS: {
+    /** Conversion factor from nanoseconds to milliseconds */
+    readonly NANOSECOND_TO_MS_DIVISOR: 1000000;
+    /** Conversion factor from microseconds to milliseconds */
+    readonly MICROSECOND_TO_MS_DIVISOR: 1000;
+    /** Conversion factor from seconds to milliseconds */
+    readonly SECOND_TO_MS_MULTIPLIER: 1000;
+    /** Conversion factor from minutes to milliseconds */
+    readonly MINUTE_TO_MS_MULTIPLIER: 60000;
+    /** Conversion factor from hours to milliseconds */
+    readonly HOUR_TO_MS_MULTIPLIER: 3600000;
+};
+/**
+ * Text processing constants
+ * Standard lengths for text preview, logging, and truncation
+ */
+export declare const TEXT_PREVIEW_LENGTHS: {
+    /** Very short preview for debugging */
+    readonly VERY_SHORT: 50;
+    /** Short preview for compact logging */
+    readonly SHORT: 100;
+    /** Medium preview for standard logging */
+    readonly MEDIUM: 150;
+    /** Standard preview length */
+    readonly STANDARD: 200;
+    /** Long preview for detailed context */
+    readonly LONG: 300;
+    /** Extra long preview for comprehensive view */
+    readonly EXTRA_LONG: 500;
+    /** Maximum preview length before truncation */
+    readonly MAX_PREVIEW: 1000;
+};
+/**
+ * Performance thresholds for various operations
+ * Unified thresholds to replace scattered magic numbers
+ */
+export declare const PERFORMANCE_THRESHOLDS: {
+    /** Success rate threshold for tool reliability */
+    readonly SUCCESS_RATE_THRESHOLD: 0.8;
+    /** High success rate threshold */
+    readonly HIGH_SUCCESS_RATE: 0.95;
+    /** Low success rate warning threshold */
+    readonly LOW_SUCCESS_RATE_WARNING: 0.6;
+    /** Critical success rate threshold */
+    readonly CRITICAL_SUCCESS_RATE: 0.5;
+    /** Tool execution time warning threshold (ms) */
+    readonly TOOL_EXECUTION_WARNING_MS: 10000;
+    /** Large tool collection threshold */
+    readonly LARGE_TOOL_COLLECTION: 100;
+    /** Circuit breaker failure threshold */
+    readonly CIRCUIT_BREAKER_FAILURES: 5;
+    /** Circuit breaker reset timeout (ms) */
+    readonly CIRCUIT_BREAKER_RESET_MS: 60000;
+};
+/**
+ * Memory threshold configuration
+ * Thresholds for monitoring and alerting on memory usage
+ */
+export declare const MEMORY_THRESHOLDS: {
+    /** Warning threshold for general memory usage */
+    readonly WARNING_MB: 100;
+    /** Critical threshold requiring immediate attention */
+    readonly CRITICAL_MB: 200;
+    /** Tool-specific memory warning threshold */
+    readonly TOOL_WARNING_MB: 20;
+    /** Tool critical memory threshold */
+    readonly TOOL_CRITICAL_MB: 50;
+    /** Memory leak detection threshold */
+    readonly LEAK_DETECTION_MB: 300;
+    /** Maximum allowed memory before forced cleanup */
+    readonly MAX_ALLOWED_MB: 500;
+    /** Heap growth rate warning (MB per minute) */
+    readonly GROWTH_RATE_WARNING_MB_PER_MIN: 10;
+    /** Moderate memory usage threshold */
+    readonly MODERATE_USAGE_MB: 30;
+    /** Low memory usage threshold */
+    readonly LOW_USAGE_MB: 10;
+    /** Moderate memory delta threshold for operations */
+    readonly OPERATION_MODERATE_MB: 30;
+    /** Small memory delta threshold for operations */
+    readonly OPERATION_SMALL_MB: 10;
+    /** Large memory delta threshold requiring GC */
+    readonly OPERATION_LARGE_MB: 50;
+};
+/**
+ * Response time threshold configuration
+ * Defines what constitutes fast, acceptable, and slow response times
+ */
+export declare const RESPONSE_TIME_THRESHOLDS: {
+    /** Fast response time - excellent performance */
+    readonly FAST_MS: 1000;
+    /** Acceptable response time - good performance */
+    readonly ACCEPTABLE_MS: 5000;
+    /** Slow response time - needs optimization */
+    readonly SLOW_MS: 10000;
+    /** Critical response time - unacceptable */
+    readonly CRITICAL_MS: 30000;
+    /** Tool execution fast threshold */
+    readonly TOOL_FAST_MS: 2000;
+    /** Tool execution slow threshold */
+    readonly TOOL_SLOW_MS: 15000;
+    /** Provider response fast threshold */
+    readonly PROVIDER_FAST_MS: 3000;
+    /** Provider response slow threshold */
+    readonly PROVIDER_SLOW_MS: 20000;
+};
+/**
+ * Concurrency limit configuration
+ * Controls parallel execution to prevent resource exhaustion
+ */
+export declare const CONCURRENCY_LIMITS: {
+    /** Default concurrent operations */
+    readonly DEFAULT: 5;
+    /** High-load scenario concurrency */
+    readonly HIGH_LOAD: 10;
+    /** Low-resource environment concurrency */
+    readonly LOW_RESOURCE: 2;
+    /** Provider-specific concurrency */
+    readonly PROVIDER: 3;
+    /** Tool execution concurrency */
+    readonly TOOL_EXECUTION: 4;
+    /** MCP server concurrency */
+    readonly MCP_SERVER: 8;
+    /** Network request concurrency */
+    readonly NETWORK_REQUEST: 6;
+    /** Maximum concurrent streams */
+    readonly MAX_STREAMS: 3;
+    /** Database operation concurrency */
+    readonly DATABASE: 5;
+};
+/**
+ * Buffer size configuration
+ * Optimized buffer sizes for different types of operations
+ */
+export declare const BUFFER_SIZES: {
+    /** Small buffer for lightweight operations */
+    readonly SMALL_BYTES: 1024;
+    /** Standard buffer for most operations */
+    readonly STANDARD_BYTES: 4096;
+    /** Large buffer for heavy operations */
+    readonly LARGE_BYTES: 8192;
+    /** Extra large buffer for file operations */
+    readonly XLARGE_BYTES: 16384;
+    /** Memory buffer for streaming */
+    readonly STREAM_BYTES: 2048;
+    /** Network buffer size */
+    readonly NETWORK_BYTES: 4096;
+    /** File I/O buffer size */
+    readonly FILE_IO_BYTES: 8192;
+    /** Maximum single buffer size */
+    readonly MAX_BYTES: 32768;
+};
+/**
+ * Cache configuration
+ * Size limits and policies for various cache types
+ */
+export declare const CACHE_CONFIG: {
+    /** Small cache for frequently accessed items */
+    readonly SMALL_SIZE: 100;
+    /** Default cache size for most use cases */
+    readonly DEFAULT_SIZE: 1000;
+    /** Large cache for extensive data */
+    readonly LARGE_SIZE: 10000;
+    /** Provider cache size */
+    readonly PROVIDER_CACHE_SIZE: 500;
+    /** Tool registry cache size */
+    readonly TOOL_REGISTRY_SIZE: 200;
+    /** Model configuration cache */
+    readonly MODEL_CONFIG_SIZE: 50;
+    /** Session cache size */
+    readonly SESSION_CACHE_SIZE: 1000;
+    /** Maximum cache size */
+    readonly MAX_SIZE: 50000;
+    /** Cache TTL in milliseconds */
+    readonly DEFAULT_TTL_MS: 300000;
+    /** Short TTL for volatile data */
+    readonly SHORT_TTL_MS: 60000;
+    /** Long TTL for stable data */
+    readonly LONG_TTL_MS: 3600000;
+};
+/**
+ * Resource monitoring configuration
+ * Intervals and thresholds for monitoring system resources
+ */
+export declare const MONITORING_CONFIG: {
+    /** Default monitoring interval */
+    readonly DEFAULT_INTERVAL_MS: 30000;
+    /** High-frequency monitoring interval */
+    readonly HIGH_FREQ_INTERVAL_MS: 5000;
+    /** Low-frequency monitoring interval */
+    readonly LOW_FREQ_INTERVAL_MS: 60000;
+    /** Memory check interval */
+    readonly MEMORY_CHECK_INTERVAL_MS: 15000;
+    /** Performance metrics collection interval */
+    readonly METRICS_INTERVAL_MS: 10000;
+    /** Health check interval */
+    readonly HEALTH_CHECK_INTERVAL_MS: 30000;
+    /** CPU usage check interval */
+    readonly CPU_CHECK_INTERVAL_MS: 20000;
+    /** Disk usage check interval */
+    readonly DISK_CHECK_INTERVAL_MS: 120000;
+};
+/**
+ * Performance optimization thresholds
+ * Values that trigger performance optimization actions
+ */
+export declare const OPTIMIZATION_THRESHOLDS: {
+    /** CPU usage threshold for optimization */
+    readonly CPU_USAGE_PERCENT: 80;
+    /** Memory usage threshold for cleanup */
+    readonly MEMORY_CLEANUP_PERCENT: 85;
+    /** Disk usage threshold for cleanup */
+    readonly DISK_CLEANUP_PERCENT: 90;
+    /** Connection pool optimization threshold */
+    readonly CONNECTION_POOL_PERCENT: 75;
+    /** Cache hit rate minimum threshold */
+    readonly CACHE_HIT_RATE_MIN_PERCENT: 60;
+    /** Queue length threshold for scaling */
+    readonly QUEUE_LENGTH_THRESHOLD: 50;
+    /** Error rate threshold for intervention */
+    readonly ERROR_RATE_THRESHOLD_PERCENT: 5;
+};
+/**
+ * Garbage collection configuration
+ * Settings for automatic resource cleanup
+ */
+export declare const GC_CONFIG: {
+    /** Memory threshold for forced GC */
+    readonly FORCE_GC_THRESHOLD_MB: 400;
+    /** Interval for automatic GC checks */
+    readonly AUTO_GC_INTERVAL_MS: 120000;
+    /** Memory growth rate for GC trigger */
+    readonly GC_TRIGGER_GROWTH_MB: 50;
+    /** Cache cleanup interval */
+    readonly CACHE_CLEANUP_INTERVAL_MS: 300000;
+    /** Temporary file cleanup interval */
+    readonly TEMP_FILE_CLEANUP_MS: 600000;
+    /** Log rotation threshold */
+    readonly LOG_ROTATION_SIZE_MB: 100;
+};
+/**
+ * Server configuration constants
+ * Default configurations for various server types
+ */
+export declare const SERVER_CONFIG: {
+    /** Maximum number of MCP servers */
+    readonly MAX_MCP_SERVERS: 20;
+    /** Default Ollama port */
+    readonly DEFAULT_OLLAMA_PORT: 11434;
+    /** Maximum number of event handlers */
+    readonly MAX_EVENT_HANDLERS: 5;
+    /** Default server startup timeout */
+    readonly STARTUP_TIMEOUT_MS: 15000;
+    /** Provider test timeout */
+    readonly PROVIDER_TEST_TIMEOUT_MS: 5000;
+    /** MCP connection test timeout */
+    readonly MCP_CONNECTION_TEST_TIMEOUT_MS: 10000;
+    /** External tool execution timeout */
+    readonly EXTERNAL_TOOL_TIMEOUT_MS: 30000;
+};
+/**
+ * Performance utility functions
+ */
+export declare const PerformanceUtils: {
+    /**
+     * Get appropriate concurrency limit based on available resources
+     * @param resourceLevel - Resource availability level (low, medium, high)
+     * @returns Recommended concurrency limit
+     */
+    readonly getConcurrencyLimit: (resourceLevel?: "low" | "medium" | "high") => number;
+    /**
+     * Get appropriate buffer size for operation type
+     * @param operationType - Type of operation (network, file, stream, etc.)
+     * @returns Recommended buffer size in bytes
+     */
+    readonly getBufferSize: (operationType?: "network" | "file" | "stream" | "standard") => number;
+    /**
+     * Get cache configuration for specific use case
+     * @param useCase - Cache use case (provider, tool, model, session)
+     * @returns Cache configuration object
+     */
+    readonly getCacheConfig: (useCase?: "provider" | "tool" | "model" | "session" | "default") => {
+        ttl: 300000;
+        maxSize: 1000;
+    } | {
+        maxSize: 500;
+        ttl: 300000;
+    } | {
+        maxSize: 200;
+        ttl: 300000;
+    } | {
+        maxSize: 50;
+        ttl: 3600000;
+    } | {
+        maxSize: 1000;
+        ttl: 60000;
+    };
+    /**
+     * Check if memory usage exceeds threshold
+     * @param currentUsageMB - Current memory usage in MB
+     * @param threshold - Threshold type to check against
+     * @returns True if threshold is exceeded
+     */
+    readonly isMemoryThresholdExceeded: (currentUsageMB: number, threshold?: "warning" | "critical" | "tool" | "leak") => boolean;
+    /**
+     * Categorize response time performance
+     * @param responseTimeMs - Response time in milliseconds
+     * @returns Performance category
+     */
+    readonly categorizeResponseTime: (responseTimeMs: number) => "fast" | "acceptable" | "slow" | "critical";
+};
+export declare const HIGH_MEMORY_THRESHOLD: 100;
+export declare const DEFAULT_CONCURRENCY_LIMIT: 5;
+export declare const MAX_CONCURRENCY_LIMIT: 10;
+export declare const SMALL_BUFFER_SIZE: 1024;
+export declare const LARGE_BUFFER_SIZE: 8192;
+export declare const DEFAULT_CACHE_SIZE: 1000;
+export declare const NANOSECOND_TO_MS_DIVISOR: 1000000;
+export declare const TEXT_PREVIEW_LENGTHS_EXPORT: {
+    /** Very short preview for debugging */
+    readonly VERY_SHORT: 50;
+    /** Short preview for compact logging */
+    readonly SHORT: 100;
+    /** Medium preview for standard logging */
+    readonly MEDIUM: 150;
+    /** Standard preview length */
+    readonly STANDARD: 200;
+    /** Long preview for detailed context */
+    readonly LONG: 300;
+    /** Extra long preview for comprehensive view */
+    readonly EXTRA_LONG: 500;
+    /** Maximum preview length before truncation */
+    readonly MAX_PREVIEW: 1000;
+};
+export declare const PERFORMANCE_THRESHOLDS_EXPORT: {
+    /** Success rate threshold for tool reliability */
+    readonly SUCCESS_RATE_THRESHOLD: 0.8;
+    /** High success rate threshold */
+    readonly HIGH_SUCCESS_RATE: 0.95;
+    /** Low success rate warning threshold */
+    readonly LOW_SUCCESS_RATE_WARNING: 0.6;
+    /** Critical success rate threshold */
+    readonly CRITICAL_SUCCESS_RATE: 0.5;
+    /** Tool execution time warning threshold (ms) */
+    readonly TOOL_EXECUTION_WARNING_MS: 10000;
+    /** Large tool collection threshold */
+    readonly LARGE_TOOL_COLLECTION: 100;
+    /** Circuit breaker failure threshold */
+    readonly CIRCUIT_BREAKER_FAILURES: 5;
+    /** Circuit breaker reset timeout (ms) */
+    readonly CIRCUIT_BREAKER_RESET_MS: 60000;
+};