@juspay/neurolink 7.35.0 → 7.37.0

package/dist/lib/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/lib/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/lib/utils/taskClassificationUtils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Task Classification Utility Functions
+ * Helper functions for analyzing prompts and calculating scores
+ */
+import type { ClassificationScores } from "../types/taskClassificationTypes.js";
+/**
+ * Analyze prompt length and apply scoring bonuses
+ */
+export declare function analyzeLengthFactors(prompt: string, reasons: string[]): {
+    fastScore: number;
+    reasoningScore: number;
+};
+/**
+ * Check prompt against fast task patterns
+ */
+export declare function checkFastPatterns(normalizedPrompt: string, reasons: string[]): number;
+/**
+ * Check prompt against reasoning task patterns
+ */
+export declare function checkReasoningPatterns(normalizedPrompt: string, reasons: string[]): number;
+/**
+ * Analyze keyword matches in the prompt
+ */
+export declare function analyzeKeywords(normalizedPrompt: string, reasons: string[]): {
+    fastScore: number;
+    reasoningScore: number;
+};
+/**
+ * Analyze question complexity
+ */
+export declare function analyzeQuestionComplexity(prompt: string, reasons: string[]): number;
+/**
+ * Analyze prompt structure and punctuation
+ */
+export declare function analyzePromptStructure(prompt: string, reasons: string[]): number;
+/**
+ * Analyze domain-specific indicators
+ */
+export declare function analyzeDomainIndicators(normalizedPrompt: string, prompt: string, reasons: string[]): {
+    fastScore: number;
+    reasoningScore: number;
+};
+/**
+ * Calculate final confidence score
+ */
+export declare function calculateConfidence(fastScore: number, reasoningScore: number): number;
+/**
+ * Determine task type based on scores
+ */
+export declare function determineTaskType(fastScore: number, reasoningScore: number): "fast" | "reasoning";
+/**
+ * Comprehensive prompt analysis
+ * Runs all analysis functions and returns combined scores
+ */
+export declare function analyzePrompt(prompt: string): ClassificationScores;

package/dist/lib/utils/taskClassificationUtils.js

