@juspay/neurolink 9.32.0 → 9.32.1

package/dist/client/utils/modelAliasResolver.js

@@ -1,54 +0,0 @@
-/**
- * NL-004: Model alias/deprecation resolver.
- *
- * Resolves model names against an alias configuration map and applies the
- * configured action (warn, redirect, or block).
- */
-import { ErrorCategory, ErrorSeverity } from "../constants/enums.js";
-import { NeuroLinkError } from "./errorHandling.js";
-import { logger } from "./logger.js";
-/**
- * Resolve model aliases/deprecations.
- * Checks the model name against the alias map and applies the configured action.
- *
- * @param model - The requested model name (may be undefined).
- * @param config - The alias configuration containing model mappings.
- * @returns The resolved model name (original or redirected).
- * @throws {NeuroLinkError} When the alias action is "block".
- */
-export function resolveModel(model, config) {
-    if (!model || !config?.aliases) {
-        return model;
-    }
-    const alias = config.aliases[model];
-    if (!alias) {
-        return model;
-    }
-    switch (alias.action) {
-        case "block":
-            throw new NeuroLinkError({
-                code: "MODEL_DEPRECATED",
-                message: `Model '${model}' is blocked. ${alias.reason || `Use '${alias.target}' instead.`}`,
-                category: ErrorCategory.VALIDATION,
-                severity: ErrorSeverity.HIGH,
-                retriable: false,
-                context: {
-                    requestedModel: model,
-                    suggestedModel: alias.target,
-                    reason: alias.reason,
-                },
-            });
-        case "warn":
-            logger.warn(`[ModelAlias] Model '${model}' is deprecated. ${alias.reason || `Redirecting to '${alias.target}'.`}`, {
-                requestedModel: model,
-                targetModel: alias.target,
-                reason: alias.reason,
-            });
-            return alias.target;
-        case "redirect":
-            logger.debug(`[ModelAlias] Redirecting model '${model}' to '${alias.target}'`);
-            return alias.target;
-        default:
-            return model;
-    }
-}

package/dist/client/utils/modelDetection.js

@@ -1,80 +0,0 @@
-/**
- * Model detection utilities for capability checking
- */
-/**
- * Check if model name is valid for detection functions
- */
-function isValidModelName(modelName) {
-    return typeof modelName === "string" && modelName.length > 0;
-}
-export function isGemini3Model(modelName) {
-    if (!isValidModelName(modelName)) {
-        return false;
-    }
-    return /^gemini-3(\.\d+)?(-.*)?$/i.test(modelName);
-}
-export function isGemini25Model(modelName) {
-    if (!isValidModelName(modelName)) {
-        return false;
-    }
-    return /^gemini-2\.5(-.*)?$/i.test(modelName);
-}
-export function supportsThinkingConfig(modelName) {
-    if (!isValidModelName(modelName)) {
-        return false;
-    }
-    const thinkingModels = [
-        /^gemini-3/i,
-        /^gemini-2\.5-pro/i,
-        /^gemini-2\.5-flash/i,
-    ];
-    return thinkingModels.some((pattern) => pattern.test(modelName));
-}
-export function supportsPromptCaching(modelName) {
-    if (!isValidModelName(modelName)) {
-        return false;
-    }
-    const cachingModels = [
-        /^gemini-3/i,
-        /^gemini-2\.5/i,
-        /^gpt-4/i,
-        /^claude-3/i,
-    ];
-    return cachingModels.some((pattern) => pattern.test(modelName));
-}
-export function getMaxThinkingBudgetTokens(modelName) {
-    if (!isValidModelName(modelName)) {
-        return 10000;
-    }
-    if (/^gemini-3(\.\d+)?-pro/i.test(modelName)) {
-        return 100000;
-    }
-    if (/^gemini-3(\.\d+)?-flash/i.test(modelName)) {
-        return 50000;
-    }
-    if (/^gemini-2\.5/i.test(modelName)) {
-        return 32000;
-    }
-    return 10000;
-}
-export function getModelFamily(modelName) {
-    if (!isValidModelName(modelName)) {
-        return "unknown";
-    }
-    if (/^gemini-3/i.test(modelName)) {
-        return "gemini-3";
-    }
-    if (/^gemini-2\.5/i.test(modelName)) {
-        return "gemini-2.5";
-    }
-    if (/^gemini-2/i.test(modelName)) {
-        return "gemini-2";
-    }
-    if (/^gpt-4/i.test(modelName)) {
-        return "gpt-4";
-    }
-    if (/^claude-3/i.test(modelName)) {
-        return "claude-3";
-    }
-    return "unknown";
-}

