@juspay/neurolink 7.34.0 → 7.36.0

package/dist/cli/factories/setupCommandFactory.js

@@ -0,0 +1,137 @@
+/**
+ * Setup Command Factory for NeuroLink
+ * Consolidates all provider setup commands into a unified interface
+ */
+import { handleGCPSetup } from "../commands/setup-gcp.js";
+import { handleBedrockSetup } from "../commands/setup-bedrock.js";
+import { handleOpenAISetup } from "../commands/setup-openai.js";
+import { handleGoogleAISetup } from "../commands/setup-google-ai.js";
+import { handleAnthropicSetup } from "../commands/setup-anthropic.js";
+import { handleAzureSetup } from "../commands/setup-azure.js";
+import { handleHuggingFaceSetup } from "../commands/setup-huggingface.js";
+import { handleMistralSetup } from "../commands/setup-mistral.js";
+import { handleSetup } from "../commands/setup.js";
+/**
+ * Setup Command Factory
+ */
+export class SetupCommandFactory {
+    /**
+     * Create the main setup command with all provider subcommands
+     */
+    static createSetupCommands() {
+        return {
+            command: ["setup [provider]", "s [provider]"],
+            describe: "Setup AI provider configurations",
+            builder: (yargs) => {
+                return (yargs
+                    .positional("provider", {
+                    type: "string",
+                    description: "Specific provider to set up",
+                    choices: [
+                        "google-ai",
+                        "openai",
+                        "anthropic",
+                        "azure",
+                        "bedrock",
+                        "gcp",
+                        "vertex",
+                        "huggingface",
+                        "mistral",
+                    ],
+                })
+                    .option("list", {
+                    type: "boolean",
+                    description: "List all available providers",
+                    alias: "l",
+                })
+                    .option("status", {
+                    type: "boolean",
+                    description: "Show provider configuration status",
+                })
+                    .option("check", {
+                    type: "boolean",
+                    description: "Only check existing configuration without prompting",
+                    default: false,
+                })
+                    .option("non-interactive", {
+                    type: "boolean",
+                    description: "Skip interactive prompts",
+                    default: false,
+                })
+                    .option("quiet", {
+                    type: "boolean",
+                    alias: "q",
+                    default: false,
+                    description: "Suppress non-essential output",
+                })
+                    .option("debug", {
+                    type: "boolean",
+                    default: false,
+                    description: "Enable debug output",
+                })
+                    // Subcommands for each provider
+                    .command("google-ai", "Setup Google AI Studio configuration", (y) => this.buildProviderOptions(y), 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                async (argv) => await handleGoogleAISetup(argv))
+                    .command("openai", "Setup OpenAI configuration", (y) => this.buildProviderOptions(y), 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                async (argv) => await handleOpenAISetup(argv))
+                    .command("anthropic", "Setup Anthropic Claude configuration", (y) => this.buildProviderOptions(y), 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                async (argv) => await handleAnthropicSetup(argv))
+                    .command("azure", "Setup Azure OpenAI configuration", (y) => this.buildProviderOptions(y), 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                async (argv) => await handleAzureSetup(argv))
+                    .command("bedrock", "Setup AWS Bedrock configuration", (y) => this.buildProviderOptions(y), 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                async (argv) => await handleBedrockSetup(argv))
+                    .command(["gcp", "vertex"], "Setup Google Cloud Platform / Vertex AI configuration", (y) => this.buildProviderOptions(y), 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                async (argv) => await handleGCPSetup(argv))
+                    .command("huggingface", "Setup Hugging Face configuration", (y) => this.buildProviderOptions(y), 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                async (argv) => await handleHuggingFaceSetup(argv))
+                    .command("mistral", "Setup Mistral AI configuration", (y) => this.buildProviderOptions(y), 
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                async (argv) => await handleMistralSetup(argv))
+                    .example("$0 setup", "Interactive setup wizard")
+                    .example("$0 setup google-ai", "Setup Google AI Studio")
+                    .example("$0 setup openai --check", "Check OpenAI configuration")
+                    .example("$0 setup --list", "List all providers")
+                    .example("$0 setup --status", "Check provider status")
+                    .help());
+            },
+            handler: async (argv) => {
+                // If no subcommand specified, run main setup wizard
+                await handleSetup(argv);
+            },
+        };
+    }
+    /**
+     * Build common options for provider setup commands
+     */
+    static buildProviderOptions(yargs) {
+        return yargs
+            .option("check", {
+            type: "boolean",
+            describe: "Only check existing configuration without prompting",
+            default: false,
+        })
+            .option("non-interactive", {
+            type: "boolean",
+            describe: "Skip interactive prompts",
+            default: false,
+        })
+            .option("quiet", {
+            type: "boolean",
+            alias: "q",
+            default: false,
+            description: "Suppress non-essential output",
+        })
+            .option("debug", {
+            type: "boolean",
+            default: false,
+            description: "Enable debug output",
+        });
+    }
+}