@@ -0,0 +1,149 @@
+/**
+ * Task Classification Utility Functions
+ * Helper functions for analyzing prompts and calculating scores
+ */
+import { FAST_PATTERNS, REASONING_PATTERNS, FAST_KEYWORDS, REASONING_KEYWORDS, SCORING_WEIGHTS, CLASSIFICATION_THRESHOLDS, DOMAIN_PATTERNS, } from "../config/taskClassificationConfig.js";
+/**
+ * Analyze prompt length and apply scoring bonuses
+ */
+export function analyzeLengthFactors(prompt, reasons) {
+    let fastScore = 0;
+    let reasoningScore = 0;
+    if (prompt.length < CLASSIFICATION_THRESHOLDS.SHORT_PROMPT_LENGTH) {
+        fastScore += SCORING_WEIGHTS.SHORT_PROMPT_BONUS;
+        reasons.push("short prompt");
+    }
+    else if (prompt.length > CLASSIFICATION_THRESHOLDS.LONG_PROMPT_LENGTH) {
+        reasoningScore += SCORING_WEIGHTS.LONG_PROMPT_BONUS;
+        reasons.push("detailed prompt");
+    }
+    return { fastScore, reasoningScore };
+}
+/**
+ * Check prompt against fast task patterns
+ */
+export function checkFastPatterns(normalizedPrompt, reasons) {
+    for (const pattern of FAST_PATTERNS) {
+        if (pattern.test(normalizedPrompt)) {
+            reasons.push("fast pattern match");
+            return SCORING_WEIGHTS.PATTERN_MATCH_SCORE;
+        }
+    }
+    return 0;
+}
+/**
+ * Check prompt against reasoning task patterns
+ */
+export function checkReasoningPatterns(normalizedPrompt, reasons) {
+    for (const pattern of REASONING_PATTERNS) {
+        if (pattern.test(normalizedPrompt)) {
+            reasons.push("reasoning pattern match");
+            return SCORING_WEIGHTS.PATTERN_MATCH_SCORE;
+        }
+    }
+    return 0;
+}
+/**
+ * Analyze keyword matches in the prompt
+ */
+export function analyzeKeywords(normalizedPrompt, reasons) {
+    const fastKeywordMatches = FAST_KEYWORDS.filter((keyword) => normalizedPrompt.includes(keyword)).length;
+    const reasoningKeywordMatches = REASONING_KEYWORDS.filter((keyword) => normalizedPrompt.includes(keyword)).length;
+    const fastScore = fastKeywordMatches * SCORING_WEIGHTS.KEYWORD_MATCH_SCORE;
+    const reasoningScore = reasoningKeywordMatches * SCORING_WEIGHTS.KEYWORD_MATCH_SCORE;
+    if (fastKeywordMatches > 0) {
+        reasons.push(`${fastKeywordMatches} fast keywords`);
+    }
+    if (reasoningKeywordMatches > 0) {
+        reasons.push(`${reasoningKeywordMatches} reasoning keywords`);
+    }
+    return { fastScore, reasoningScore };
+}
+/**
+ * Analyze question complexity
+ */
+export function analyzeQuestionComplexity(prompt, reasons) {
+    const questionMarks = (prompt.match(/\?/g) || []).length;
+    if (questionMarks > 1) {
+        reasons.push("multiple questions");
+        return SCORING_WEIGHTS.MULTIPLE_QUESTIONS_BONUS;
+    }
+    return 0;
+}
+/**
+ * Analyze prompt structure and punctuation
+ */
+export function analyzePromptStructure(prompt, reasons) {
+    const sentences = prompt.split(/[.!?]+/).filter((s) => s.trim().length > 0);
+    if (sentences.length > 3) {
+        reasons.push("multi-sentence structure");
+        return SCORING_WEIGHTS.MULTI_SENTENCE_BONUS;
+    }
+    return 0;
+}
+/**
+ * Analyze domain-specific indicators
+ */
+export function analyzeDomainIndicators(normalizedPrompt, prompt, reasons) {
+    let fastScore = 0;
+    let reasoningScore = 0;
+    // Check for technical domain
+    if (DOMAIN_PATTERNS.TECHNICAL.test(normalizedPrompt)) {
+        reasoningScore += SCORING_WEIGHTS.TECHNICAL_DOMAIN_BONUS;
+        reasons.push("technical domain");
+    }
+    // Check for simple definition requests
+    if (DOMAIN_PATTERNS.SIMPLE_DEFINITION.test(normalizedPrompt) &&
+        prompt.length < CLASSIFICATION_THRESHOLDS.SIMPLE_DEFINITION_LENGTH) {
+        fastScore += SCORING_WEIGHTS.SIMPLE_DEFINITION_BONUS;
+        reasons.push("simple definition request");
+    }
+    return { fastScore, reasoningScore };
+}
+/**
+ * Calculate final confidence score
+ */
+export function calculateConfidence(fastScore, reasoningScore) {
+    const totalScore = fastScore + reasoningScore;
+    if (totalScore === 0) {
+        return CLASSIFICATION_THRESHOLDS.DEFAULT_CONFIDENCE;
+    }
+    const rawConfidence = Math.max(fastScore, reasoningScore) / totalScore;
+    return Math.max(CLASSIFICATION_THRESHOLDS.MIN_CONFIDENCE, Math.min(CLASSIFICATION_THRESHOLDS.MAX_CONFIDENCE, rawConfidence));
+}
+/**
+ * Determine task type based on scores
+ */
+export function determineTaskType(fastScore, reasoningScore) {
+    return fastScore >= reasoningScore ? "fast" : "reasoning";
+}
+/**
+ * Comprehensive prompt analysis
+ * Runs all analysis functions and returns combined scores
+ */
+export function analyzePrompt(prompt) {
+    const normalizedPrompt = prompt.toLowerCase().trim();
+    const reasons = [];
+    let fastScore = 0;
+    let reasoningScore = 0;
+    // 1. Length analysis
+    const lengthScores = analyzeLengthFactors(prompt, reasons);
+    fastScore += lengthScores.fastScore;
+    reasoningScore += lengthScores.reasoningScore;
+    // 2. Pattern matching
+    fastScore += checkFastPatterns(normalizedPrompt, reasons);
+    reasoningScore += checkReasoningPatterns(normalizedPrompt, reasons);
+    // 3. Keyword analysis
+    const keywordScores = analyzeKeywords(normalizedPrompt, reasons);
+    fastScore += keywordScores.fastScore;
+    reasoningScore += keywordScores.reasoningScore;
+    // 4. Question complexity
+    reasoningScore += analyzeQuestionComplexity(prompt, reasons);
+    // 5. Structure analysis
+    reasoningScore += analyzePromptStructure(prompt, reasons);
+    // 6. Domain analysis
+    const domainScores = analyzeDomainIndicators(normalizedPrompt, prompt, reasons);
+    fastScore += domainScores.fastScore;
+    reasoningScore += domainScores.reasoningScore;
+    return { fastScore, reasoningScore, reasons };
+}