package/dist/client/utils/modelRouter.js

@@ -1,292 +0,0 @@
-/**
- * Model Router for NeuroLink Orchestration
- * Routes tasks to optimal models based on classification and requirements
- */
-import { logger } from "./logger.js";
-import { BinaryTaskClassifier } from "./taskClassifier.js";
-import { redactForRouting } from "./promptRedaction.js";
-/**
- * Routing configuration constants
- */
-const ROUTING_CONFIG = {
-    minRouteConfidence: 0.3,
-    maxRouteConfidence: 0.95,
-    confidenceBoost: 0.1,
-};
-/**
- * Model configurations for different task types and providers
- */
-const MODEL_CONFIGS = {
-    fast: {
-        primary: {
-            provider: "vertex",
-            model: "gemini-2.5-flash",
-            capabilities: ["speed", "general", "code", "basic-reasoning"],
-            avgResponseTime: 800,
-            costPerToken: 0.0001,
-            reasoning: "Optimized for speed and efficiency via Vertex AI",
-        },
-        fallback: {
-            provider: "vertex",
-            model: "claude-haiku-4-5@20251001",
-            capabilities: ["speed", "general", "basic-reasoning"],
-            avgResponseTime: 1200,
-            costPerToken: 0.0002,
-            reasoning: "Vertex AI Claude Haiku fallback",
-        },
-    },
-    reasoning: {
-        primary: {
-            provider: "vertex",
-            model: "claude-sonnet-4-5@20250929",
-            capabilities: [
-                "reasoning",
-                "analysis",
-                "complex-logic",
-                "code",
-                "creativity",
-            ],
-            avgResponseTime: 3000,
-            costPerToken: 0.003,
-            reasoning: "Advanced reasoning and analysis via Claude Sonnet 4-5 on Vertex AI",
-        },
-        fallback: {
-            provider: "vertex",
-            model: "claude-opus-4-5@20251101",
-            capabilities: [
-                "reasoning",
-                "analysis",
-                "complex-logic",
-                "code",
-                "creativity",
-                "agentic",
-            ],
-            avgResponseTime: 4000,
-            costPerToken: 0.005,
-            reasoning: "Claude Opus 4-5 fallback on Vertex AI for most complex tasks",
-        },
-    },
-};
-/**
- * Model Router
- * Intelligently routes tasks to optimal models based on classification
- */
-export class ModelRouter {
-    /**
-     * Route a prompt to the optimal model configuration
-     */
-    static route(prompt, options = {}) {
-        const startTime = Date.now();
-        // 1. Classify the task if not overridden
-        let classification;
-        if (options.forceTaskType) {
-            classification = {
-                type: options.forceTaskType,
-                confidence: ROUTING_CONFIG.maxRouteConfidence, // Use maxRouteConfidence instead of 1.0
-                reasoning: "forced task type",
-            };
-        }
-        else {
-            classification = BinaryTaskClassifier.classify(prompt);
-        }
-        // 2. Apply special requirements
-        let taskType = classification.type;
-        const reasons = [classification.reasoning];
-        if (options.requireFast) {
-            taskType = "fast";
-            reasons.push("speed required");
-        }
-        if (options.requireCapability) {
-            // Check if the capability suggests a specific task type
-            const capability = options.requireCapability.toLowerCase();
-            if (["analysis", "reasoning", "complex", "research"].some((c) => capability.includes(c))) {
-                taskType = "reasoning";
-                reasons.push(`capability: ${capability}`);
-            }
-            else if (["speed", "quick", "fast", "simple"].some((c) => capability.includes(c))) {
-                taskType = "fast";
-                reasons.push(`capability: ${capability}`);
-            }
-        }
-        // 3. Select model configuration
-        const config = MODEL_CONFIGS[taskType];
-        const selectedConfig = config.primary;
-        // 4. Calculate confidence based on multiple factors
-        let confidence = classification.confidence;
-        // Adjust confidence based on prompt characteristics
-        if (taskType === "fast" && prompt.length < 30) {
-            confidence = Math.min(ROUTING_CONFIG.maxRouteConfidence, confidence + ROUTING_CONFIG.confidenceBoost);
-            reasons.push("very short prompt");
-        }
-        if (taskType === "reasoning" && prompt.length > 150) {
-            confidence = Math.min(ROUTING_CONFIG.maxRouteConfidence, confidence + ROUTING_CONFIG.confidenceBoost);
-            reasons.push("detailed prompt");
-        }
-        // Ensure final confidence is within configured bounds
-        confidence = Math.max(ROUTING_CONFIG.minRouteConfidence, Math.min(ROUTING_CONFIG.maxRouteConfidence, confidence));
-        // 5. Create route result
-        const route = {
-            provider: selectedConfig.provider,
-            model: selectedConfig.model,
-            reasoning: reasons.join(", "),
-            confidence,
-        };
-        const routingTime = Date.now() - startTime;
-        logger.debug("Model routing decision", {
-            prompt: redactForRouting(prompt),
-            taskType,
-            route: {
-                provider: route.provider,
-                model: route.model,
-                confidence: route.confidence.toFixed(2),
-            },
-            reasoning: route.reasoning,
-            routingTime: `${routingTime}ms`,
-            options: Object.keys(options).length > 0 ? options : undefined,
-        });
-        return route;
-    }
-    /**
-     * Get fallback route if primary route fails
-     */
-    static getFallbackRoute(prompt, primaryRoute, options = {}) {
-        // Determine fallback strategy
-        let fallbackType;
-        if (options.fallbackStrategy) {
-            if (options.fallbackStrategy === "auto") {
-                // Use opposite of primary for fallback
-                const primaryType = this.getTaskTypeFromRoute(primaryRoute);
-                fallbackType = primaryType === "fast" ? "reasoning" : "fast";
-            }
-            else {
-                fallbackType = options.fallbackStrategy;
-            }
-        }
-        else {
-            // Default: use fallback model of same type
-            fallbackType = this.getTaskTypeFromRoute(primaryRoute);
-        }
-        const config = MODEL_CONFIGS[fallbackType];
-        const fallbackConfig = config.fallback;
-        const route = {
-            provider: fallbackConfig.provider,
-            model: fallbackConfig.model,
-            reasoning: `fallback from ${primaryRoute.provider}/${primaryRoute.model}`,
-            confidence: Math.max(ROUTING_CONFIG.minRouteConfidence, Math.min(ROUTING_CONFIG.maxRouteConfidence, primaryRoute.confidence - 0.2)),
-        };
-        logger.debug("Fallback route selected", {
-            originalRoute: `${primaryRoute.provider}/${primaryRoute.model}`,
-            fallbackRoute: `${route.provider}/${route.model}`,
-            fallbackType,
-            strategy: options.fallbackStrategy || "default",
-        });
-        return route;
-    }
-    /**
-     * Determine task type from a model route
-     */
-    static getTaskTypeFromRoute(route) {
-        // Check which config matches this route
-        for (const [taskType, config] of Object.entries(MODEL_CONFIGS)) {
-            if (config.primary.provider === route.provider &&
-                config.primary.model === route.model) {
-                return taskType;
-            }
-            if (config.fallback.provider === route.provider &&
-                config.fallback.model === route.model) {
-                return taskType;
-            }
-        }
-        // Default fallback based on model name patterns
-        if (route.model.includes("flash") || route.model.includes("mini")) {
-            return "fast";
-        }
-        return "reasoning";
-    }
-    /**
-     * Get all available model configurations
-     */
-    static getAvailableModels() {
-        return MODEL_CONFIGS;
-    }
-    /**
-     * Validate model availability for a given route
-     */
-    static async validateRoute(route) {
-        try {
-            // This would typically check provider availability
-            // For now, just validate the configuration exists
-            const configs = Object.values(MODEL_CONFIGS).flatMap((config) => [
-                config.primary,
-                config.fallback,
-            ]);
-            return configs.some((config) => config.provider === route.provider && config.model === route.model);
-        }
-        catch (error) {
-            logger.error("Route validation failed", {
-                route,
-                error: error instanceof Error ? error.message : String(error),
-            });
-            return false;
-        }
-    }
-    /**
-     * Get routing statistics for multiple prompts
-     */
-    static getRoutingStats(prompts) {
-        const routes = prompts.map((prompt) => this.route(prompt));
-        // Handle empty prompts array to avoid divide-by-zero
-        if (routes.length === 0) {
-            const stats = {
-                total: 0,
-                fastRoutes: 0,
-                reasoningRoutes: 0,
-                averageConfidence: 0,
-                providerDistribution: {},
-            };
-            logger.debug("Routing statistics", stats);
-            return stats;
-        }
-        const stats = {
-            total: routes.length,
-            fastRoutes: routes.filter((r) => {
-                const taskType = this.getTaskTypeFromRoute(r);
-                return taskType === "fast";
-            }).length,
-            reasoningRoutes: routes.filter((r) => {
-                const taskType = this.getTaskTypeFromRoute(r);
-                return taskType === "reasoning";
-            }).length,
-            averageConfidence: routes.reduce((sum, r) => sum + r.confidence, 0) / routes.length,
-            providerDistribution: routes.reduce((dist, r) => {
-                dist[r.provider] = (dist[r.provider] || 0) + 1;
-                return dist;
-            }, {}),
-        };
-        logger.debug("Routing statistics", stats);
-        return stats;
-    }
-    /**
-     * Estimate cost and performance for a route
-     */
-    static getRouteEstimates(route, estimatedTokens = 500) {
-        // Find the config for this route
-        const allConfigs = Object.values(MODEL_CONFIGS).flatMap((config) => [
-            config.primary,
-            config.fallback,
-        ]);
-        const config = allConfigs.find((c) => c.provider === route.provider && c.model === route.model);
-        if (!config) {
-            return {
-                estimatedCost: 0,
-                estimatedResponseTime: 2000,
-                capabilities: [],
-            };
-        }
-        return {
-            estimatedCost: config.costPerToken * estimatedTokens,
-            estimatedResponseTime: config.avgResponseTime,
-            capabilities: [...config.capabilities],
-        };
-    }
-}

