@juspay/neurolink 7.1.0 → 7.3.0

package/dist/lib/core/streamAnalytics.js

@@ -0,0 +1,125 @@
+import { createAnalytics } from "./analytics.js";
+import { logger } from "../utils/logger.js";
+/**
+ * Base implementation for collecting analytics from Vercel AI SDK stream results
+ */
+export class BaseStreamAnalyticsCollector {
+    /**
+     * Collect token usage from stream result
+     */
+    async collectUsage(result) {
+        try {
+            const usage = await result.usage;
+            if (!usage) {
+                logger.debug("No usage data available from stream result");
+                return {
+                    inputTokens: 0,
+                    outputTokens: 0,
+                    totalTokens: 0,
+                };
+            }
+            return {
+                inputTokens: usage.promptTokens || 0,
+                outputTokens: usage.completionTokens || 0,
+                totalTokens: usage.totalTokens ||
+                    (usage.promptTokens || 0) + (usage.completionTokens || 0),
+            };
+        }
+        catch (error) {
+            logger.warn("Failed to collect usage from stream result", { error });
+            return {
+                inputTokens: 0,
+                outputTokens: 0,
+                totalTokens: 0,
+            };
+        }
+    }
+    /**
+     * Collect response metadata from stream result
+     */
+    async collectMetadata(result) {
+        try {
+            const [response, finishReason] = await Promise.all([
+                result.response,
+                result.finishReason,
+            ]);
+            return {
+                id: response?.id,
+                model: response?.model,
+                timestamp: response?.timestamp instanceof Date
+                    ? response.timestamp.getTime()
+                    : response?.timestamp || Date.now(),
+                finishReason: finishReason,
+            };
+        }
+        catch (error) {
+            logger.warn("Failed to collect metadata from stream result", { error });
+            const finishReason = await result.finishReason.catch(() => "error");
+            return {
+                timestamp: Date.now(),
+                finishReason: finishReason,
+            };
+        }
+    }
+    /**
+     * Create comprehensive analytics from stream result
+     */
+    async createAnalytics(provider, model, result, responseTime, metadata) {
+        try {
+            // Collect analytics data in parallel
+            const [usage, responseMetadata] = await Promise.all([
+                this.collectUsage(result),
+                this.collectMetadata(result),
+            ]);
+            // Get final text content and finish reason
+            const [content, finishReason, toolResults, toolCalls] = await Promise.all([
+                result.text,
+                result.finishReason,
+                result.toolResults || Promise.resolve([]),
+                result.toolCalls || Promise.resolve([]),
+            ]);
+            // Create comprehensive analytics
+            return createAnalytics(provider, model, {
+                usage,
+                content,
+                response: responseMetadata,
+                finishReason: finishReason,
+                toolResults: toolResults,
+                toolCalls: toolCalls,
+            }, responseTime, {
+                ...metadata,
+                streamingMode: true,
+                responseId: responseMetadata.id,
+                finishReason: finishReason,
+            });
+        }
+        catch (error) {
+            logger.error("Failed to create analytics from stream result", {
+                provider,
+                model,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Return minimal analytics on error
+            return createAnalytics(provider, model, { usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 } }, responseTime, {
+                ...metadata,
+                streamingMode: true,
+                analyticsError: true,
+            });
+        }
+    }
+    /**
+     * Clean up resources and force garbage collection if needed
+     */
+    cleanup() {
+        // Only force garbage collection if memory usage exceeds 500 MB
+        const heapUsed = process.memoryUsage().heapUsed;
+        const GC_THRESHOLD = 500 * 1024 * 1024; // 500 MB
+        if (typeof global !== "undefined" && global.gc && heapUsed > GC_THRESHOLD) {
+            global.gc();
+        }
+    }
+}
+/**
+ * Global instance of stream analytics collector
+ */
+export const streamAnalyticsCollector = new BaseStreamAnalyticsCollector();

package/dist/lib/models/modelRegistry.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Model Registry for NeuroLink CLI Commands
+ * Provides centralized model data for models command system
+ * Part of Phase 4.1 - Models Command System
+ */
+import { AIProviderName } from "../core/types.js";
+import type { JsonValue } from "../types/common.js";
+/**
+ * Model capabilities interface
+ */
+export interface ModelCapabilities {
+    vision: boolean;
+    functionCalling: boolean;
+    codeGeneration: boolean;
+    reasoning: boolean;
+    multimodal: boolean;
+    streaming: boolean;
+    jsonMode: boolean;
+}
+/**
+ * Model pricing information
+ */
+export interface ModelPricing {
+    inputCostPer1K: number;
+    outputCostPer1K: number;
+    currency: string;
+}
+/**
+ * Model performance characteristics
+ */
+export interface ModelPerformance {
+    speed: "fast" | "medium" | "slow";
+    quality: "high" | "medium" | "low";
+    accuracy: "high" | "medium" | "low";
+}
+/**
+ * Model limitations and constraints
+ */
+export interface ModelLimits {
+    maxContextTokens: number;
+    maxOutputTokens: number;
+    maxRequestsPerMinute?: number;
+    maxRequestsPerDay?: number;
+}
+/**
+ * Use case suitability scores (1-10 scale)
+ */
+export interface UseCaseSuitability {
+    coding: number;
+    creative: number;
+    analysis: number;
+    conversation: number;
+    reasoning: number;
+    translation: number;
+    summarization: number;
+}
+/**
+ * Complete model information
+ */
+export interface ModelInfo {
+    id: string;
+    name: string;
+    provider: AIProviderName;
+    description: string;
+    capabilities: ModelCapabilities;
+    pricing: ModelPricing;
+    performance: ModelPerformance;
+    limits: ModelLimits;
+    useCases: UseCaseSuitability;
+    aliases: string[];
+    deprecated: boolean;
+    isLocal: boolean;
+    releaseDate?: string;
+    category: "general" | "coding" | "creative" | "vision" | "reasoning";
+}
+/**
+ * Model search filters
+ */
+export interface ModelSearchFilters {
+    provider?: AIProviderName | AIProviderName[];
+    capability?: keyof ModelCapabilities | (keyof ModelCapabilities)[];
+    useCase?: keyof UseCaseSuitability;
+    maxCost?: number;
+    minContextSize?: number;
+    maxContextSize?: number;
+    performance?: ModelPerformance["speed"] | ModelPerformance["quality"];
+    category?: ModelInfo["category"] | ModelInfo["category"][];
+}
+/**
+ * Model search result with ranking
+ */
+export interface ModelSearchResult {
+    model: ModelInfo;
+    score: number;
+    matchReasons: string[];
+}
+/**
+ * Comprehensive model registry
+ */
+export declare const MODEL_REGISTRY: Record<string, ModelInfo>;
+/**
+ * Model aliases registry for quick resolution
+ */
+export declare const MODEL_ALIASES: Record<string, string>;
+/**
+ * Use case to model mappings
+ */
+export declare const USE_CASE_RECOMMENDATIONS: Record<string, string[]>;
+/**
+ * Get all models
+ */
+export declare function getAllModels(): ModelInfo[];
+/**
+ * Get model by ID
+ */
+export declare function getModelById(id: string): ModelInfo | undefined;
+/**
+ * Get models by provider
+ */
+export declare function getModelsByProvider(provider: AIProviderName): ModelInfo[];
+/**
+ * Get available providers
+ */
+export declare function getAvailableProviders(): AIProviderName[];
+/**
+ * Calculate estimated cost for a request
+ */
+export declare function calculateCost(model: ModelInfo, inputTokens: number, outputTokens: number): number;
+/**
+ * Format model for display
+ */
+export declare function formatModelForDisplay(model: ModelInfo): JsonValue;