@juspay/neurolink 6.1.0 → 6.2.1

package/dist/lib/utils/providerUtils-fixed.js

@@ -1,94 +0,0 @@
-import { AIProviderFactory } from "../core/factory.js";
-import { logger } from "./logger.js";
-import { hasProviderEnvVars } from "./providerUtils.js";
-/**
- * Asynchronously get the best available provider based on real-time checks.
- * This function performs actual authentication and availability tests.
- *
- * @param requestedProvider - Optional preferred provider name
- * @returns The best provider name to use
- */
-export async function getBestProvider(requestedProvider) {
-    // 🔧 FIX: Check for explicit default provider in env
-    if (process.env.DEFAULT_PROVIDER &&
-        (await isProviderAvailable(process.env.DEFAULT_PROVIDER))) {
-        logger.debug(`[getBestProvider] Using DEFAULT_PROVIDER: ${process.env.DEFAULT_PROVIDER}`);
-        return process.env.DEFAULT_PROVIDER;
-    }
-    // 🔧 FIX: Special case for Ollama when explicitly configured
-    if (process.env.OLLAMA_BASE_URL && process.env.OLLAMA_MODEL) {
-        // Quick connectivity check for Ollama
-        try {
-            if (await isProviderAvailable("ollama")) {
-                logger.debug(`[getBestProvider] Prioritizing working local Ollama`);
-                return "ollama"; // Prioritize working local AI
-            }
-        }
-        catch {
-            // Fall through to cloud providers
-        }
-    }
-    const providers = [
-        "google-ai",
-        "anthropic",
-        "openai",
-        "mistral",
-        "vertex",
-        "azure",
-        "huggingface",
-        "bedrock",
-        "ollama", // Keep as fallback
-    ];
-    if (requestedProvider && requestedProvider !== "auto") {
-        if (await isProviderAvailable(requestedProvider)) {
-            logger.debug(`[getBestProvider] Using requested provider: ${requestedProvider}`);
-            return requestedProvider;
-        }
-        else {
-            logger.warn(`[getBestProvider] Requested provider '${requestedProvider}' is not available. Falling back to auto-selection.`);
-        }
-    }
-    for (const provider of providers) {
-        if (await isProviderAvailable(provider)) {
-            logger.debug(`[getBestProvider] Selected provider: ${provider}`);
-            return provider;
-        }
-    }
-    throw new Error("No available AI providers. Please check your configurations.");
-}
-/**
- * Check if a provider is truly available by performing a quick authentication test.
- *
- * @param providerName - The name of the provider to check.
- * @returns True if the provider is available and authenticated.
- */
-async function isProviderAvailable(providerName) {
-    if (!hasProviderEnvVars(providerName) && providerName !== "ollama") {
-        return false;
-    }
-    if (providerName === "ollama") {
-        try {
-            const response = await fetch("http://localhost:11434/api/tags", {
-                method: "GET",
-                signal: AbortSignal.timeout(2000),
-            });
-            if (response.ok) {
-                const { models } = await response.json();
-                const defaultOllamaModel = "llama3.2:latest";
-                return models.some((m) => m.name === defaultOllamaModel);
-            }
-            return false;
-        }
-        catch (error) {
-            return false;
-        }
-    }
-    try {
-        const provider = await AIProviderFactory.createProvider(providerName);
-        await provider.generate({ prompt: "test", maxTokens: 1 });
-        return true;
-    }
-    catch (error) {
-        return false;
-    }
-}

package/dist/lib/utils/streaming-utils.d.ts

