@juspay/neurolink 7.36.0 → 7.37.1

package/dist/utils/modelRouter.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Model Router for NeuroLink Orchestration
+ * Routes tasks to optimal models based on classification and requirements
+ */
+import type { TaskType } from "../types/taskClassificationTypes.js";
+export interface ModelRoute {
+    provider: string;
+    model: string;
+    reasoning: string;
+    confidence: number;
+}
+export interface ModelRoutingOptions {
+    /** Override the task classification */
+    forceTaskType?: TaskType;
+    /** Require specific performance characteristics */
+    requireFast?: boolean;
+    /** Require specific capability (reasoning, creativity, etc.) */
+    requireCapability?: string;
+    /** Fallback strategy if primary choice fails */
+    fallbackStrategy?: "fast" | "reasoning" | "auto";
+}
+/**
+ * Model configurations for different task types and providers
+ */
+declare const MODEL_CONFIGS: {
+    readonly fast: {
+        readonly primary: {
+            readonly provider: "vertex";
+            readonly model: "gemini-2.5-flash";
+            readonly capabilities: readonly ["speed", "general", "code", "basic-reasoning"];
+            readonly avgResponseTime: 800;
+            readonly costPerToken: 0.0001;
+            readonly reasoning: "Optimized for speed and efficiency via Vertex AI";
+        };
+        readonly fallback: {
+            readonly provider: "vertex";
+            readonly model: "gemini-2.5-pro";
+            readonly capabilities: readonly ["speed", "general", "basic-reasoning"];
+            readonly avgResponseTime: 1200;
+            readonly costPerToken: 0.0002;
+            readonly reasoning: "Vertex AI Gemini Pro fallback";
+        };
+    };
+    readonly reasoning: {
+        readonly primary: {
+            readonly provider: "vertex";
+            readonly model: "claude-sonnet-4@20250514";
+            readonly capabilities: readonly ["reasoning", "analysis", "complex-logic", "code", "creativity"];
+            readonly avgResponseTime: 3000;
+            readonly costPerToken: 0.003;
+            readonly reasoning: "Advanced reasoning and analysis via Claude Sonnet 4 on Vertex AI";
+        };
+        readonly fallback: {
+            readonly provider: "vertex";
+            readonly model: "claude-opus-4@20250514";
+            readonly capabilities: readonly ["reasoning", "analysis", "complex-logic", "code", "creativity", "agentic"];
+            readonly avgResponseTime: 4000;
+            readonly costPerToken: 0.005;
+            readonly reasoning: "Claude Opus 4 fallback on Vertex AI for most complex tasks";
+        };
+    };
+};
+/**
+ * Model Router
+ * Intelligently routes tasks to optimal models based on classification
+ */
+export declare class ModelRouter {
+    /**
+     * Route a prompt to the optimal model configuration
+     */
+    static route(prompt: string, options?: ModelRoutingOptions): ModelRoute;
+    /**
+     * Get fallback route if primary route fails
+     */
+    static getFallbackRoute(prompt: string, primaryRoute: ModelRoute, options?: ModelRoutingOptions): ModelRoute;
+    /**
+     * Determine task type from a model route
+     */
+    private static getTaskTypeFromRoute;
+    /**
+     * Get all available model configurations
+     */
+    static getAvailableModels(): typeof MODEL_CONFIGS;
+    /**
+     * Validate model availability for a given route
+     */
+    static validateRoute(route: ModelRoute): Promise<boolean>;
+    /**
+     * Get routing statistics for multiple prompts
+     */
+    static getRoutingStats(prompts: string[]): {
+        total: number;
+        fastRoutes: number;
+        reasoningRoutes: number;
+        averageConfidence: number;
+        providerDistribution: Record<string, number>;
+    };
+    /**
+     * Estimate cost and performance for a route
+     */
+    static getRouteEstimates(route: ModelRoute, estimatedTokens?: number): {
+        estimatedCost: number;
+        estimatedResponseTime: number;
+        capabilities: string[];
+    };
+}
+export {};

