@juspay/neurolink 7.29.1 → 7.29.3

package/dist/cli/factories/commandFactory.js

@@ -1,5 +1,8 @@
 import { NeuroLink } from "../../lib/neurolink.js";
 import { configManager } from "../commands/config.js";
+import { handleError } from "../index.js";
+import { normalizeEvaluationData } from "../../lib/utils/evaluationUtils.js";
+// Use TokenUsage from standard types - no local interface needed
 import { ContextFactory, } from "../../lib/types/contextTypes.js";
 import { ModelsCommandFactory } from "../commands/models.js";
 import { MCPCommandFactory } from "../commands/mcp.js";
@@ -9,6 +12,7 @@ import ora from "ora";
 import chalk from "chalk";
 import { logger } from "../../lib/utils/logger.js";
 import fs from "fs";
+// Use specific command interfaces from cli.ts instead of universal interface
 /**
  * CLI Command Factory for generate commands
  */
@@ -209,7 +213,9 @@ export class CLICommandFactory {
             }
         }
         return {
-            provider: argv.provider === "auto" ? undefined : argv.provider,
+            provider: argv.provider === "auto"
+                ? undefined
+                : argv.provider,
             model: argv.model,
             temperature: argv.temperature,
             maxTokens: argv.maxTokens,
@@ -273,14 +279,53 @@ export class CLICommandFactory {
             logger.always(output);
         }
     }