@@ -1,79 +0,0 @@
-/**
- * Phase 2: Enhanced Streaming Infrastructure
- * Streaming utilities for progress tracking and metadata enhancement
- */
-import type { StreamingProgressData, StreamingMetadata, ProgressCallback } from "../core/types.js";
-export interface UIProgressHandler {
-    onProgress: (progress: StreamingProgressData) => void;
-    onComplete: (metadata: StreamingMetadata) => void;
-    onError: (error: Error) => void;
-}
-export interface StreamingStats {
-    totalChunks: number;
-    totalBytes: number;
-    duration: number;
-    averageChunkSize: number;
-    provider: string;
-    model: string;
-}
-/**
- * Enhanced streaming utilities for progress tracking and metadata
- */
-export interface StreamingConfigOptions {
-    enableProgressTracking?: boolean;
-    progressCallback?: ProgressCallback;
-    includeStreamingMetadata?: boolean;
-    streamingBufferSize?: number;
-    enableStreamingHeaders?: boolean;
-}
-/**
- * Legacy interface for backward compatibility
- */
-export interface EnhancedStreamTextOptions extends StreamingConfigOptions {
-}
-export declare class StreamingEnhancer {
-    /**
-     * Add progress tracking to a readable stream
-     */
-    static addProgressTracking(stream: ReadableStream, callback?: ProgressCallback, options?: {
-        streamId?: string;
-        bufferSize?: number;
-    }): ReadableStream;
-    /**
-     * Add metadata headers to streaming response
-     */
-    static addMetadataHeaders(response: Response, stats: StreamingStats): Response;
-    /**
-     * Create progress callback for UI integration
-     */
-    static createProgressCallback(ui: UIProgressHandler): ProgressCallback;
-    /**
-     * Estimate remaining time based on current progress
-     */
-    static estimateRemainingTime(totalBytes: number, elapsedTime: number, chunkCount: number): number | undefined;
-    /**
-     * Create enhanced streaming configuration
-     */
-    static createStreamingConfig(options: StreamingConfigOptions | EnhancedStreamTextOptions): {
-        progressTracking: boolean;
-        callback?: ProgressCallback;
-        metadata: boolean;
-        bufferSize: number;
-        headers: boolean;
-    };
-}
-/**
- * Streaming performance monitor for debugging and optimization
- */
-export declare class StreamingMonitor {
-    private static activeStreams;
-    static registerStream(streamId: string): void;
-    static updateStream(streamId: string, progress: StreamingProgressData): void;
-    static completeStream(streamId: string): void;
-    static getActiveStreams(): StreamingProgressData[];
-    static getStreamStats(): {
-        activeCount: number;
-        totalBytesActive: number;
-        averageProgress: number;
-    };
-}

package/dist/lib/utils/streaming-utils.js