package/dist/utils/modelRouter.js

@@ -0,0 +1,292 @@
+/**
+ * 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, // ms
+            costPerToken: 0.0001,
+            reasoning: "Optimized for speed and efficiency via Vertex AI",
+        },
+        fallback: {
+            provider: "vertex",
+            model: "gemini-2.5-pro",
+            capabilities: ["speed", "general", "basic-reasoning"],
+            avgResponseTime: 1200,
+            costPerToken: 0.0002,
+            reasoning: "Vertex AI Gemini Pro fallback",
+        },
+    },
+    reasoning: {
+        primary: {
+            provider: "vertex",
+            model: "claude-sonnet-4@20250514",
+            capabilities: [
+                "reasoning",
+                "analysis",
+                "complex-logic",
+                "code",
+                "creativity",
+            ],
+            avgResponseTime: 3000, // ms
+            costPerToken: 0.003,
+            reasoning: "Advanced reasoning and analysis via Claude Sonnet 4 on Vertex AI",
+        },
+        fallback: {
+            provider: "vertex",
+            model: "claude-opus-4@20250514",
+            capabilities: [
+                "reasoning",
+                "analysis",
+                "complex-logic",
+                "code",
+                "creativity",
+                "agentic",
+            ],
+            avgResponseTime: 4000,
+            costPerToken: 0.005,
+            reasoning: "Claude Opus 4 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/utils/parameterValidation.js

@@ -192,28 +192,9 @@ export function validateMCPTool(tool) {
     if (execError) {
         errors.push(execError);
     }
-    // Additional MCP-specific validation
-    if (mcpTool.execute) {
-        try {
-            // Test execute function with mock data
-            const mockParams = {};
-            const mockContext = {
-                sessionId: "validation-test",
-                userId: "validation-user",
-            };
-            const result = mcpTool.execute(mockParams, mockContext);
-            const returnsPromise = result && typeof result === "object" && "then" in result;
-            if (!returnsPromise) {
-                errors.push(new ValidationError("Execute function must return a Promise", "execute", "NOT_PROMISE", [
-                    "Ensure function returns a Promise<ToolResult>",
-                    "Use async/await pattern",
-                    "Return a result object with success property",
-                ]));
-            }
-        }
-        catch (error) {
-            warnings.push(`Execute function validation failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
+    // Simplified validation - just check if execute is a function
+    if (mcpTool.execute && typeof mcpTool.execute !== "function") {
+        errors.push(new ValidationError("Execute must be a function", "execute", "INVALID_TYPE", ["Provide a function for the execute property"]));
     }
     // Check optional properties
     if (mcpTool.inputSchema && !isNonNullObject(mcpTool.inputSchema)) {
@@ -264,7 +245,7 @@ export function validateTextGenerationOptions(options) {
         errors.push(tempError);
     }
     // Validate maxTokens
-    const tokensError = validateNumberRange(opts.maxTokens, "maxTokens", 1, 200000);
+    const tokensError = validateNumberRange(opts.maxTokens, "maxTokens", 1, 128000);
     if (tokensError) {
         errors.push(tokensError);
     }
@@ -316,7 +297,7 @@ export function validateStreamOptions(options) {
         errors.push(tempError);
     }
     // Validate maxTokens
-    const tokensError = validateNumberRange(opts.maxTokens, "maxTokens", 1, 200000);
+    const tokensError = validateNumberRange(opts.maxTokens, "maxTokens", 1, 128000);
     if (tokensError) {
         errors.push(tokensError);
     }
@@ -349,7 +330,7 @@ export function validateGenerateOptions(options) {
     if (tempError) {
         errors.push(tempError);
     }
-    const tokensError = validateNumberRange(opts.maxTokens, "maxTokens", 1, 200000);
+    const tokensError = validateNumberRange(opts.maxTokens, "maxTokens", 1, 128000);
     if (tokensError) {
         errors.push(tokensError);
     }

package/dist/utils/promptRedaction.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Prompt redaction utilities for safe logging
+ * Provides consistent prompt masking across NeuroLink components
+ */
+export interface PromptRedactionOptions {
+    /** Maximum length of redacted prompt */
+    maxLength?: number;
+    /** Whether to show word count */
+    showWordCount?: boolean;
+    /** Mask character to use for redaction */
+    maskChar?: string;
+}
+/**
+ * Redact a prompt for safe logging
+ * Truncates to maxLength and optionally shows word count
+ */
+export declare function redactPrompt(prompt: string, options?: PromptRedactionOptions): string;
+/**
+ * Create a short safe mask for highly sensitive contexts
+ */
+export declare function createSafeMask(prompt: string, _maskLength?: number): string;
+/**
+ * Redact for classification context (matches classifier behavior)
+ */
+export declare function redactForClassification(prompt: string): string;
+/**
+ * Redact for routing context (matches router behavior)
+ */
+export declare function redactForRouting(prompt: string): string;