package/dist/lib/utils/taskClassifier.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Binary Task Classifier for NeuroLink Orchestration
+ * Classifies tasks as either 'fast' (quick responses) or 'reasoning' (complex analysis)
+ */
+import type { TaskType, TaskClassification, ClassificationStats, ClassificationValidation } from "../types/taskClassificationTypes.js";
+/**
+ * Binary Task Classifier
+ * Determines if a task requires fast response or deeper reasoning
+ */
+export declare class BinaryTaskClassifier {
+    /**
+     * Classify a prompt as either fast or reasoning task
+     */
+    static classify(prompt: string): TaskClassification;
+    /**
+     * Get classification statistics for multiple prompts
+     */
+    static getClassificationStats(prompts: string[]): ClassificationStats;
+    /**
+     * Validate classification accuracy (for testing/tuning)
+     */
+    static validateClassification(prompt: string, expectedType: TaskType): ClassificationValidation;
+}

package/dist/lib/utils/taskClassifier.js

@@ -0,0 +1,94 @@
+/**
+ * Binary Task Classifier for NeuroLink Orchestration
+ * Classifies tasks as either 'fast' (quick responses) or 'reasoning' (complex analysis)
+ */
+import { logger } from "./logger.js";
+import { CLASSIFICATION_THRESHOLDS } from "../config/taskClassificationConfig.js";
+import { analyzePrompt, calculateConfidence, determineTaskType, } from "./taskClassificationUtils.js";
+import { redactForClassification } from "./promptRedaction.js";
+/**
+ * Binary Task Classifier
+ * Determines if a task requires fast response or deeper reasoning
+ */
+export class BinaryTaskClassifier {
+    /**
+     * Classify a prompt as either fast or reasoning task
+     */
+    static classify(prompt) {
+        const startTime = Date.now();
+        // Analyze the prompt using utility functions
+        const scores = analyzePrompt(prompt);
+        const { fastScore, reasoningScore, reasons } = scores;
+        // Determine final classification
+        const totalScore = fastScore + reasoningScore;
+        let type;
+        let confidence;
+        if (totalScore === 0) {
+            // Default to fast for ambiguous cases
+            type = "fast";
+            confidence = CLASSIFICATION_THRESHOLDS.DEFAULT_CONFIDENCE;
+            reasons.push("default fallback");
+        }
+        else {
+            type = determineTaskType(fastScore, reasoningScore);
+            confidence = calculateConfidence(fastScore, reasoningScore);
+        }
+        const classification = {
+            type,
+            confidence,
+            reasoning: reasons.join(", "),
+        };
+        const classificationTime = Date.now() - startTime;
+        logger.debug("Task classified", {
+            prompt: redactForClassification(prompt),
+            classification: type,
+            confidence: confidence.toFixed(2),
+            fastScore,
+            reasoningScore,
+            reasons: reasons.join(", "),
+            classificationTime: `${classificationTime}ms`,
+        });
+        return classification;
+    }
+    /**
+     * Get classification statistics for multiple prompts
+     */
+    static getClassificationStats(prompts) {
+        // Guard against empty array to prevent divide-by-zero
+        if (prompts.length === 0) {
+            const stats = {
+                total: 0,
+                fast: 0,
+                reasoning: 0,
+                averageConfidence: 0,
+            };
+            logger.debug("Classification stats", stats);
+            return stats;
+        }
+        const classifications = prompts.map((prompt) => this.classify(prompt));
+        const stats = {
+            total: classifications.length,
+            fast: classifications.filter((c) => c.type === "fast").length,
+            reasoning: classifications.filter((c) => c.type === "reasoning").length,
+            averageConfidence: classifications.reduce((sum, c) => sum + c.confidence, 0) /
+                classifications.length,
+        };
+        logger.debug("Classification stats", stats);
+        return stats;
+    }
+    /**
+     * Validate classification accuracy (for testing/tuning)
+     */
+    static validateClassification(prompt, expectedType) {
+        const classification = this.classify(prompt);
+        const correct = classification.type === expectedType;
+        logger.debug("Classification validation", {
+            prompt: redactForClassification(prompt),
+            expected: expectedType,
+            actual: classification.type,
+            correct,
+            confidence: classification.confidence,
+        });
+        return { correct, classification };
+    }
+}