package/dist/client/utils/multimodalOptionsBuilder.js

@@ -1,65 +0,0 @@
-/**
- * Builds a normalized multimodal options payload for streaming providers.
- *
- * This utility extracts and normalizes multimodal input fields from StreamOptions
- * into a consistent format that can be consumed by buildMultimodalMessagesArray.
- *
- * @param {StreamOptions} options - Stream options containing:
- *   - input.text: Main text prompt
- *   - input.images: Image files (Buffer | string paths/URLs)
- *   - input.content: Advanced multimodal content array
- *   - input.files: Auto-detected file types
- *   - input.csvFiles: CSV files for tabular data
- *   - input.pdfFiles: PDF documents (Buffer | string paths)
- *   - csvOptions: CSV parsing options
- *   - systemPrompt: System-level instructions
- *   - conversationMessages: Chat history
- *   - temperature: Model temperature (0-1)
- *   - maxTokens: Maximum output tokens
- *   - enableAnalytics: Enable analytics tracking
- *   - enableEvaluation: Enable response evaluation
- *   - context: Additional context data
- * @param {string} providerName - Provider identifier (e.g., "vertex", "openai", "anthropic")
- * @param {string} modelName - Model identifier (e.g., "gemini-2.5-flash", "gpt-4o")
- * @returns {object} Normalized options object with:
- *   - input: { text, images, content, files, csvFiles, pdfFiles }
- *   - csvOptions: CSV processing options
- *   - systemPrompt: System prompt string
- *   - conversationHistory: Message history array
- *   - provider: Provider name
- *   - model: Model name
- *   - temperature: Temperature value
- *   - maxTokens: Token limit
- *   - enableAnalytics: Analytics flag
- *   - enableEvaluation: Evaluation flag
- *   - context: Context data
- *
- * @example
- * ```typescript
- * const opts = buildMultimodalOptions(streamOptions, "vertex", "gemini-2.5-flash");
- * const messages = await buildMultimodalMessagesArray(opts, "vertex", "gemini-2.5-flash");
- * ```
- */
-export function buildMultimodalOptions(options, providerName, modelName) {
-    return {
-        input: {
-            text: options.input?.text || "",
-            images: options.input?.images,
-            content: options.input?.content,
-            files: options.input?.files,
-            csvFiles: options.input?.csvFiles,
-            pdfFiles: options.input?.pdfFiles,
-        },
-        csvOptions: options.csvOptions,
-        systemPrompt: options.systemPrompt,
-        conversationHistory: options.conversationMessages,
-        provider: providerName,
-        model: modelName,
-        temperature: options.temperature,
-        maxTokens: options.maxTokens,
-        enableAnalytics: options.enableAnalytics,
-        enableEvaluation: options.enableEvaluation,
-        context: options.context,
-        fileRegistry: options.fileRegistry,
-    };
-}