@@ -1,198 +0,0 @@
-/**
- * Phase 2: Enhanced Streaming Infrastructure
- * Streaming utilities for progress tracking and metadata enhancement
- */
-export class StreamingEnhancer {
-    /**
-     * Add progress tracking to a readable stream
-     */
-    static addProgressTracking(stream, callback, options) {
-        const streamId = options?.streamId || `stream_${Date.now()}`;
-        const startTime = Date.now();
-        let chunkCount = 0;
-        let totalBytes = 0;
-        let lastProgressTime = startTime;
-        return new ReadableStream({
-            start(controller) {
-                if (callback) {
-                    callback({
-                        chunkCount: 0,
-                        totalBytes: 0,
-                        chunkSize: 0,
-                        elapsedTime: 0,
-                        streamId,
-                        phase: "initializing",
-                    });
-                }
-            },
-            async pull(controller) {
-                const reader = stream.getReader();
-                try {
-                    const { done, value } = await reader.read();
-                    if (done) {
-                        controller.close();
-                        if (callback) {
-                            const elapsedTime = Date.now() - startTime;
-                            callback({
-                                chunkCount,
-                                totalBytes,
-                                chunkSize: totalBytes > 0 ? Math.round(totalBytes / chunkCount) : 0,
-                                elapsedTime,
-                                streamId,
-                                phase: "complete",
-                            });
-                        }
-                        return;
-                    }
-                    // Track progress
-                    chunkCount++;
-                    const chunkSize = value
-                        ? new TextEncoder().encode(value.toString()).length
-                        : 0;
-                    totalBytes += chunkSize;
-                    const currentTime = Date.now();
-                    const elapsedTime = currentTime - startTime;
-                    const timeSinceLastProgress = currentTime - lastProgressTime;
-                    // Call progress callback
-                    if (callback && (timeSinceLastProgress > 100 || chunkCount === 1)) {
-                        // Throttle to max 10 calls/second
-                        const estimatedRemaining = StreamingEnhancer.estimateRemainingTime(totalBytes, elapsedTime, chunkCount);
-                        callback({
-                            chunkCount,
-                            totalBytes,
-                            chunkSize,
-                            elapsedTime,
-                            estimatedRemaining,
-                            streamId,
-                            phase: "streaming",
-                        });
-                        lastProgressTime = currentTime;
-                    }
-                    controller.enqueue(value);
-                }
-                catch (error) {
-                    controller.error(error);
-                    if (callback) {
-                        callback({
-                            chunkCount,
-                            totalBytes,
-                            chunkSize: 0,
-                            elapsedTime: Date.now() - startTime,
-                            streamId,
-                            phase: "error",
-                        });
-                    }
-                }
-                finally {
-                    reader.releaseLock();
-                }
-            },
-        });
-    }
-    /**
-     * Add metadata headers to streaming response
-     */
-    static addMetadataHeaders(response, stats) {
-        const headers = new Headers(response.headers);
-        headers.set("X-Streaming-Chunks", stats.totalChunks.toString());
-        headers.set("X-Streaming-Bytes", stats.totalBytes.toString());
-        headers.set("X-Streaming-Duration", stats.duration.toString());
-        headers.set("X-Streaming-Avg-Chunk-Size", stats.averageChunkSize.toString());
-        headers.set("X-Streaming-Provider", stats.provider);
-        headers.set("X-Streaming-Model", stats.model);
-        headers.set("X-Streaming-Throughput", Math.round(stats.totalBytes / (stats.duration / 1000)).toString());
-        return new Response(response.body, {
-            status: response.status,
-            statusText: response.statusText,
-            headers,
-        });
-    }
-    /**
-     * Create progress callback for UI integration
-     */
-    static createProgressCallback(ui) {
-        return (progress) => {
-            try {
-                ui.onProgress(progress);
-                if (progress.phase === "complete") {
-                    ui.onComplete({
-                        startTime: Date.now() - progress.elapsedTime,
-                        endTime: Date.now(),
-                        totalDuration: progress.elapsedTime,
-                        averageChunkSize: Math.round(progress.totalBytes / progress.chunkCount),
-                        maxChunkSize: progress.chunkSize, // This would need to be tracked better in real implementation
-                        minChunkSize: progress.chunkSize, // This would need to be tracked better in real implementation
-                        throughputBytesPerSecond: Math.round(progress.totalBytes / (progress.elapsedTime / 1000)),
-                        streamingProvider: "unknown", // Would be passed from provider
-                        modelUsed: "unknown", // Would be passed from provider
-                    });
-                }
-            }
-            catch (error) {
-                ui.onError(error);
-            }
-        };
-    }
-    /**
-     * Estimate remaining time based on current progress
-     */
-    static estimateRemainingTime(totalBytes, elapsedTime, chunkCount) {
-        if (elapsedTime < 1000 || chunkCount < 3) {
-            return undefined; // Not enough data for estimation
-        }
-        const bytesPerMs = totalBytes / elapsedTime;
-        const avgChunkSize = totalBytes / chunkCount;
-        // Rough estimation assuming similar chunk sizes going forward
-        // This is a simple heuristic - real implementation might be more sophisticated
-        const estimatedTotalBytes = avgChunkSize * (chunkCount + 10); // Assume 10 more chunks
-        const remainingBytes = estimatedTotalBytes - totalBytes;
-        return Math.max(0, remainingBytes / bytesPerMs);
-    }
-    /**
-     * Create enhanced streaming configuration
-     */
-    static createStreamingConfig(options) {
-        return {
-            progressTracking: options.enableProgressTracking ?? false,
-            callback: options.progressCallback,
-            metadata: options.includeStreamingMetadata ?? false,
-            bufferSize: options.streamingBufferSize ?? 8192,
-            headers: options.enableStreamingHeaders ?? false,
-        };
-    }
-}
-/**
- * Streaming performance monitor for debugging and optimization
- */
-export class StreamingMonitor {
-    static activeStreams = new Map();
-    static registerStream(streamId) {
-        this.activeStreams.set(streamId, {
-            chunkCount: 0,
-            totalBytes: 0,
-            chunkSize: 0,
-            elapsedTime: 0,
-            streamId,
-            phase: "initializing",
-        });
-    }
-    static updateStream(streamId, progress) {
-        this.activeStreams.set(streamId, progress);
-    }
-    static completeStream(streamId) {
-        this.activeStreams.delete(streamId);
-    }
-    static getActiveStreams() {
-        return Array.from(this.activeStreams.values());
-    }
-    static getStreamStats() {
-        const streams = this.getActiveStreams();
-        return {
-            activeCount: streams.length,
-            totalBytesActive: streams.reduce((sum, s) => sum + s.totalBytes, 0),
-            averageProgress: streams.length > 0
-                ? streams.reduce((sum, s) => sum + s.elapsedTime, 0) / streams.length
-                : 0,
-        };
-    }
-}