package/dist/utils/promptRedaction.js

@@ -0,0 +1,62 @@
+/**
+ * Prompt redaction utilities for safe logging
+ * Provides consistent prompt masking across NeuroLink components
+ */
+/**
+ * Default redaction options
+ */
+const DEFAULT_REDACTION_OPTIONS = {
+    maxLength: 100,
+    showWordCount: true,
+    maskChar: "*",
+};
+/**
+ * Redact a prompt for safe logging
+ * Truncates to maxLength and optionally shows word count
+ */
+export function redactPrompt(prompt, options = {}) {
+    const opts = { ...DEFAULT_REDACTION_OPTIONS, ...options };
+    if (!prompt || typeof prompt !== "string") {
+        return "[INVALID_PROMPT]";
+    }
+    const wordCount = prompt.trim().split(/\s+/).length;
+    let redacted = prompt.substring(0, opts.maxLength);
+    // Add ellipsis if truncated
+    if (prompt.length > opts.maxLength) {
+        redacted = redacted.substring(0, opts.maxLength - 3) + "...";
+    }
+    // Optionally append word count
+    if (opts.showWordCount) {
+        redacted += ` [${wordCount} words]`;
+    }
+    return redacted;
+}
+/**
+ * Create a short safe mask for highly sensitive contexts
+ */
+export function createSafeMask(prompt, _maskLength = 20) {
+    if (!prompt || typeof prompt !== "string") {
+        return "[INVALID_PROMPT]";
+    }
+    const wordCount = prompt.trim().split(/\s+/).length;
+    const charCount = prompt.length;
+    return `[REDACTED: ${charCount} chars, ${wordCount} words]`;
+}
+/**
+ * Redact for classification context (matches classifier behavior)
+ */
+export function redactForClassification(prompt) {
+    return redactPrompt(prompt, {
+        maxLength: 100,
+        showWordCount: false,
+    });
+}
+/**
+ * Redact for routing context (matches router behavior)
+ */
+export function redactForRouting(prompt) {
+    return redactPrompt(prompt, {
+        maxLength: 100,
+        showWordCount: true,
+    });
+}

package/dist/utils/schemaConversion.d.ts

@@ -0,0 +1,14 @@
+import type { ZodUnknownSchema } from "../types/tools.js";
+/**
+ * Convert Zod schema to JSON Schema format for Claude AI
+ */
+export declare function convertZodToJsonSchema(zodSchema: ZodUnknownSchema): object;
+/**
+ * Check if a value is a Zod schema
+ */
+export declare function isZodSchema(value: unknown): boolean;
+/**
+ * Convert JSON Schema to Zod schema format using official json-schema-to-zod library
+ * This ensures complete preservation of all schema structure and validation rules
+ */
+export declare function convertJsonSchemaToZod(jsonSchema: Record<string, unknown>): ZodUnknownSchema;