package/dist/neurolink.d.ts

@@ -62,6 +62,7 @@ export declare class NeuroLink {
     private conversationMemory?;
     private conversationMemoryNeedsInit;
     private conversationMemoryConfig?;
+    private enableOrchestration;
     /**
      * Creates a new NeuroLink instance for AI text generation with MCP tool integration.
      *
@@ -70,6 +71,7 @@ export declare class NeuroLink {
      * @param config.conversationMemory.enabled - Whether to enable conversation memory (default: false)
      * @param config.conversationMemory.maxSessions - Maximum number of concurrent sessions (default: 100)
      * @param config.conversationMemory.maxTurnsPerSession - Maximum conversation turns per session (default: 50)
+     * @param config.enableOrchestration - Whether to enable smart model orchestration (default: false)
      *
      * @example
      * ```typescript
@@ -84,6 +86,11 @@ export declare class NeuroLink {
      *     maxTurnsPerSession: 20
      *   }
      * });
+     *
+     * // With orchestration enabled
+     * const neurolink = new NeuroLink({
+     *   enableOrchestration: true
+     * });
      * ```
      *
      * @throws {Error} When provider registry setup fails
@@ -92,6 +99,7 @@ export declare class NeuroLink {
      */
     constructor(config?: {
         conversationMemory?: Partial<ConversationMemoryConfig>;
+        enableOrchestration?: boolean;
     });
     /**
      * Log constructor start with comprehensive environment analysis
@@ -158,6 +166,18 @@ export declare class NeuroLink {
      * Log MCP initialization completion
      */
     private logMCPInitComplete;
+    /**
+     * Apply orchestration to determine optimal provider and model
+     * @param options - Original GenerateOptions
+     * @returns Modified options with orchestrated provider marked in context, or empty object if validation fails
+     */
+    private applyOrchestration;
+    /**
+     * Apply orchestration to determine optimal provider and model for streaming
+     * @param options - Original StreamOptions
+     * @returns Modified options with orchestrated provider marked in context, or empty object if validation fails
+     */
+    private applyStreamOrchestration;
     /**
      * MAIN ENTRY POINT: Enhanced generate method with new function signature
      * Replaces both generateText and legacy methods