package/dist/cli/parser.js

@@ -6,6 +6,7 @@ import { CLICommandFactory } from "./factories/commandFactory.js";
 import { globalSession } from "../lib/session/globalSessionState.js";
 import { handleError } from "./errorHandler.js";
 import { logger } from "../lib/utils/logger.js";
+import { SetupCommandFactory } from "./factories/setupCommandFactory.js";
 // Enhanced CLI with Professional UX
 export function initializeCliParser() {
     return (yargs(hideBin(process.argv))
@@ -154,5 +155,7 @@ export function initializeCliParser() {
         // SageMaker Command Group - Using CLICommandFactory
         .command(CLICommandFactory.createSageMakerCommands())
         // Loop Command - Using CLICommandFactory
-        .command(CLICommandFactory.createLoopCommand()));
+        .command(CLICommandFactory.createLoopCommand())
+        // Setup Commands - Using SetupCommandFactory
+        .command(SetupCommandFactory.createSetupCommands())); // Close the main return statement
 }

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

@@ -12,6 +12,7 @@ export interface EnvUpdateResult {
     updated: string[];
     added: string[];
     unchanged: string[];
+    deleted: string[];
 }
 /**
  * Create a timestamped backup of the existing .env file
@@ -24,11 +25,11 @@ export declare function parseEnvFile(content: string): Record<string, string>;
 /**
  * Generate .env file content from key-value pairs
  */
-export declare function generateEnvContent(envVars: Record<string, string>, existingContent?: string): string;
+export declare function generateEnvContent(envVars: Record<string, string>, existingContent?: string, keysToDelete?: string[]): string;
 /**
  * Update .env file with new environment variables
  */
-export declare function updateEnvFile(newVars: Record<string, string>, envPath?: string, createBackup?: boolean): EnvUpdateResult;
+export declare function updateEnvFile(newVars: Record<string, string>, envPath?: string, createBackup?: boolean, keysToDelete?: string[]): EnvUpdateResult;
 /**
  * Display environment file update summary
  */

package/dist/cli/utils/envManager.js

