@juspay/neurolink 7.36.0 → 7.37.1

package/dist/cli/factories/commandFactory.js

@@ -953,7 +953,9 @@ export class CLICommandFactory {
                 temperature: enhancedOptions.temperature,
                 maxTokens: enhancedOptions.maxTokens,
                 systemPrompt: enhancedOptions.systemPrompt,
-                timeout: enhancedOptions.timeout,
+                timeout: enhancedOptions.timeout
+                    ? enhancedOptions.timeout * 1000
+                    : undefined,
                 disableTools: enhancedOptions.disableTools,
                 enableAnalytics: enhancedOptions.enableAnalytics,
                 enableEvaluation: enhancedOptions.enableEvaluation,
@@ -1001,6 +1003,288 @@ export class CLICommandFactory {
             handleError(error, "Generation");
         }
     }
+    /**
+     * Process context for streaming
+     */
+    static async processStreamContext(argv, options) {
+        let inputText = argv.input;
+        let contextMetadata;
+        if (options.context && options.contextConfig) {
+            const processedContextResult = ContextFactory.processContext(options.context, options.contextConfig);
+            // Integrate context into prompt if configured
+            if (processedContextResult.processedContext) {
+                inputText = processedContextResult.processedContext + inputText;
+            }
+            // Add context metadata for analytics
+            contextMetadata = {
+                ...ContextFactory.extractAnalyticsContext(options.context),
+                contextMode: processedContextResult.config.mode,
+                contextTruncated: processedContextResult.metadata.truncated,
+            };
+            if (options.debug) {
+                logger.debug("Context processed for streaming:", {
+                    mode: processedContextResult.config.mode,
+                    truncated: processedContextResult.metadata.truncated,
+                    processingTime: processedContextResult.metadata.processingTime,
+                });
+            }
+        }
+        return { inputText, contextMetadata };
+    }
+    /**
+     * Execute dry-run streaming simulation
+     */
+    static async executeDryRunStream(options, contextMetadata) {
+        if (!options.quiet) {
+            logger.always(chalk.blue("🔄 Dry-run streaming..."));
+        }
+        // Simulate streaming output
+        const chunks = [
+            "Mock ",
+            "streaming ",
+            "response ",
+            "for ",
+            "testing ",
+            "purposes",
+        ];
+        let fullContent = "";
+        for (const chunk of chunks) {
+            process.stdout.write(chunk);
+            fullContent += chunk;
+            await new Promise((resolve) => setTimeout(resolve, 50)); // Simulate streaming delay
+        }
+        if (!options.quiet) {
+            process.stdout.write("\n");
+        }
+        // Mock analytics and evaluation for dry-run
+        if (options.enableAnalytics) {
+            const mockAnalytics = {
+                provider: options.provider || "auto",
+                model: options.model || "test-model",
+                requestDuration: 300,
+                tokenUsage: {
+                    input: 10,
+                    output: 15,
+                    total: 25,
+                },
+                timestamp: new Date().toISOString(),
+                context: contextMetadata,
+            };
+            const mockGenerateResult = {
+                success: true,
+                content: fullContent,
+                analytics: mockAnalytics,
+                model: mockAnalytics.model,
+                toolsUsed: [],
+            };
+            const analyticsDisplay = this.formatAnalyticsForTextMode(mockGenerateResult);
+            logger.always(analyticsDisplay);
+        }
+        if (options.enableEvaluation) {
+            logger.always(chalk.blue("\n📊 Response Evaluation (Dry-run):"));
+            logger.always(`   Relevance: 8/10`);
+            logger.always(`   Accuracy: 9/10`);
+            logger.always(`   Completeness: 8/10`);
+            logger.always(`   Overall: 8.3/10`);
+            logger.always(`   Reasoning: Test evaluation response`);
+        }
+        if (options.output) {
+            fs.writeFileSync(options.output, fullContent);
+            if (!options.quiet) {
+                logger.always(`\nOutput saved to ${options.output}`);
+            }
+        }
+        if (options.debug) {
+            logger.debug("\n" + chalk.yellow("Debug Information (Dry-run Streaming):"));
+            logger.debug("Provider:", options.provider || "auto");
+            logger.debug("Model:", options.model || "test-model");
+            logger.debug("Mode: DRY-RUN (no actual API calls made)");
+        }
+        if (!globalSession.getCurrentSessionId()) {
+            process.exit(0);
+        }
+    }
+    /**
+     * Execute real streaming with timeout handling
+     */
+    static async executeRealStream(argv, options, inputText, contextMetadata) {
+        const sdk = globalSession.getOrCreateNeuroLink();
+        const sessionVariables = globalSession.getSessionVariables();
+        const enhancedOptions = { ...options, ...sessionVariables };
+        const sessionId = globalSession.getCurrentSessionId();
+        const context = sessionId
+            ? { ...contextMetadata, sessionId }
+            : contextMetadata;
+        // Process CLI images if provided
+        const imageBuffers = CLICommandFactory.processCliImages(argv.image);
+        const stream = await sdk.stream({
+            input: imageBuffers
+                ? { text: inputText, images: imageBuffers }
+                : { text: inputText },
+            provider: enhancedOptions.provider,
+            model: enhancedOptions.model,
+            temperature: enhancedOptions.temperature,
+            maxTokens: enhancedOptions.maxTokens,
+            systemPrompt: enhancedOptions.systemPrompt,
+            timeout: enhancedOptions.timeout
+                ? enhancedOptions.timeout * 1000
+                : undefined,
+            disableTools: enhancedOptions.disableTools,
+            enableAnalytics: enhancedOptions.enableAnalytics,
+            enableEvaluation: enhancedOptions.enableEvaluation,
+            evaluationDomain: enhancedOptions.evaluationDomain,
+            toolUsageContext: enhancedOptions.toolUsageContext,
+            context: context,
+            factoryConfig: enhancedOptions.domain
+                ? {
+                    domainType: enhancedOptions.domain,
+                    enhancementType: "domain-configuration",
+                    validateDomainData: true,
+                }
+                : undefined,
+        });
+        const fullContent = await this.processStreamWithTimeout(stream, options);
+        await this.displayStreamResults(stream, fullContent, options);
+        return fullContent;
+    }
+    /**
+     * Process stream with timeout handling
+     */
+    static async processStreamWithTimeout(stream, options) {
+        let fullContent = "";
+        let contentReceived = false;
+        const abortController = new AbortController();
+        // Create timeout promise for stream consumption (30 seconds)
+        const timeoutPromise = new Promise((_, reject) => {
+            const timeoutId = setTimeout(() => {
+                if (!contentReceived) {
+                    const timeoutError = new Error("\n❌ Stream timeout - no content received within 30 seconds\n" +
+                        "This usually indicates authentication or network issues\n\n" +
+                        "🔧 Try these steps:\n" +
+                        "1. Check your provider credentials are configured correctly\n" +
+                        `2. Test generate mode: neurolink generate "test" --provider ${options.provider}\n` +
+                        `3. Use debug mode: neurolink stream "test" --provider ${options.provider} --debug`);
+                    reject(timeoutError);
+                }
+            }, 30000);
+            // Clean up timeout when aborted
+            abortController.signal.addEventListener("abort", () => {
+                clearTimeout(timeoutId);
+            });
+        });
+        try {
+            // Process the stream with timeout handling
+            const streamIterator = stream.stream[Symbol.asyncIterator]();
+            let timeoutActive = true;
+            while (true) {
+                let nextResult;
+                if (timeoutActive && !contentReceived) {
+                    // Race between next chunk and timeout for first chunk only
+                    nextResult = await Promise.race([
+                        streamIterator.next(),
+                        timeoutPromise,
+                    ]);
+                }
+                else {
+                    // No timeout for subsequent chunks
+                    nextResult = await streamIterator.next();
+                }
+                if (nextResult.done) {
+                    break;
+                }
+                if (!contentReceived) {
+                    contentReceived = true;
+                    timeoutActive = false;
+                    abortController.abort(); // Cancel timeout
+                }
+                if (options.delay && options.delay > 0) {
+                    // Demo mode - add delay between chunks
+                    await new Promise((resolve) => setTimeout(resolve, options.delay));
+                }
+                const evt = nextResult.value;
+                const isText = (o) => !!o &&
+                    typeof o === "object" &&
+                    typeof o.content === "string";
+                const isAudio = (o) => !!o &&
+                    typeof o === "object" &&
+                    o.type === "audio";
+                if (isText(evt)) {
+                    process.stdout.write(evt.content);
+                    fullContent += evt.content;
+                }
+                else if (isAudio(evt)) {
+                    if (options.debug && !options.quiet) {
+                        process.stdout.write("[audio-chunk]");
+                    }
+                }
+            }
+        }
+        catch (error) {
+            abortController.abort(); // Clean up timeout
+            throw error;
+        }
+        if (!contentReceived) {
+            throw new Error("\n❌ No content received from stream\n" +
+                "Check your credentials and provider configuration");
+        }
+        if (!options.quiet) {
+            process.stdout.write("\n");
+        }
+        return fullContent;
+    }
+    /**
+     * Display analytics and evaluation results
+     */
+    static async displayStreamResults(stream, fullContent, options) {
+        // Display analytics after streaming
+        if (options.enableAnalytics && stream.analytics) {
+            const resolvedAnalytics = await (stream.analytics instanceof Promise
+                ? stream.analytics
+                : Promise.resolve(stream.analytics));
+            const streamAnalytics = {
+                success: true,
+                content: fullContent,
+                analytics: resolvedAnalytics,
+                model: stream.model,
+                toolsUsed: stream.toolCalls?.map((tc) => tc.toolName) || [],
+            };
+            const analyticsDisplay = this.formatAnalyticsForTextMode(streamAnalytics);
+            logger.always(analyticsDisplay);
+        }
+        // Display evaluation after streaming
+        if (options.enableEvaluation && stream.evaluation) {
+            const resolvedEvaluation = await (stream.evaluation instanceof Promise
+                ? stream.evaluation
+                : Promise.resolve(stream.evaluation));
+            logger.always(chalk.blue("\n📊 Response Evaluation:"));
+            logger.always(`   Relevance: ${resolvedEvaluation.relevance}/10`);
+            logger.always(`   Accuracy: ${resolvedEvaluation.accuracy}/10`);
+            logger.always(`   Completeness: ${resolvedEvaluation.completeness}/10`);
+            logger.always(`   Overall: ${resolvedEvaluation.overall}/10`);
+            if (resolvedEvaluation.reasoning) {
+                logger.always(`   Reasoning: ${resolvedEvaluation.reasoning}`);
+            }
+        }
+    }
+    /**
+     * Handle stream output file writing and debug output
+     */
+    static async handleStreamOutput(options, fullContent) {
+        // Handle output file if specified
+        if (options.output) {
+            fs.writeFileSync(options.output, fullContent);
+            if (!options.quiet) {
+                logger.always(`\nOutput saved to ${options.output}`);
+            }
+        }
+        // Debug output for streaming
+        if (options.debug) {
+            await this.logStreamDebugInfo({
+                provider: options.provider,
+                model: options.model,
+            });
+        }
+    }
     /**
      * Log debug information for stream result
      */