package/dist/lib/utils/timeout-manager.d.ts

@@ -1,75 +0,0 @@
-/**
- * Centralized Timeout Manager for NeuroLink
- *
- * Provides consistent timeout handling across all operations with proper cleanup,
- * abort controller integration, and graceful degradation.
- */
-export interface TimeoutConfig {
-    operation: string;
-    timeout?: number | string;
-    gracefulShutdown?: boolean;
-    retryOnTimeout?: boolean;
-    maxRetries?: number;
-    abortSignal?: AbortSignal;
-}
-export interface TimeoutResult<T> {
-    success: boolean;
-    data?: T;
-    error?: Error;
-    timedOut: boolean;
-    executionTime: number;
-    retriesUsed: number;
-}
-/**
- * Enhanced timeout manager with proper cleanup and abort controller integration
- */
-export declare class TimeoutManager {
-    private activeTimeouts;
-    /**
-     * Execute operation with timeout and proper cleanup
-     */
-    executeWithTimeout<T>(operation: () => Promise<T>, config: TimeoutConfig): Promise<TimeoutResult<T>>;
-    /**
-     * Execute single operation with timeout
-     */
-    private performSingleOperation;
-    /**
-     * Execute operation with abort signal support
-     */
-    private executeWithAbortSignal;
-    /**
-     * Get timeout in milliseconds from config
-     */
-    private getTimeoutMs;
-    /**
-     * Generate unique operation ID
-     */
-    private generateOperationId;
-    /**
-     * Cleanup specific operation
-     */
-    cleanup(operationId: string): void;
-    /**
-     * Cleanup all active timeouts (call on shutdown)
-     */
-    cleanupAll(): void;
-    /**
-     * Get current active timeout count (for debugging)
-     */
-    getActiveTimeoutCount(): number;
-    /**
-     * Create a timeout wrapper for child process operations
-     */
-    wrapChildProcess<T>(processFactory: () => Promise<T>, config: TimeoutConfig): Promise<TimeoutResult<T>>;
-    /**
-     * Create a timeout wrapper for MCP server operations
-     */
-    wrapMCPOperation<T>(operation: () => Promise<T>, operationName: string, timeoutMs?: number): Promise<TimeoutResult<T>>;
-    /**
-     * Create a timeout wrapper for CLI operations
-     */
-    wrapCLIOperation<T>(operation: () => Promise<T>, operationName: string, timeoutMs?: number): Promise<TimeoutResult<T>>;
-}
-export declare function createTimeoutManager(): TimeoutManager;
-export declare function getDefaultTimeoutManager(): TimeoutManager;
-export declare const defaultTimeoutManager: TimeoutManager;

package/dist/lib/utils/timeout-manager.js