@@ -59,7 +59,7 @@ export function parseEnvFile(content) {
 /**
  * Generate .env file content from key-value pairs
  */
-export function generateEnvContent(envVars, existingContent) {
+export function generateEnvContent(envVars, existingContent, keysToDelete = []) {
     const lines = [];
     const _existingVars = existingContent ? parseEnvFile(existingContent) : {};
     const processedKeys = new Set();
@@ -79,6 +79,10 @@ export function generateEnvContent(envVars, existingContent) {
                 continue;
             }
             const key = trimmedLine.substring(0, equalIndex).trim();
+            // Skip keys that should be deleted
+            if (keysToDelete.includes(key)) {
+                continue; // Skip this line - delete the key
+            }
             if (Object.prototype.hasOwnProperty.call(envVars, key)) {
                 // Update existing variable
                 lines.push(`${key}=${envVars[key]}`);
@@ -108,12 +112,13 @@ export function generateEnvContent(envVars, existingContent) {
 /**
  * Update .env file with new environment variables
  */
-export function updateEnvFile(newVars, envPath = ".env", createBackup = true) {
+export function updateEnvFile(newVars, envPath = ".env", createBackup = true, keysToDelete = []) {
     const result = {
         backup: { existed: false },
         updated: [],
         added: [],
         unchanged: [],
+        deleted: [],
     };
     // Create backup if requested and file exists
     if (createBackup) {
@@ -126,6 +131,12 @@ export function updateEnvFile(newVars, envPath = ".env", createBackup = true) {
         existingContent = fs.readFileSync(envPath, "utf8");
         _existingVars = parseEnvFile(existingContent);
     }
+    // Track keys to be deleted
+    for (const key of keysToDelete) {
+        if (Object.prototype.hasOwnProperty.call(_existingVars, key)) {
+            result.deleted.push(key);
+        }
+    }
     // Categorize changes
     for (const [key, value] of Object.entries(newVars)) {
         if (Object.prototype.hasOwnProperty.call(_existingVars, key)) {
@@ -141,7 +152,7 @@ export function updateEnvFile(newVars, envPath = ".env", createBackup = true) {
         }
     }
     // Generate new content
-    const newContent = generateEnvContent(newVars, existingContent);
+    const newContent = generateEnvContent(newVars, existingContent, keysToDelete);
     // Write updated file
     try {
         fs.writeFileSync(envPath, newContent, "utf8");
@@ -167,10 +178,13 @@ export function displayEnvUpdateSummary(result, quiet = false) {
     if (result.updated.length > 0) {
         logger.always(chalk.yellow(`🔄 Updated ${result.updated.length} existing variables: ${result.updated.join(", ")}`));
     }
+    if (result.deleted.length > 0) {
+        logger.always(chalk.red(`🗑️ Deleted ${result.deleted.length} variables: ${result.deleted.join(", ")}`));
+    }
     if (result.unchanged.length > 0) {
         logger.always(chalk.gray(`✓ ${result.unchanged.length} variables unchanged: ${result.unchanged.join(", ")}`));
     }
-    const totalChanges = result.added.length + result.updated.length;
+    const totalChanges = result.added.length + result.updated.length + result.deleted.length;
     if (totalChanges > 0) {
         logger.always(chalk.blue(`📝 Environment file updated with ${totalChanges} changes`));
     }

package/dist/core/baseProvider.js

@@ -1,3 +1,4 @@
+import { generateText } from "ai";
 import { MiddlewareFactory } from "../middleware/factory.js";
 import { logger } from "../utils/logger.js";
 import { DEFAULT_MAX_STEPS, STEP_LIMITS } from "../core/constants.js";
@@ -5,12 +6,11 @@ import { directAgentTools } from "../agent/directTools.js";
 import { getSafeMaxTokens } from "../utils/tokenLimits.js";
 import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
 import { shouldDisableBuiltinTools } from "../utils/toolUtils.js";
-import { buildMessagesArray } from "../utils/messageBuilder.js";
+import { buildMessagesArray, buildMultimodalMessagesArray, } from "../utils/messageBuilder.js";
 import { getKeysAsString, getKeyCount } from "../utils/transformationUtils.js";
 import { validateStreamOptions as validateStreamOpts, validateTextGenerationOptions, ValidationError, createValidationSummary, } from "../utils/parameterValidation.js";
 import { recordProviderPerformanceFromMetrics, getPerformanceOptimizedProvider, } from "./evaluationProviders.js";
 import { modelConfig } from "./modelConfiguration.js";
-// Provider types moved to ../types/providers.js
 /**
  * Abstract base class for all AI providers
  * Tools are integrated as first-class citizens - always available by default
@@ -166,7 +166,7 @@ export class BaseProvider {
         try {
             // Import streamText dynamically to avoid circular dependencies
             // Using streamText instead of generateText for unified implementation
-            const { streamText } = await import("ai");
+            // const { streamText } = await import("ai");
             // Get ALL available tools (direct + MCP + external from options)
             const shouldUseTools = !options.disableTools && this.supportsTools();
             const baseTools = shouldUseTools ? await this.getAllTools() : {};
@@ -211,42 +211,86 @@ export class BaseProvider {
             });
             const model = await this.getAISDKModelWithMiddleware(options);
             // Build proper message array with conversation history
-            const messages = buildMessagesArray(options);
-            // Use streamText and accumulate results instead of generateText
-            const streamResult = await streamText({
+            // Check if this is a multimodal request (images or content present)
+            let messages;
+            // Type guard to check if options has multimodal input
+            const hasMultimodalInput = (opts) => {
+                const input = opts.input;
+                const hasImages = !!input?.images?.length;
+                const hasContent = !!input?.content?.length;
+                return hasImages || hasContent;
+            };
+            if (hasMultimodalInput(options)) {
+                if (process.env.NEUROLINK_DEBUG === "true") {
+                    logger.info("🖼️ [MULTIMODAL-REQUEST] Detected multimodal input, using multimodal message builder");
+                }
+                // This is a multimodal request - use multimodal message builder
+                // Convert TextGenerationOptions to GenerateOptions format for multimodal processing
+                const input = options.input;
+                const multimodalOptions = {
+                    input: {
+                        text: options.prompt || options.input?.text || "",
+                        images: input?.images,
+                        content: input?.content,
+                    },
+                    provider: options.provider,
+                    model: options.model,
+                    temperature: options.temperature,
+                    maxTokens: options.maxTokens,
+                    systemPrompt: options.systemPrompt,
+                    enableAnalytics: options.enableAnalytics,
+                    enableEvaluation: options.enableEvaluation,
+                    context: options.context,
+                };
+                messages = await buildMultimodalMessagesArray(multimodalOptions, this.providerName, this.modelName);
+            }
+            else {
+                if (process.env.NEUROLINK_DEBUG === "true") {
+                    logger.info("📝 [TEXT-ONLY-REQUEST] No multimodal input detected, using standard message builder");
+                }
+                // Standard text-only request
+                messages = buildMessagesArray(options);
+            }
+            // Convert messages to Vercel AI SDK format
+            const aiSDKMessages = messages.map((msg) => {
+                if (typeof msg.content === "string") {
+                    // Simple text content
+                    return {
+                        role: msg.role,
+                        content: msg.content,
+                    };
+                }
+                else {
+                    // Multimodal content array - convert to Vercel AI SDK format
+                    // The Vercel AI SDK expects content to be in a specific format
+                    return {
+                        role: msg.role,
+                        content: msg.content.map((item) => {
+                            if (item.type === "text") {
+                                return { type: "text", text: item.text || "" };
+                            }
+                            else if (item.type === "image") {
+                                return { type: "image", image: item.image || "" };
+                            }
+                            return item;
+                        }),
+                    };
+                }
+            });
+            const generateResult = await generateText({
                 model,
-                messages: messages,
+                messages: aiSDKMessages,
                 tools,
                 maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
                 toolChoice: shouldUseTools ? "auto" : "none",
                 temperature: options.temperature,
                 maxTokens: options.maxTokens, // No default limit - unlimited unless specified
             });
-            // Accumulate the streamed content
-            let accumulatedContent = "";
-            // Wait for the stream to complete and accumulate content
-            try {
-                for await (const chunk of streamResult.textStream) {
-                    accumulatedContent += chunk;
-                }
-            }
-            catch (streamError) {
-                logger.error(`Error reading text stream for ${this.providerName}:`, streamError);
-                throw streamError;
-            }
-            // Get the final result - this should include usage, toolCalls, etc.
-            const usage = await streamResult.usage;
-            const toolCalls = await streamResult.toolCalls;
-            const toolResults = await streamResult.toolResults;
             const responseTime = Date.now() - startTime;
-            // Create a result object compatible with generateText format
-            const result = {
-                text: accumulatedContent,
-                usage: usage,
-                toolCalls: toolCalls,
-                toolResults: toolResults,
-                steps: streamResult.steps, // Include steps for tool execution tracking
-            };
+            // Extract properties from generateResult
+            const usage = generateResult.usage;
+            const toolCalls = generateResult.toolCalls;
+            const toolResults = generateResult.toolResults;
             try {
                 const actualCost = await this.calculateActualCost(usage || { promptTokens: 0, completionTokens: 0, totalTokens: 0 });
                 recordProviderPerformanceFromMetrics(this.providerName, {
@@ -273,14 +317,14 @@ export class BaseProvider {
             // First check direct tool calls (fallback)
             if (toolCalls && toolCalls.length > 0) {
                 toolsUsed.push(...toolCalls.map((tc) => {
-                    return tc.toolName || "unknown";
+                    return tc.toolName || tc.name || "unknown";
                 }));
             }
             // Then check steps for tool calls (primary source for multi-step)
-            if (result.steps &&
-                Array.isArray(result.steps)) {
-                for (const step of result.steps ||
-                    []) {
+            if (generateResult.steps &&
+                Array.isArray(generateResult.steps)) {
+                for (const step of generateResult
+                    .steps || []) {
                     if (step?.toolCalls && Array.isArray(step.toolCalls)) {
                         toolsUsed.push(...step.toolCalls.map((tc) => {
                             return tc.toolName || tc.name || "unknown";
@@ -295,10 +339,10 @@ export class BaseProvider {
             // Create a map of tool calls to their arguments for matching with results
             const toolCallArgsMap = new Map();
             // Extract tool executions from AI SDK result steps
-            if (result.steps &&
-                Array.isArray(result.steps)) {
-                for (const step of result.steps ||
-                    []) {
+            if (generateResult.steps &&
+                Array.isArray(generateResult.steps)) {
+                for (const step of generateResult
+                    .steps || []) {
                     // First, collect tool calls and their arguments
                     if (step?.toolCalls && Array.isArray(step.toolCalls)) {
                         for (const toolCall of step.toolCalls) {
@@ -359,11 +403,11 @@ export class BaseProvider {
             }
             // Format the result with tool executions included
             const enhancedResult = {
-                content: result.text,
+                content: generateResult.text,
                 usage: {
-                    input: result.usage?.promptTokens || 0,
-                    output: result.usage?.completionTokens || 0,
-                    total: result.usage?.totalTokens || 0,
+                    input: generateResult.usage?.promptTokens || 0,
+                    output: generateResult.usage?.completionTokens || 0,
+                    total: generateResult.usage?.totalTokens || 0,
                 },
                 provider: this.providerName,
                 model: this.modelName,
@@ -943,13 +987,23 @@ export class BaseProvider {
         const providerName = optionsOrPrompt.provider || this.providerName;
         // Apply safe maxTokens based on provider and model
         const safeMaxTokens = getSafeMaxTokens(providerName, modelName, optionsOrPrompt.maxTokens);
-        return {
+        // CRITICAL FIX: Preserve the entire input object for multimodal support
+        // This ensures images and content arrays are not lost during normalization
+        const normalizedOptions = {
             ...optionsOrPrompt,
             prompt,
             provider: providerName,
             model: modelName,
             maxTokens: safeMaxTokens,
         };
+        // Ensure input object is preserved if it exists (for multimodal support)
+        if (optionsOrPrompt.input) {
+            normalizedOptions.input = {
+                ...optionsOrPrompt.input,
+                text: prompt, // Ensure text is consistent
+            };
+        }
+        return normalizedOptions;
     }
     normalizeStreamOptions(optionsOrPrompt) {
         if (typeof optionsOrPrompt === "string") {

package/dist/core/types.d.ts

@@ -175,11 +175,14 @@ export interface StreamingOptions {
 }
 /**
  * Text generation options interface
+ * Extended to support multimodal content with zero breaking changes
  */
 export interface TextGenerationOptions {
     prompt?: string;
     input?: {
         text: string;
+        images?: Array<Buffer | string>;
+        content?: Array<import("../types/content.js").TextContent | import("../types/content.js").ImageContent>;
     };
     provider?: AIProviderName;
     model?: string;

package/dist/lib/adapters/providerImageAdapter.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Provider Image Adapter - Smart routing for multimodal content
+ * Handles provider-specific image formatting and vision capability validation
+ */
+import type { Content } from "../types/content.js";
+/**
+ * Simplified logger for essential error reporting only
+ */
+export declare class MultimodalLogger {
+    static logError(step: string, error: Error, context: unknown): void;
+}
+/**
+ * Provider Image Adapter - Smart routing and formatting
+ */
+export declare class ProviderImageAdapter {
+    /**
+     * Main adapter method - routes to provider-specific formatting
+     */
+    static adaptForProvider(text: string, images: Array<Buffer | string>, provider: string, model: string): Promise<unknown>;
+    /**
+     * Format content for OpenAI (GPT-4o format)
+     */
+    private static formatForOpenAI;
+    /**
+     * Format content for Google AI (Gemini format)
+     */
+    private static formatForGoogleAI;
+    /**
+     * Format content for Anthropic (Claude format)
+     */
+    private static formatForAnthropic;
+    /**
+     * Format content for Vertex AI (model-specific routing)
+     */
+    private static formatForVertex;
+    /**
+     * Validate that provider and model support vision
+     */
+    private static validateVisionSupport;
+    /**
+     * Convert simple images array to advanced content format
+     */
+    static convertToContent(text: string, images?: Array<Buffer | string>): Content[];
+    /**
+     * Check if provider supports multimodal content
+     */
+    static supportsVision(provider: string, model?: string): boolean;
+    /**
+     * Get supported models for a provider
+     */
+    static getSupportedModels(provider: string): string[];
+    /**
+     * Get all vision-capable providers
+     */
+    static getVisionProviders(): string[];
+}