-    // Helper method to validate token usage data
+    // Helper method to validate token usage data with fallback handling
     static isValidTokenUsage(tokens) {
-        return !!(tokens &&
-            typeof tokens === "object" &&
-            tokens !== null &&
-            typeof tokens.input === "number" &&
-            typeof tokens.output === "number" &&
-            typeof tokens.total === "number");
+        if (!tokens || typeof tokens !== "object" || tokens === null) {
+            return false;
+        }
+        const tokensObj = tokens;
+        // Check primary format: analytics.tokens {input, output, total}
+        if (typeof tokensObj.input === "number" &&
+            typeof tokensObj.output === "number" &&
+            typeof tokensObj.total === "number") {
+            return true;
+        }
+        // Check fallback format: tokenUsage {inputTokens, outputTokens, totalTokens}
+        if (typeof tokensObj.inputTokens === "number" &&
+            typeof tokensObj.outputTokens === "number" &&
+            typeof tokensObj.totalTokens === "number") {
+            return true;
+        }
+        return false;
+    }
+    // Helper method to normalize token usage data to standard format
+    static normalizeTokenUsage(tokens) {
+        if (!this.isValidTokenUsage(tokens)) {
+            return null;
+        }
+        const tokensObj = tokens;
+        // Primary format: analytics.tokens {input, output, total}
+        if (typeof tokensObj.input === "number" &&
+            typeof tokensObj.output === "number" &&
+            typeof tokensObj.total === "number") {
+            return {
+                input: tokensObj.input,
+                output: tokensObj.output,
+                total: tokensObj.total,
+            };
+        }
+        // Fallback format: tokenUsage {inputTokens, outputTokens, totalTokens}
+        if (typeof tokensObj.inputTokens === "number" &&
+            typeof tokensObj.outputTokens === "number" &&
+            typeof tokensObj.totalTokens === "number") {
+            return {
+                input: tokensObj.inputTokens,
+                output: tokensObj.outputTokens,
+                total: tokensObj.totalTokens,
+            };
+        }
+        return null;
     }
     // Helper method to format analytics for text mode display
     static formatAnalyticsForTextMode(result) {
@@ -299,10 +344,10 @@ export class CLICommandFactory {
             analyticsText += ` (${modelName})`;
         }
         analyticsText += "\n";
-        // Token usage
-        if (this.isValidTokenUsage(analytics.tokens)) {
-            const tokens = analytics.tokens;
-            analyticsText += `   Tokens: ${tokens.input} input + ${tokens.output} output = ${tokens.total} total\n`;
+        // Token usage with fallback handling
+        const normalizedTokens = this.normalizeTokenUsage(analytics.tokenUsage);
+        if (normalizedTokens) {
+            analyticsText += `   Tokens: ${normalizedTokens.input} input + ${normalizedTokens.output} output = ${normalizedTokens.total} total\n`;
         }
         // Cost information
         if (analytics.cost !== undefined &&
@@ -310,9 +355,12 @@ export class CLICommandFactory {
             typeof analytics.cost === "number") {
             analyticsText += `   Cost: $${analytics.cost.toFixed(5)}\n`;
         }
-        // Response time
-        if (analytics.responseTime && typeof analytics.responseTime === "number") {
-            const timeInSeconds = (analytics.responseTime / 1000).toFixed(1);
+        // Response time with fallback handling for requestDuration vs responseTime
+        const duration = analytics.requestDuration ||
+            analytics.responseTime ||
+            analytics.duration;
+        if (duration && typeof duration === "number") {
+            const timeInSeconds = (duration / 1000).toFixed(1);
             analyticsText += `   Time: ${timeInSeconds}s\n`;
         }
         // Tools used
@@ -561,21 +609,21 @@ export class CLICommandFactory {
                         provider: "google-ai",
                         status: "working",
                         configured: true,
-                        responseTime: 150,
+                        requestDuration: 150,
                         model: "gemini-2.5-flash",
                     },
                     {
                         provider: "openai",
                         status: "working",
                         configured: true,
-                        responseTime: 200,
+                        requestDuration: 200,
                         model: "gpt-4o-mini",
                     },
                     {
                         provider: "anthropic",
                         status: "working",
                         configured: true,
-                        responseTime: 180,
+                        requestDuration: 180,
                         model: "claude-3-haiku",
                     },
                     { provider: "bedrock", status: "not configured", configured: false },
@@ -591,7 +639,9 @@ export class CLICommandFactory {
                         : result.status === "failed"
                             ? chalk.red("❌ Failed")
                             : chalk.gray("⚪ Not configured");
-                    const time = result.responseTime ? ` (${result.responseTime}ms)` : "";
+                    const time = result.requestDuration
+                        ? ` (${result.requestDuration}ms)`
+                        : "";
                     const model = result.model ? ` [${result.model}]` : "";
                     logger.always(`${result.provider}: ${status}${time}${model}`);
                 }
@@ -692,33 +742,31 @@ export class CLICommandFactory {
                     provider: options.provider || "auto",
                     model: options.model || "test-model",
                     usage: {
-                        inputTokens: 10,
-                        outputTokens: 15,
-                        totalTokens: 25,
+                        input: 10,
+                        output: 15,
+                        total: 25,
                     },
                     responseTime: 150,
                     analytics: options.enableAnalytics
                         ? {
                             provider: options.provider || "auto",
                             model: options.model || "test-model",
-                            tokens: { input: 10, output: 15, total: 25 },
+                            tokenUsage: { input: 10, output: 15, total: 25 },
                             cost: 0.00025,
-                            responseTime: 150,
+                            requestDuration: 150,
                             context: contextMetadata,
                         }
                         : undefined,
                     evaluation: options.enableEvaluation
-                        ? {
+                        ? normalizeEvaluationData({
                             relevance: 8,
                             accuracy: 9,
                             completeness: 8,
                             overall: 8.3,
-                            isOffTopic: false,
-                            alertSeverity: "none",
                             reasoning: "Test evaluation response",
                             evaluationModel: "test-evaluator",
                             evaluationTime: 50,
-                        }
+                        })
                         : undefined,
                 };
                 if (spinner) {
@@ -732,7 +780,6 @@ export class CLICommandFactory {
                     logger.debug("Mode: DRY-RUN (no actual API calls made)");
                 }
                 process.exit(0);
-                return;
             }
             const sdk = new NeuroLink();
             if (options.debug) {
@@ -785,18 +832,36 @@ export class CLICommandFactory {
             if (spinner) {
                 spinner.fail();
             }
-            logger.error(chalk.red(`❌ Generation failed: ${error.message}`));
-            if (options.debug) {
-                logger.error(chalk.gray(error.stack));
-            }
-            process.exit(1);
+            handleError(error, "Generation");
         }
     }
     /**
-     * Execute the stream command
+     * Log debug information for stream result
      */
-    static async executeStream(argv) {
-        // Handle stdin input if no input provided
+    static async logStreamDebugInfo(stream) {
+        logger.debug("\n" + chalk.yellow("Debug Information (Streaming):"));
+        logger.debug("Provider:", stream.provider);
+        logger.debug("Model:", stream.model);
+        if (stream.analytics) {
+            const resolvedAnalytics = await (stream.analytics instanceof Promise
+                ? stream.analytics
+                : Promise.resolve(stream.analytics));
+            logger.debug("Analytics:", JSON.stringify(resolvedAnalytics, null, 2));
+        }
+        if (stream.evaluation) {
+            const resolvedEvaluation = await (stream.evaluation instanceof Promise
+                ? stream.evaluation
+                : Promise.resolve(stream.evaluation));
+            logger.debug("Evaluation:", JSON.stringify(resolvedEvaluation, null, 2));
+        }
+        if (stream.metadata) {
+            logger.debug("Metadata:", JSON.stringify(stream.metadata, null, 2));
+        }
+    }
+    /**
+     * Handle stdin input for stream command
+     */
+    static async handleStdinInput(argv) {
         if (!argv.input && !process.stdin.isTTY) {
             let stdinData = "";
             process.stdin.setEncoding("utf8");
@@ -811,6 +876,12 @@ export class CLICommandFactory {
         else if (!argv.input) {
             throw new Error('Input required. Use: neurolink stream "your prompt" or echo "prompt" | neurolink stream');
         }
+    }
+    /**
+     * Execute the stream command
+     */
+    static async executeStream(argv) {
+        await this.handleStdinInput(argv);
         const options = this.processOptions(argv);
         if (!options.quiet) {
             logger.always(chalk.blue("🔄 Streaming..."));
@@ -873,11 +944,11 @@ export class CLICommandFactory {
                         model: options.model || "test-model",
                         requestDuration: 300,
                         tokenUsage: {
-                            inputTokens: 10,
-                            outputTokens: 15,
-                            totalTokens: 25,
+                            input: 10,
+                            output: 15,
+                            total: 25,
                         },
-                        timestamp: Date.now(),
+                        timestamp: new Date().toISOString(),
                         context: contextMetadata,
                     };
                     const mockGenerateResult = {
@@ -911,7 +982,6 @@ export class CLICommandFactory {
                     logger.debug("Mode: DRY-RUN (no actual API calls made)");
                 }
                 process.exit(0);
-                return;
             }
             const sdk = new NeuroLink();
             const stream = await sdk.stream({
@@ -935,14 +1005,66 @@ export class CLICommandFactory {
                     : undefined,
             });
             let fullContent = "";
-            // Process the stream
-            for await (const chunk of stream.stream) {
-                if (options.delay && options.delay > 0) {
-                    // Demo mode - add delay between chunks
-                    await new Promise((resolve) => setTimeout(resolve, options.delay));
+            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));
+                    }
+                    process.stdout.write(nextResult.value.content);
+                    fullContent += nextResult.value.content;
                 }
-                process.stdout.write(chunk.content);
-                fullContent += chunk.content;
+            }
+            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");
@@ -985,33 +1107,12 @@ export class CLICommandFactory {
             }
             // 🔧 NEW: Debug output for streaming (similar to generate command)
             if (options.debug) {
-                logger.debug("\n" + chalk.yellow("Debug Information (Streaming):"));
-                logger.debug("Provider:", stream.provider);
-                logger.debug("Model:", stream.model);
-                if (stream.analytics) {
-                    const resolvedAnalytics = await (stream.analytics instanceof Promise
-                        ? stream.analytics
-                        : Promise.resolve(stream.analytics));
-                    logger.debug("Analytics:", JSON.stringify(resolvedAnalytics, null, 2));
-                }
-                if (stream.evaluation) {
-                    const resolvedEvaluation = await (stream.evaluation instanceof Promise
-                        ? stream.evaluation
-                        : Promise.resolve(stream.evaluation));
-                    logger.debug("Evaluation:", JSON.stringify(resolvedEvaluation, null, 2));
-                }
-                if (stream.metadata) {
-                    logger.debug("Metadata:", JSON.stringify(stream.metadata, null, 2));
-                }
+                await this.logStreamDebugInfo(stream);
             }
             process.exit(0);
         }
         catch (error) {
-            logger.error(chalk.red(`❌ Streaming failed: ${error.message}`));
-            if (options.debug) {
-                logger.error(chalk.gray(error.stack));
-            }
-            process.exit(1);
+            handleError(error, "Streaming");
         }
     }
     /**
@@ -1125,11 +1226,7 @@ export class CLICommandFactory {
             if (spinner) {
                 spinner.fail();
             }
-            logger.error(chalk.red(`❌ Batch processing failed: ${error.message}`));
-            if (options.debug) {
-                logger.error(chalk.gray(error.stack));
-            }
-            process.exit(1);
+            handleError(error, "Batch processing");
         }
     }
     /**
@@ -1158,8 +1255,7 @@ export class CLICommandFactory {
             this.handleOutput(config, options);
         }
         catch (error) {
-            logger.error(chalk.red(`❌ Configuration export failed: ${error.message}`));
-            process.exit(1);
+            handleError(error, "Configuration export");
         }
     }
     /**
@@ -1183,8 +1279,7 @@ export class CLICommandFactory {
             }
         }
         catch (error) {
-            logger.error(chalk.red(`❌ Provider selection failed: ${error.message}`));
-            process.exit(1);
+            handleError(error, "Provider selection");
         }
     }
     /**
@@ -1323,8 +1418,7 @@ export class CLICommandFactory {
             }
         }
         catch (error) {
-            logger.error(chalk.red(`❌ Completion generation failed: ${error.message}`));
-            process.exit(1);
+            handleError(error, "Completion generation");
         }
     }
 }

package/dist/cli/factories/ollamaCommandFactory.js

@@ -183,7 +183,9 @@ export class OllamaCommandFactory {
                 logger.always(chalk.green(`\n${modelsData.models.length} models available`));
             }
         }
-        catch (_error) {
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.debug("Error:", errorMessage);
             spinner.fail("Ollama service is not running");
             logger.always(chalk.yellow("\nStart Ollama with: ollama serve"));
             logger.always(chalk.blue("Or restart the Ollama app if using the desktop version"));

package/dist/cli/factories/sagemakerCommandFactory.js

@@ -309,9 +309,10 @@ export class SageMakerCommandFactory {
                     logger.always(chalk.yellow("No SageMaker endpoints found"));
                 }
             }
-            catch (_awsError) {
+            catch (error) {
                 spinner.fail("Failed to list endpoints");
-                logger.error(chalk.red("AWS SDK credentials error or insufficient permissions"));
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                logger.error(chalk.red("Error:", errorMessage));
                 logger.always(chalk.yellow("\nTo list endpoints, please:"));
                 logger.always("1. Set AWS_ACCESS_KEY_ID environment variable");
                 logger.always("2. Set AWS_SECRET_ACCESS_KEY environment variable");

package/dist/cli/index.d.ts

@@ -5,4 +5,4 @@
  * Professional CLI experience with minimal maintenance overhead.
  * Features: Spinners, colors, batch processing, provider testing, rich help
  */
-export {};
+export declare function handleError(_error: Error, context: string): void;

package/dist/cli/index.js

@@ -14,6 +14,14 @@ import { fileURLToPath } from "url";
 import { CLICommandFactory } from "./factories/commandFactory.js";
 import { AuthenticationError, AuthorizationError, NetworkError, RateLimitError, } from "../lib/types/errors.js";
 import { logger } from "../lib/utils/logger.js";
+// Clean up pnpm-specific environment variables that cause npm warnings
+// These variables are set by pnpm but cause "Unknown env config" warnings in npm
+if (process.env.npm_config_verify_deps_before_run) {
+    delete process.env.npm_config_verify_deps_before_run;
+}
+if (process.env.npm_config__jsr_registry) {
+    delete process.env.npm_config__jsr_registry;
+}
 // Get version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -25,14 +33,14 @@ try {
     const { config } = await import("dotenv");
     config(); // Load .env from current working directory
 }
-catch (error) {
+catch {
     // dotenv is not available (dev dependency only) - this is fine for production
     // Environment variables should be set externally in production
 }
 // Utility Functions (Simple, Zero Maintenance)
-function handleError(error, context) {
-    logger.error(chalk.red(`❌ ${context} failed: ${error.message}`));
-    if (error instanceof AuthenticationError) {
+export function handleError(_error, context) {
+    logger.error(chalk.red(`❌ ${context} failed: ${_error.message}`));
+    if (_error instanceof AuthenticationError) {
         logger.error(chalk.yellow("💡 Set Google AI Studio API key (RECOMMENDED): export GOOGLE_AI_API_KEY=AIza-..."));
         logger.error(chalk.yellow("💡 Or set OpenAI API key: export OPENAI_API_KEY=sk-..."));
         logger.error(chalk.yellow("💡 Or set AWS Bedrock credentials: export AWS_ACCESS_KEY_ID=... AWS_SECRET_ACCESS_KEY=... AWS_REGION=us-east-1"));
@@ -40,14 +48,14 @@ function handleError(error, context) {
         logger.error(chalk.yellow("💡 Or set Anthropic API key: export ANTHROPIC_API_KEY=sk-ant-..."));
         logger.error(chalk.yellow("💡 Or set Azure OpenAI credentials: export AZURE_OPENAI_API_KEY=... AZURE_OPENAI_ENDPOINT=..."));
     }
-    else if (error instanceof RateLimitError) {
+    else if (_error instanceof RateLimitError) {
         logger.error(chalk.yellow("💡 Try again in a few moments or use --provider vertex"));
     }
-    else if (error instanceof AuthorizationError) {
+    else if (_error instanceof AuthorizationError) {
         logger.error(chalk.yellow("💡 Check your account permissions for the selected model/service."));
         logger.error(chalk.yellow("💡 For AWS Bedrock, ensure you have permissions for the specific model and consider using inference profile ARNs."));
     }
-    else if (error instanceof NetworkError) {
+    else if (_error instanceof NetworkError) {
         logger.error(chalk.yellow("💡 Check your internet connection and the provider's status page."));
     }
     process.exit(1);
@@ -97,9 +105,9 @@ const cli = yargs(args)
         }
     };
     if (err) {
-        // Error likely from an async command handler (e.g., via handleError)
-        // handleError already prints and calls process.exit(1).
-        // If we're here, it means handleError's process.exit might not have been caught by the top-level async IIFE.
+        // Error likely from an async command handler (e.g., via _handleError)
+        // _handleError already prints and calls process.exit(1).
+        // If we're here, it means _handleError's process.exit might not have been caught by the top-level async IIFE.
         // Or, it's a synchronous yargs error during parsing that yargs itself throws.
         const alreadyExitedByHandleError = err?.exitCode !== undefined;
         // A simple heuristic: if the error message doesn't look like one of our handled generic messages,
@@ -189,7 +197,7 @@ const cli = yargs(args)
     }
     catch (error) {
         // Global error handler - should not reach here due to fail() handler
-        process.stderr.write(chalk.red(`Unexpected CLI error: ${error.message}\n`));
+        process.stderr.write(chalk.red(`Unexpected CLI _error: ${error.message}\n`));
         process.exit(1);
     }
 })();

package/dist/cli/utils/envManager.js

@@ -61,7 +61,7 @@ export function parseEnvFile(content) {
  */
 export function generateEnvContent(envVars, existingContent) {
     const lines = [];
-    const existingVars = existingContent ? parseEnvFile(existingContent) : {};
+    const _existingVars = existingContent ? parseEnvFile(existingContent) : {};
     const processedKeys = new Set();
     // If we have existing content, preserve its structure and comments
     if (existingContent) {
@@ -121,15 +121,15 @@ export function updateEnvFile(newVars, envPath = ".env", createBackup = true) {
     }
     // Read existing content
     let existingContent = "";
-    let existingVars = {};
+    let _existingVars = {};
     if (fs.existsSync(envPath)) {
         existingContent = fs.readFileSync(envPath, "utf8");
-        existingVars = parseEnvFile(existingContent);
+        _existingVars = parseEnvFile(existingContent);
     }
     // Categorize changes
     for (const [key, value] of Object.entries(newVars)) {
-        if (Object.prototype.hasOwnProperty.call(existingVars, key)) {
-            if (existingVars[key] !== value) {
+        if (Object.prototype.hasOwnProperty.call(_existingVars, key)) {
+            if (_existingVars[key] !== value) {
                 result.updated.push(key);
             }
             else {

package/dist/cli/utils/ollamaUtils.d.ts

@@ -8,6 +8,18 @@ export declare class OllamaUtils {
      * Secure wrapper around spawnSync to prevent command injection.
      */
     static safeSpawn(command: AllowedCommand, args: string[], options?: SpawnSyncOptions): SpawnSyncReturns<string>;
+    /**
+     * Check if Ollama command line is available
+     */
+    private static isOllamaCommandReady;
+    /**
+     * Validate HTTP API response from Ollama
+     */
+    private static validateApiResponse;
+    /**
+     * Check if Ollama HTTP API is ready
+     */
+    private static isOllamaApiReady;
     /**
      * Wait for Ollama service to become ready with exponential backoff
      */