@juspay/neurolink 3.0.1 → 4.0.0

package/dist/telemetry/telemetry-service.js

@@ -0,0 +1,261 @@
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { metrics, trace } from "@opentelemetry/api";
+import { getNodeAutoInstrumentations } from "@opentelemetry/auto-instrumentations-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { OTLPMetricExporter } from "@opentelemetry/exporter-metrics-otlp-http";
+import { Resource } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION, } from "@opentelemetry/semantic-conventions";
+import { PeriodicExportingMetricReader } from "@opentelemetry/sdk-metrics";
+export class TelemetryService {
+    static instance;
+    sdk;
+    enabled = false;
+    meter;
+    tracer;
+    // Optional Metrics (only created when enabled)
+    aiRequestCounter;
+    aiRequestDuration;
+    aiTokensUsed;
+    aiProviderErrors;
+    mcpToolCalls;
+    connectionCounter;
+    responseTimeHistogram;
+    constructor() {
+        // Check if telemetry is enabled
+        this.enabled = this.isTelemetryEnabled();
+        if (this.enabled) {
+            this.initializeTelemetry();
+        }
+        else {
+            console.log("[Telemetry] Disabled - set NEUROLINK_TELEMETRY_ENABLED=true or configure OTEL_EXPORTER_OTLP_ENDPOINT to enable");
+        }
+    }
+    static getInstance() {
+        if (!TelemetryService.instance) {
+            TelemetryService.instance = new TelemetryService();
+        }
+        return TelemetryService.instance;
+    }
+    isTelemetryEnabled() {
+        return (process.env.NEUROLINK_TELEMETRY_ENABLED === "true" ||
+            process.env.OTEL_EXPORTER_OTLP_ENDPOINT !== undefined);
+    }
+    initializeTelemetry() {
+        try {
+            const resource = new Resource({
+                [ATTR_SERVICE_NAME]: process.env.OTEL_SERVICE_NAME || "neurolink-ai",
+                [ATTR_SERVICE_VERSION]: process.env.OTEL_SERVICE_VERSION || "3.0.1",
+            });
+            this.sdk = new NodeSDK({
+                resource,
+                traceExporter: new OTLPTraceExporter({
+                    url: process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ||
+                        `${process.env.OTEL_EXPORTER_OTLP_ENDPOINT}/v1/traces`,
+                }),
+                // Note: Metric reader configured separately
+                instrumentations: [getNodeAutoInstrumentations()],
+            });
+            this.meter = metrics.getMeter("neurolink-ai");
+            this.tracer = trace.getTracer("neurolink-ai");
+            this.initializeMetrics();
+            console.log("[Telemetry] Initialized with endpoint:", process.env.OTEL_EXPORTER_OTLP_ENDPOINT);
+        }
+        catch (error) {
+            console.error("[Telemetry] Failed to initialize:", error);
+            this.enabled = false;
+        }
+    }
+    initializeMetrics() {
+        if (!this.enabled || !this.meter) {
+            return;
+        }
+        this.aiRequestCounter = this.meter.createCounter("ai_requests_total", {
+            description: "Total number of AI requests",
+        });
+        this.aiRequestDuration = this.meter.createHistogram("ai_request_duration_ms", {
+            description: "AI request duration in milliseconds",
+        });
+        this.aiTokensUsed = this.meter.createCounter("ai_tokens_used_total", {
+            description: "Total number of AI tokens used",
+        });
+        this.aiProviderErrors = this.meter.createCounter("ai_provider_errors_total", {
+            description: "Total number of AI provider errors",
+        });
+        this.mcpToolCalls = this.meter.createCounter("mcp_tool_calls_total", {
+            description: "Total number of MCP tool calls",
+        });
+        this.connectionCounter = this.meter.createCounter("connections_total", {
+            description: "Total number of connections",
+        });
+        this.responseTimeHistogram = this.meter.createHistogram("response_time_ms", {
+            description: "Response time in milliseconds",
+        });
+    }
+    async initialize() {
+        if (!this.enabled) {
+            return;
+        }
+        try {
+            await this.sdk?.start();
+            console.log("[Telemetry] SDK started successfully");
+        }
+        catch (error) {
+            console.error("[Telemetry] Failed to start SDK:", error);
+            this.enabled = false;
+        }
+    }
+    // AI Operation Tracing (NO-OP when disabled)
+    async traceAIRequest(provider, operation) {
+        if (!this.enabled || !this.tracer) {
+            return await operation(); // Direct execution when disabled
+        }
+        const span = this.tracer.startSpan(`ai.${provider}.generate_text`, {
+            attributes: {
+                "ai.provider": provider,
+                "ai.operation": "generate_text",
+            },
+        });
+        try {
+            const result = await operation();
+            span.setStatus({ code: 1 }); // OK
+            return result;
+        }
+        catch (error) {
+            span.setStatus({
+                code: 2,
+                message: error instanceof Error ? error.message : "Unknown error",
+            }); // ERROR
+            span.recordException(error);
+            throw error;
+        }
+        finally {
+            span.end();
+        }
+    }
+    // Metrics Recording (NO-OP when disabled)
+    recordAIRequest(provider, model, tokens, duration) {
+        if (!this.enabled || !this.aiRequestCounter) {
+            return;
+        }
+        const labels = { provider, model };
+        this.aiRequestCounter.add(1, labels);
+        this.aiRequestDuration?.record(duration, labels);
+        this.aiTokensUsed?.add(tokens, labels);
+    }
+    recordAIError(provider, error) {
+        if (!this.enabled || !this.aiProviderErrors) {
+            return;
+        }
+        this.aiProviderErrors.add(1, {
+            provider,
+            error: error.name,
+            message: error.message.substring(0, 100), // Limit message length
+        });
+    }
+    recordMCPToolCall(toolName, duration, success) {
+        if (!this.enabled || !this.mcpToolCalls) {
+            return;
+        }
+        this.mcpToolCalls.add(1, {
+            tool: toolName,
+            success: success.toString(),
+            duration_bucket: this.getDurationBucket(duration),
+        });
+    }
+    recordConnection(type) {
+        if (!this.enabled || !this.connectionCounter) {
+            return;
+        }
+        this.connectionCounter.add(1, { connection_type: type });
+    }
+    recordResponseTime(endpoint, method, duration) {
+        if (!this.enabled || !this.responseTimeHistogram) {
+            return;
+        }
+        this.responseTimeHistogram.record(duration, {
+            endpoint,
+            method,
+            status_bucket: this.getStatusBucket(duration),
+        });
+    }
+    // Custom Metrics
+    recordCustomMetric(name, value, labels) {
+        if (!this.enabled || !this.meter) {
+            return;
+        }
+        const counter = this.meter.createCounter(`custom_${name}`, {
+            description: `Custom metric: ${name}`,
+        });
+        counter.add(value, labels || {});
+    }
+    recordCustomHistogram(name, value, labels) {
+        if (!this.enabled || !this.meter) {
+            return;
+        }
+        const histogram = this.meter.createHistogram(`custom_${name}_histogram`, {
+            description: `Custom histogram: ${name}`,
+        });
+        histogram.record(value, labels || {});
+    }
+    // Health Checks
+    async getHealthMetrics() {
+        const memoryUsage = process.memoryUsage();
+        return {
+            timestamp: Date.now(),
+            memoryUsage,
+            uptime: process.uptime(),
+            activeConnections: 0, // Would need to be provided by calling code
+            errorRate: 0, // Would need to be calculated from metrics
+            averageResponseTime: 0, // Would need to be calculated from metrics
+        };
+    }
+    // Telemetry Status
+    isEnabled() {
+        return this.enabled;
+    }
+    getStatus() {
+        return {
+            enabled: this.enabled,
+            endpoint: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+            service: process.env.OTEL_SERVICE_NAME || "neurolink-ai",
+            version: process.env.OTEL_SERVICE_VERSION || "3.0.1",
+        };
+    }
+    // Helper methods
+    getDurationBucket(duration) {
+        if (duration < 100) {
+            return "fast";
+        }
+        if (duration < 500) {
+            return "medium";
+        }
+        if (duration < 1000) {
+            return "slow";
+        }
+        return "very_slow";
+    }
+    getStatusBucket(duration) {
+        if (duration < 200) {
+            return "excellent";
+        }
+        if (duration < 500) {
+            return "good";
+        }
+        if (duration < 1000) {
+            return "acceptable";
+        }
+        return "poor";
+    }
+    // Cleanup
+    async shutdown() {
+        if (this.enabled && this.sdk) {
+            try {
+                await this.sdk.shutdown();
+                console.log("[Telemetry] SDK shutdown completed");
+            }
+            catch (error) {
+                console.error("[Telemetry] Error during shutdown:", error);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,67 @@
+/**
+ * Phase 2: Enhanced Streaming Infrastructure
+ * Streaming utilities for progress tracking and metadata enhancement
+ */
+import type { StreamingProgressData, StreamingMetadata, ProgressCallback, EnhancedStreamTextOptions } 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 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: 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/utils/streaming-utils.js

@@ -0,0 +1,201 @@
+/**
+ * Phase 2: Enhanced Streaming Infrastructure
+ * Streaming utilities for progress tracking and metadata enhancement
+ */
+/**
+ * Enhanced streaming utilities for progress tracking and metadata
+ */
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "3.0.1",
+  "version": "4.0.0",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, and professional CLI. Built-in tools operational, 58+ external MCP servers discoverable. Connect to filesystem, GitHub, database operations, and more. Build, test, and deploy AI applications with 9 major providers: OpenAI, Anthropic, Google AI, AWS Bedrock, Azure, Hugging Face, Ollama, and Mistral AI.",
   "author": {
     "name": "Juspay Technologies",
@@ -132,16 +132,32 @@
     "@google/generative-ai": "^0.24.1",
     "@huggingface/inference": "^2.8.0",
     "@modelcontextprotocol/sdk": "^1.13.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/auto-instrumentations-node": "^0.52.1",
+    "@opentelemetry/exporter-logs-otlp-http": "^0.54.2",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.54.2",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.54.2",
+    "@opentelemetry/instrumentation-fetch": "^0.54.2",
+    "@opentelemetry/instrumentation-http": "^0.54.2",
+    "@opentelemetry/propagator-b3": "^1.30.1",
+    "@opentelemetry/resource-detector-aws": "^1.12.0",
+    "@opentelemetry/resources": "^1.30.1",
+    "@opentelemetry/sdk-logs": "^0.54.2",
+    "@opentelemetry/sdk-metrics": "^1.30.1",
+    "@opentelemetry/sdk-node": "^0.54.2",
+    "@opentelemetry/semantic-conventions": "^1.34.0",
+    "@types/ws": "^8.18.1",
     "ai": "^4.0.0",
     "chalk": "^5.3.0",
     "cors": "^2.8.5",
     "dotenv": "^16.5.0",
     "express": "^5.1.0",
     "inquirer": "^9.2.15",
-    "undici": "^6.6.2",
     "ora": "^7.0.1",
     "playwright": "^1.52.0",
+    "undici": "^6.6.2",
     "uuid": "^11.1.0",
+    "ws": "^8.18.3",
     "yargs": "^17.7.2",
     "zod": "^3.22.0",
     "zod-to-json-schema": "^3.24.5"