@@ -1057,252 +1341,14 @@ export class CLICommandFactory {
             if (options.delay) {
                 await new Promise((resolve) => setTimeout(resolve, options.delay));
             }
-            // Process context if provided (same as generate command)
-            let inputText = argv.input;
-            let contextMetadata;
-            if (options.context && options.contextConfig) {
-                const processedContextResult = ContextFactory.processContext(options.context, options.contextConfig);
-                // Integrate context into prompt if configured
-                if (processedContextResult.processedContext) {
-                    inputText = processedContextResult.processedContext + inputText;
-                }
-                // Add context metadata for analytics
-                contextMetadata = {
-                    ...ContextFactory.extractAnalyticsContext(options.context),
-                    contextMode: processedContextResult.config.mode,
-                    contextTruncated: processedContextResult.metadata.truncated,
-                };
-                if (options.debug) {
-                    logger.debug("Context processed for streaming:", {
-                        mode: processedContextResult.config.mode,
-                        truncated: processedContextResult.metadata.truncated,
-                        processingTime: processedContextResult.metadata.processingTime,
-                    });
-                }
-            }
+            const { inputText, contextMetadata } = await this.processStreamContext(argv, options);
             // Handle dry-run mode for testing
             if (options.dryRun) {
-                if (!options.quiet) {
-                    logger.always(chalk.blue("🔄 Dry-run streaming..."));
-                }
-                // Simulate streaming output
-                const chunks = [
-                    "Mock ",
-                    "streaming ",
-                    "response ",
-                    "for ",
-                    "testing ",
-                    "purposes",
-                ];
-                let fullContent = "";
-                for (const chunk of chunks) {
-                    process.stdout.write(chunk);
-                    fullContent += chunk;
-                    await new Promise((resolve) => setTimeout(resolve, 50)); // Simulate streaming delay
-                }
-                if (!options.quiet) {
-                    process.stdout.write("\n");
-                }
-                // Mock analytics and evaluation for dry-run
-                if (options.enableAnalytics) {
-                    const mockAnalytics = {
-                        provider: options.provider || "auto",
-                        model: options.model || "test-model",
-                        requestDuration: 300,
-                        tokenUsage: {
-                            input: 10,
-                            output: 15,
-                            total: 25,
-                        },
-                        timestamp: new Date().toISOString(),
-                        context: contextMetadata,
-                    };
-                    const mockGenerateResult = {
-                        success: true,
-                        content: fullContent,
-                        analytics: mockAnalytics,
-                        model: mockAnalytics.model,
-                        toolsUsed: [],
-                    };
-                    const analyticsDisplay = this.formatAnalyticsForTextMode(mockGenerateResult);
-                    logger.always(analyticsDisplay);
-                }
-                if (options.enableEvaluation) {
-                    logger.always(chalk.blue("\n📊 Response Evaluation (Dry-run):"));
-                    logger.always(`   Relevance: 8/10`);
-                    logger.always(`   Accuracy: 9/10`);
-                    logger.always(`   Completeness: 8/10`);
-                    logger.always(`   Overall: 8.3/10`);
-                    logger.always(`   Reasoning: Test evaluation response`);
-                }
-                if (options.output) {
-                    fs.writeFileSync(options.output, fullContent);
-                    if (!options.quiet) {
-                        logger.always(`\nOutput saved to ${options.output}`);
-                    }
-                }
-                if (options.debug) {
-                    logger.debug("\n" + chalk.yellow("Debug Information (Dry-run Streaming):"));
-                    logger.debug("Provider:", options.provider || "auto");
-                    logger.debug("Model:", options.model || "test-model");
-                    logger.debug("Mode: DRY-RUN (no actual API calls made)");
-                }
-                if (!globalSession.getCurrentSessionId()) {
-                    process.exit(0);
-                }
-            }
-            const sdk = globalSession.getOrCreateNeuroLink();
-            const sessionVariables = globalSession.getSessionVariables();
-            const enhancedOptions = { ...options, ...sessionVariables };
-            const sessionId = globalSession.getCurrentSessionId();
-            const context = sessionId
-                ? { ...contextMetadata, sessionId }
-                : contextMetadata;
-            // Process CLI images if provided
-            const imageBuffers = CLICommandFactory.processCliImages(argv.image);
-            const stream = await sdk.stream({
-                input: imageBuffers
-                    ? { text: inputText, images: imageBuffers }
-                    : { text: inputText },
-                provider: enhancedOptions.provider,
-                model: enhancedOptions.model,
-                temperature: enhancedOptions.temperature,
-                maxTokens: enhancedOptions.maxTokens,
-                systemPrompt: enhancedOptions.systemPrompt,
-                timeout: enhancedOptions.timeout,
-                disableTools: enhancedOptions.disableTools,
-                enableAnalytics: enhancedOptions.enableAnalytics,
-                enableEvaluation: enhancedOptions.enableEvaluation,
-                evaluationDomain: enhancedOptions.evaluationDomain,
-                toolUsageContext: enhancedOptions.toolUsageContext,
-                context: context,
-                factoryConfig: enhancedOptions.domain
-                    ? {
-                        domainType: enhancedOptions.domain,
-                        enhancementType: "domain-configuration",
-                        validateDomainData: true,
-                    }
-                    : undefined,
-            });
-            let fullContent = "";
-            let contentReceived = false;
-            const abortController = new AbortController();
-            // Create timeout promise for stream consumption (30 seconds)
-            const timeoutPromise = new Promise((_, reject) => {
-                const timeoutId = setTimeout(() => {
-                    if (!contentReceived) {
-                        const timeoutError = new Error("\n❌ Stream timeout - no content received within 30 seconds\n" +
-                            "This usually indicates authentication or network issues\n\n" +
-                            "🔧 Try these steps:\n" +
-                            "1. Check your provider credentials are configured correctly\n" +
-                            `2. Test generate mode: neurolink generate "test" --provider ${options.provider}\n` +
-                            `3. Use debug mode: neurolink stream "test" --provider ${options.provider} --debug`);
-                        reject(timeoutError);
-                    }
-                }, 30000);
-                // Clean up timeout when aborted
-                abortController.signal.addEventListener("abort", () => {
-                    clearTimeout(timeoutId);
-                });
-            });
-            try {
-                // Process the stream with timeout handling
-                const streamIterator = stream.stream[Symbol.asyncIterator]();
-                let timeoutActive = true;
-                while (true) {
-                    let nextResult;
-                    if (timeoutActive && !contentReceived) {
-                        // Race between next chunk and timeout for first chunk only
-                        nextResult = await Promise.race([
-                            streamIterator.next(),
-                            timeoutPromise,
-                        ]);
-                    }
-                    else {
-                        // No timeout for subsequent chunks
-                        nextResult = await streamIterator.next();
-                    }
-                    if (nextResult.done) {
-                        break;
-                    }
-                    if (!contentReceived) {
-                        contentReceived = true;
-                        timeoutActive = false;
-                        abortController.abort(); // Cancel timeout
-                    }
-                    if (options.delay && options.delay > 0) {
-                        // Demo mode - add delay between chunks
-                        await new Promise((resolve) => setTimeout(resolve, options.delay));
-                    }
-                    const evt = nextResult.value;
-                    const isText = (o) => !!o &&
-                        typeof o === "object" &&
-                        typeof o.content === "string";
-                    const isAudio = (o) => !!o &&
-                        typeof o === "object" &&
-                        o.type === "audio";
-                    if (isText(evt)) {
-                        process.stdout.write(evt.content);
-                        fullContent += evt.content;
-                    }
-                    else if (isAudio(evt)) {
-                        if (options.debug && !options.quiet) {
-                            process.stdout.write("[audio-chunk]");
-                        }
-                    }
-                }
-            }
-            catch (error) {
-                abortController.abort(); // Clean up timeout
-                throw error;
-            }
-            if (!contentReceived) {
-                throw new Error("\n❌ No content received from stream\n" +
-                    "Check your credentials and provider configuration");
-            }
-            if (!options.quiet) {
-                process.stdout.write("\n");
-            }
-            // 🔧 NEW: Display analytics and evaluation after streaming (similar to generate command)
-            if (options.enableAnalytics && stream.analytics) {
-                const resolvedAnalytics = await (stream.analytics instanceof Promise
-                    ? stream.analytics
-                    : Promise.resolve(stream.analytics));
-                const streamAnalytics = {
-                    success: true,
-                    content: fullContent,
-                    analytics: resolvedAnalytics,
-                    model: stream.model,
-                    toolsUsed: stream.toolCalls?.map((tc) => tc.toolName) || [],
-                };
-                const analyticsDisplay = this.formatAnalyticsForTextMode(streamAnalytics);
-                logger.always(analyticsDisplay);
-            }
-            // 🔧 NEW: Display evaluation after streaming
-            if (options.enableEvaluation && stream.evaluation) {
-                const resolvedEvaluation = await (stream.evaluation instanceof Promise
-                    ? stream.evaluation
-                    : Promise.resolve(stream.evaluation));
-                logger.always(chalk.blue("\n📊 Response Evaluation:"));
-                logger.always(`   Relevance: ${resolvedEvaluation.relevance}/10`);
-                logger.always(`   Accuracy: ${resolvedEvaluation.accuracy}/10`);
-                logger.always(`   Completeness: ${resolvedEvaluation.completeness}/10`);
-                logger.always(`   Overall: ${resolvedEvaluation.overall}/10`);
-                if (resolvedEvaluation.reasoning) {
-                    logger.always(`   Reasoning: ${resolvedEvaluation.reasoning}`);
-                }
-            }
-            // Handle output file if specified
-            if (options.output) {
-                fs.writeFileSync(options.output, fullContent);
-                if (!options.quiet) {
-                    logger.always(`\nOutput saved to ${options.output}`);
-                }
-            }
-            // 🔧 NEW: Debug output for streaming (similar to generate command)
-            if (options.debug) {
-                await this.logStreamDebugInfo(stream);
+                await this.executeDryRunStream(options, contextMetadata);
+                return;
             }
+            const fullContent = await this.executeRealStream(argv, options, inputText, contextMetadata);
+            await this.handleStreamOutput(options, fullContent);
             if (!globalSession.getCurrentSessionId()) {
                 process.exit(0);
             }
@@ -1385,7 +1431,9 @@ export class CLICommandFactory {
                         temperature: enhancedOptions.temperature,
                         maxTokens: enhancedOptions.maxTokens,
                         systemPrompt: enhancedOptions.systemPrompt,
-                        timeout: enhancedOptions.timeout,
+                        timeout: enhancedOptions.timeout
+                            ? enhancedOptions.timeout * 1000
+                            : undefined,
                         disableTools: enhancedOptions.disableTools,
                         evaluationDomain: enhancedOptions.evaluationDomain,
                         toolUsageContext: enhancedOptions.toolUsageContext,
@@ -1631,6 +1679,10 @@ export class CLICommandFactory {
                 success = true;
             }
             else {
+                // sessionId is guaranteed to exist when isAllSessions is false
+                if (!argv.sessionId) {
+                    throw new Error("Session ID is required for clearing specific session");
+                }
                 success = await sdk.clearConversationSession(argv.sessionId);
             }
             if (spinner) {

package/dist/config/taskClassificationConfig.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Task Classification Configuration
+ * Contains patterns, keywords, and scoring weights for task classification
+ */
+/**
+ * Regular expression patterns that indicate fast response tasks
+ */
+export declare const FAST_PATTERNS: RegExp[];
+/**
+ * Regular expression patterns that indicate reasoning tasks
+ */
+export declare const REASONING_PATTERNS: RegExp[];
+/**
+ * Keywords that indicate fast tasks regardless of context
+ */
+export declare const FAST_KEYWORDS: string[];
+/**
+ * Keywords that indicate reasoning tasks regardless of context
+ */
+export declare const REASONING_KEYWORDS: string[];
+/**
+ * Scoring weights for different classification factors
+ */
+export declare const SCORING_WEIGHTS: {
+    readonly SHORT_PROMPT_BONUS: 2;
+    readonly LONG_PROMPT_BONUS: 1;
+    readonly PATTERN_MATCH_SCORE: 3;
+    readonly KEYWORD_MATCH_SCORE: 1;
+    readonly MULTIPLE_QUESTIONS_BONUS: 1;
+    readonly MULTI_SENTENCE_BONUS: 1;
+    readonly TECHNICAL_DOMAIN_BONUS: 1;
+    readonly SIMPLE_DEFINITION_BONUS: 2;
+};
+/**
+ * Classification thresholds and constraints
+ */
+export declare const CLASSIFICATION_THRESHOLDS: {
+    readonly SHORT_PROMPT_LENGTH: 50;
+    readonly LONG_PROMPT_LENGTH: 200;
+    readonly SIMPLE_DEFINITION_LENGTH: 100;
+    readonly MIN_CONFIDENCE: 0.6;
+    readonly MAX_CONFIDENCE: 0.95;
+    readonly DEFAULT_CONFIDENCE: 0.5;
+};
+/**
+ * Domain-specific patterns for enhanced classification
+ */
+export declare const DOMAIN_PATTERNS: {
+    readonly TECHNICAL: RegExp;
+    readonly SIMPLE_DEFINITION: RegExp;
+};