package/dist/client/utils/observabilityHelpers.js

@@ -1,47 +0,0 @@
-/**
- * Utility for building observability configs from environment variables
- */
-/**
- * Build observability config from environment variables
- *
- * Reads Langfuse configuration from environment:
- * - LANGFUSE_ENABLED: Enable/disable Langfuse (must be "true")
- * - LANGFUSE_PUBLIC_KEY: Your Langfuse public key (required)
- * - LANGFUSE_SECRET_KEY: Your Langfuse secret key (required)
- * - LANGFUSE_BASE_URL: Langfuse server URL (default: https://cloud.langfuse.com)
- * - LANGFUSE_ENVIRONMENT: Environment name (default: dev)
- * - PUBLIC_APP_VERSION: Release/version identifier (default: v1.0.0)
- *
- * @returns ObservabilityConfig if all required env vars are set, undefined otherwise
- *
- * @example
- * ```typescript
- * import { NeuroLink, buildObservabilityConfigFromEnv } from '@juspay/neurolink';
- *
- * const neurolink = new NeuroLink({
- *   observability: buildObservabilityConfigFromEnv()
- * });
- * ```
- */
-export function buildObservabilityConfigFromEnv() {
-    const langfuseEnabled = process.env.LANGFUSE_ENABLED?.trim().toLowerCase() === "true";
-    const publicKey = process.env.LANGFUSE_PUBLIC_KEY?.trim();
-    const secretKey = process.env.LANGFUSE_SECRET_KEY?.trim();
-    if (!langfuseEnabled || !publicKey || !secretKey) {
-        return undefined;
-    }
-    return {
-        langfuse: {
-            enabled: langfuseEnabled,
-            publicKey,
-            secretKey,
-            baseUrl: process.env.LANGFUSE_BASE_URL?.trim() || "https://cloud.langfuse.com",
-            environment: process.env.LANGFUSE_ENVIRONMENT?.trim() ||
-                process.env.PUBLIC_APP_ENVIRONMENT?.trim() ||
-                "dev",
-            release: process.env.PUBLIC_APP_VERSION?.trim() ||
-                process.env.npm_package_version?.trim() ||
-                "v1.0.0",
-        },
-    };
-}