@@ -1,244 +0,0 @@
-/**
- * Centralized Timeout Manager for NeuroLink
- *
- * Provides consistent timeout handling across all operations with proper cleanup,
- * abort controller integration, and graceful degradation.
- */
-import { parseTimeout, TimeoutError, DEFAULT_TIMEOUTS } from "./timeout.js";
-/**
- * Enhanced timeout manager with proper cleanup and abort controller integration
- */
-export class TimeoutManager {
-    activeTimeouts = new Map();
-    /**
-     * Execute operation with timeout and proper cleanup
-     */
-    async executeWithTimeout(operation, config) {
-        const startTime = Date.now();
-        const operationId = this.generateOperationId(config.operation);
-        let retriesUsed = 0;
-        const maxRetries = config.retryOnTimeout ? (config.maxRetries ?? 1) : 0;
-        while (retriesUsed <= maxRetries) {
-            try {
-                const result = await this.performSingleOperation(operation, config, operationId);
-                return {
-                    success: true,
-                    data: result,
-                    timedOut: false,
-                    executionTime: Date.now() - startTime,
-                    retriesUsed,
-                };
-            }
-            catch (error) {
-                // Clean up any active timeouts for this operation
-                this.cleanup(operationId);
-                if (error instanceof TimeoutError && retriesUsed < maxRetries) {
-                    retriesUsed++;
-                    continue;
-                }
-                return {
-                    success: false,
-                    error: error instanceof Error ? error : new Error(String(error)),
-                    timedOut: error instanceof TimeoutError,
-                    executionTime: Date.now() - startTime,
-                    retriesUsed,
-                };
-            }
-        }
-        // This should never be reached, but TypeScript needs it
-        return {
-            success: false,
-            error: new Error("Maximum retries exceeded"),
-            timedOut: true,
-            executionTime: Date.now() - startTime,
-            retriesUsed,
-        };
-    }
-    /**
-     * Execute single operation with timeout
-     */
-    async performSingleOperation(operation, config, operationId) {
-        const timeoutMs = this.getTimeoutMs(config);
-        if (!timeoutMs) {
-            // No timeout specified, execute directly
-            return await operation();
-        }
-        // Create abort controller for this operation
-        const controller = new AbortController();
-        const existingSignal = config.abortSignal;
-        // Merge with existing abort signal if provided
-        if (existingSignal) {
-            existingSignal.addEventListener("abort", () => {
-                controller.abort(existingSignal.reason);
-            });
-            if (existingSignal.aborted) {
-                throw new Error("Operation aborted before execution");
-            }
-        }
-        // Set up timeout
-        const timer = setTimeout(() => {
-            controller.abort(new TimeoutError(`Operation '${config.operation}' timed out after ${timeoutMs}ms`, timeoutMs, "timeout-manager", "generate"));
-        }, timeoutMs);
-        // Cleanup function
-        const cleanup = () => {
-            clearTimeout(timer);
-            this.activeTimeouts.delete(operationId);
-        };
-        // Store active timeout for potential cleanup
-        this.activeTimeouts.set(operationId, {
-            timer,
-            controller,
-            cleanup,
-        });
-        try {
-            // Execute operation with abort signal
-            const result = await this.executeWithAbortSignal(operation, controller.signal);
-            cleanup();
-            return result;
-        }
-        catch (error) {
-            cleanup();
-            // Convert abort errors to timeout errors if appropriate
-            if (error instanceof Error && error.name === "AbortError") {
-                throw new TimeoutError(`Operation '${config.operation}' was aborted`, timeoutMs, "timeout-manager", "generate");
-            }
-            throw error;
-        }
-    }
-    /**
-     * Execute operation with abort signal support
-     */
-    async executeWithAbortSignal(operation, signal) {
-        // Check if already aborted
-        if (signal.aborted) {
-            throw new Error("Operation aborted");
-        }
-        // Race between operation and abort signal
-        return new Promise((resolve, reject) => {
-            // Listen for abort
-            signal.addEventListener("abort", () => {
-                reject(signal.reason || new Error("Operation aborted"));
-            });
-            // Execute operation
-            operation().then(resolve).catch(reject);
-        });
-    }
-    /**
-     * Get timeout in milliseconds from config
-     */
-    getTimeoutMs(config) {
-        if (config.timeout !== undefined) {
-            return parseTimeout(config.timeout);
-        }
-        // Use default timeout based on operation type
-        const operation = config.operation.toLowerCase();
-        // MCP operations
-        if (operation.includes("mcp") || operation.includes("server")) {
-            return parseTimeout(DEFAULT_TIMEOUTS.tools.network);
-        }
-        // File operations
-        if (operation.includes("file") ||
-            operation.includes("read") ||
-            operation.includes("write")) {
-            return parseTimeout(DEFAULT_TIMEOUTS.tools.filesystem);
-        }
-        // Network operations
-        if (operation.includes("network") ||
-            operation.includes("http") ||
-            operation.includes("fetch")) {
-            return parseTimeout(DEFAULT_TIMEOUTS.tools.network);
-        }
-        // Default
-        return parseTimeout(DEFAULT_TIMEOUTS.tools.default);
-    }
-    /**
-     * Generate unique operation ID
-     */
-    generateOperationId(operation) {
-        return `${operation}-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
-    }
-    /**
-     * Cleanup specific operation
-     */
-    cleanup(operationId) {
-        const timeout = this.activeTimeouts.get(operationId);
-        if (timeout) {
-            timeout.cleanup();
-        }
-    }
-    /**
-     * Cleanup all active timeouts (call on shutdown)
-     */
-    cleanupAll() {
-        for (const [id, timeout] of this.activeTimeouts) {
-            timeout.cleanup();
-        }
-        this.activeTimeouts.clear();
-    }
-    /**
-     * Get current active timeout count (for debugging)
-     */
-    getActiveTimeoutCount() {
-        return this.activeTimeouts.size;
-    }
-    /**
-     * Create a timeout wrapper for child process operations
-     */
-    wrapChildProcess(processFactory, config) {
-        return this.executeWithTimeout(processFactory, {
-            ...config,
-            gracefulShutdown: true,
-            timeout: config.timeout || DEFAULT_TIMEOUTS.tools.network,
-        });
-    }
-    /**
-     * Create a timeout wrapper for MCP server operations
-     */
-    wrapMCPOperation(operation, operationName, timeoutMs) {
-        return this.executeWithTimeout(operation, {
-            operation: `mcp-${operationName}`,
-            timeout: timeoutMs || parseTimeout(DEFAULT_TIMEOUTS.tools.network),
-            retryOnTimeout: false,
-            gracefulShutdown: true,
-        });
-    }
-    /**
-     * Create a timeout wrapper for CLI operations
-     */
-    wrapCLIOperation(operation, operationName, timeoutMs) {
-        return this.executeWithTimeout(operation, {
-            operation: `cli-${operationName}`,
-            timeout: timeoutMs || 120000, // 2 minutes default for CLI
-            retryOnTimeout: false,
-            gracefulShutdown: true,
-        });
-    }
-}
-// Factory function to create a new TimeoutManager instance
-export function createTimeoutManager() {
-    return new TimeoutManager();
-}
-// Lazy-loaded default timeout manager instance
-let _defaultTimeoutManager = null;
-export function getDefaultTimeoutManager() {
-    if (!_defaultTimeoutManager) {
-        _defaultTimeoutManager = createTimeoutManager();
-    }
-    return _defaultTimeoutManager;
-}
-// Export default instance for backwards compatibility
-export const defaultTimeoutManager = getDefaultTimeoutManager();
-// Cleanup on process exit
-if (typeof process !== "undefined") {
-    process.once("exit", () => {
-        getDefaultTimeoutManager().cleanupAll();
-    });
-    process.once("SIGINT", () => {
-        getDefaultTimeoutManager().cleanupAll();
-        process.exit(0);
-    });
-    process.once("SIGTERM", () => {
-        getDefaultTimeoutManager().cleanupAll();
-        process.exit(0);
-    });
-}