@juspay/neurolink 9.25.2 → 9.26.1

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [9.26.1](https://github.com/juspay/neurolink/compare/v9.26.0...v9.26.1) (2026-03-16)
+
+### Bug Fixes
+
+- **(tests):** remove redundant vitest test cases, keep only continuous test suites ([625ecd6](https://github.com/juspay/neurolink/commit/625ecd684ec47919d3b79a8c1e907f8cb114a991))
+
+## [9.26.0](https://github.com/juspay/neurolink/compare/v9.25.2...v9.26.0) (2026-03-16)
+
+### Features
+
+- **(core):** production reliability fixes, bash tool, and LiteLLM vision tests (NL-001–NL-007) ([9a915e6](https://github.com/juspay/neurolink/commit/9a915e6f00e1e54e31967e47893f3b24e40eaad9))
+
 ## [9.25.2](https://github.com/juspay/neurolink/compare/v9.25.1...v9.25.2) (2026-03-15)
 
 ### Bug Fixes

package/dist/adapters/providerImageAdapter.d.ts

@@ -14,34 +14,10 @@ export declare class MultimodalLogger {
  */
 export declare class ProviderImageAdapter {
     /**
-     * Main adapter method - routes to provider-specific formatting
+     * Validate image count against provider limits.
+     * Warns at 80% threshold, throws error if limit exceeded.
      */
-    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 image count against provider limits
-     * Warns at 80% threshold, throws error if limit exceeded
-     */
-    private static validateImageCount;
-    /**
-     * Validate that provider and model support vision
-     */
-    private static validateVisionSupport;
+    static validateImageCount(imageCount: number, provider: string, model?: string): void;
     /**
      * Convert simple images array to advanced content format
      * @param text - Text content to include

package/dist/adapters/providerImageAdapter.js

@@ -2,8 +2,8 @@
  * Provider Image Adapter - Smart routing for multimodal content
  * Handles provider-specific image formatting and vision capability validation
  */
-import { logger } from "../utils/logger.js";
 import { ImageProcessor } from "../utils/imageProcessor.js";
+import { logger } from "../utils/logger.js";
 /**
  * Simplified logger for essential error reporting only
  */
@@ -436,184 +436,15 @@ const VISION_CAPABILITIES = {
  * Provider Image Adapter - Smart routing and formatting
  */
 export class ProviderImageAdapter {
+    // NOTE: The legacy `adaptForProvider` method and its private helpers
+    // (formatForOpenAI, formatForGoogleAI, formatForAnthropic, formatForVertex,
+    // validateVisionSupport) were removed as dead code. The production image
+    // pipeline uses `convertSimpleImagesToProviderFormat` in messageBuilder.ts
+    // with Vercel AI SDK's native ImagePart format. Image count limits are
+    // enforced via the public `validateImageCount` method below.
     /**
-     * Main adapter method - routes to provider-specific formatting
-     */
-    static async adaptForProvider(text, images, provider, model) {
-        try {
-            // Validate provider supports vision
-            this.validateVisionSupport(provider, model);
-            let adaptedPayload;
-            // Process images based on provider requirements
-            switch (provider.toLowerCase()) {
-                case "openai":
-                    adaptedPayload = this.formatForOpenAI(text, images);
-                    break;
-                case "azure":
-                case "azure-openai":
-                    // Azure uses same format as OpenAI but validate with azure provider name
-                    this.validateImageCount(images.length, "azure");
-                    adaptedPayload = this.formatForOpenAI(text, images, true);
-                    break;
-                case "google-ai":
-                case "google":
-                    adaptedPayload = this.formatForGoogleAI(text, images);
-                    break;
-                case "anthropic":
-                    adaptedPayload = this.formatForAnthropic(text, images);
-                    break;
-                case "vertex":
-                    adaptedPayload = this.formatForVertex(text, images, model);
-                    break;
-                case "ollama":
-                    // Ollama uses same format as OpenAI but validate with ollama provider name
-                    this.validateImageCount(images.length, "ollama");
-                    adaptedPayload = this.formatForOpenAI(text, images, true);
-                    break;
-                case "huggingface":
-                    adaptedPayload = this.formatForOpenAI(text, images);
-                    break;
-                case "sagemaker":
-                    adaptedPayload = this.formatForOpenAI(text, images);
-                    break;
-                case "litellm":
-                    // LiteLLM uses same format as OpenAI but validate with litellm provider name
-                    this.validateImageCount(images.length, "litellm");
-                    adaptedPayload = this.formatForOpenAI(text, images, true);
-                    break;
-                case "mistral":
-                    // Mistral uses same format as OpenAI but validate with mistral provider name
-                    this.validateImageCount(images.length, "mistral");
-                    adaptedPayload = this.formatForOpenAI(text, images, true);
-                    break;
-                case "bedrock":
-                    // Bedrock uses same format as Anthropic but validate with bedrock provider name
-                    this.validateImageCount(images.length, "bedrock");
-                    adaptedPayload = this.formatForAnthropic(text, images, true);
-                    break;
-                case "openrouter":
-                    // OpenRouter routes to underlying providers, use OpenAI format
-                    this.validateImageCount(images.length, "openrouter");
-                    adaptedPayload = this.formatForOpenAI(text, images);
-                    break;
-                default:
-                    throw new Error(`Vision not supported for provider: ${provider}`);
-            }
-            return adaptedPayload;
-        }
-        catch (error) {
-            MultimodalLogger.logError("ADAPTATION", error, {
-                provider,
-                model,
-                imageCount: images.length,
-            });
-            throw error;
-        }
-    }
-    /**
-     * Format content for OpenAI (GPT-4o format)
-     */
-    static formatForOpenAI(text, images, skipValidation = false) {
-        // Validate image count before processing (unless called from another formatter)
-        if (!skipValidation) {
-            this.validateImageCount(images.length, "openai");
-        }
-        const content = [{ type: "text", text }];
-        images.forEach((image, index) => {
-            try {
-                const imageUrl = ImageProcessor.processImageForOpenAI(image);
-                content.push({
-                    type: "image_url",
-                    image_url: { url: imageUrl },
-                });
-            }
-            catch (error) {
-                MultimodalLogger.logError("PROCESS_IMAGE", error, {
-                    index,
-                    provider: "openai",
-                });
-                throw error;
-            }
-        });
-        return { messages: [{ role: "user", content }] };
-    }
-    /**
-     * Format content for Google AI (Gemini format)
-     */
-    static formatForGoogleAI(text, images, skipValidation = false) {
-        // Validate image count before processing (unless called from another formatter)
-        if (!skipValidation) {
-            this.validateImageCount(images.length, "google-ai");
-        }
-        const parts = [{ text }];
-        images.forEach((image, index) => {
-            try {
-                const { mimeType, data } = ImageProcessor.processImageForGoogle(image);
-                parts.push({
-                    inlineData: { mimeType, data },
-                });
-            }
-            catch (error) {
-                MultimodalLogger.logError("PROCESS_IMAGE", error, {
-                    index,
-                    provider: "google-ai",
-                });
-                throw error;
-            }
-        });
-        return { contents: [{ parts }] };
-    }
-    /**
-     * Format content for Anthropic (Claude format)
-     */
-    static formatForAnthropic(text, images, skipValidation = false) {
-        // Validate image count before processing (unless called from another formatter)
-        if (!skipValidation) {
-            this.validateImageCount(images.length, "anthropic");
-        }
-        const content = [{ type: "text", text }];
-        images.forEach((image, index) => {
-            try {
-                const { mediaType, data } = ImageProcessor.processImageForAnthropic(image);
-                content.push({
-                    type: "image",
-                    source: {
-                        type: "base64",
-                        media_type: mediaType,
-                        data,
-                    },
-                });
-            }
-            catch (error) {
-                MultimodalLogger.logError("PROCESS_IMAGE", error, {
-                    index,
-                    provider: "anthropic",
-                });
-                throw error;
-            }
-        });
-        return { messages: [{ role: "user", content }] };
-    }
-    /**
-     * Format content for Vertex AI (model-specific routing)
-     */
-    static formatForVertex(text, images, model) {
-        // Validate image count with model-specific limits before processing
-        this.validateImageCount(images.length, "vertex", model);
-        // Route based on model type, skip validation in delegated methods
-        if (model.includes("gemini")) {
-            return this.formatForGoogleAI(text, images, true);
-        }
-        else if (model.includes("claude")) {
-            return this.formatForAnthropic(text, images, true);
-        }
-        else {
-            return this.formatForGoogleAI(text, images, true);
-        }
-    }
-    /**
-     * Validate image count against provider limits
-     * Warns at 80% threshold, throws error if limit exceeded
+     * Validate image count against provider limits.
+     * Warns at 80% threshold, throws error if limit exceeded.
      */
     static validateImageCount(imageCount, provider, model) {
         const normalizedProvider = provider.toLowerCase();
@@ -659,27 +490,6 @@ export class ProviderImageAdapter {
                 `Maximum allowed: ${limit}. Please reduce the number of images.`);
         }
     }
-    /**
-     * Validate that provider and model support vision
-     */
-    static validateVisionSupport(provider, model) {
-        const normalizedProvider = normalizeVisionProvider(provider);
-        const supportedModels = VISION_CAPABILITIES[normalizedProvider];
-        if (!supportedModels) {
-            throw new Error(`Provider ${provider} does not support vision processing. ` +
-                `Supported providers: ${Object.keys(VISION_CAPABILITIES).join(", ")}`);
-        }
-        const isSupported = supportedModels.some((supportedModel) => model.toLowerCase().includes(supportedModel.toLowerCase()));
-        // Proxy providers route to arbitrary underlying models — skip the allowlist
-        // check for unknown models and let the underlying provider error if needed.
-        if (!isSupported && PROXY_PROVIDERS.has(normalizedProvider)) {
-            return;
-        }
-        if (!isSupported) {
-            throw new Error(`Provider ${provider} with model ${model} does not support vision processing. ` +
-                `Supported models for ${provider}: ${supportedModels.join(", ")}`);
-        }
-    }
     /**
      * Convert simple images array to advanced content format
      * @param text - Text content to include

package/dist/agent/directTools.d.ts

@@ -220,8 +220,8 @@ export declare const directAgentTools: {
         mode: z.ZodDefault<z.ZodEnum<["create", "overwrite", "append"]>>;
     }, "strip", z.ZodTypeAny, {
         path: string;
-        content: string;
         mode: "append" | "create" | "overwrite";
+        content: string;
     }, {
         path: string;
         content: string;
@@ -250,8 +250,8 @@ export declare const directAgentTools: {
     }> & {
         execute: (args: {
             path: string;
-            content: string;
             mode: "append" | "create" | "overwrite";
+            content: string;
         }, options: import("ai").ToolExecutionOptions) => PromiseLike<{
             success: boolean;
             error: string;
@@ -464,6 +464,36 @@ export declare const directAgentTools: {
         }>;
     };
 };
+/**
+ * Bash command execution tool - exported separately for opt-in use.
+ *
+ * SECURITY: This tool is NOT included in directAgentTools by default.
+ * It must be explicitly enabled via:
+ *   - Environment variable: NEUROLINK_ENABLE_BASH_TOOL=true
+ *   - Config: toolConfig.enableBashTool = true
+ *
+ * Import this directly when you need bash execution capabilities:
+ *   import { bashTool } from '../agent/directTools.js';
+ */
+export declare const bashTool: import("ai").Tool<z.ZodObject<{
+    command: z.ZodString;
+    timeout: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    timeout: number;
+    command: string;
+    cwd?: string | undefined;
+}, {
+    command: string;
+    timeout?: number | undefined;
+    cwd?: string | undefined;
+}>, unknown> & {
+    execute: (args: {
+        timeout: number;
+        command: string;
+        cwd?: string | undefined;
+    }, options: import("ai").ToolExecutionOptions) => PromiseLike<unknown>;
+};
 /**
  * Type aliases for specific tool categories
  */
@@ -481,7 +511,9 @@ export type UtilityToolsMap = {
     calculateMath: typeof directAgentTools.calculateMath;
     listDirectory: typeof directAgentTools.listDirectory;
 };
-export type AllToolsMap = typeof directAgentTools;
+export type AllToolsMap = typeof directAgentTools & {
+    executeBashCommand?: typeof bashTool;
+};
 /**
  * Get a subset of tools for specific use cases with improved type safety
  */

package/dist/agent/directTools.js

@@ -6,9 +6,18 @@ import { tool } from "ai";
 import { z } from "zod";
 import * as fs from "fs";
 import * as path from "path";
+import { execFile } from "child_process";
 import { logger } from "../utils/logger.js";
 import { VertexAI } from "@google-cloud/vertexai";
 import { CSVProcessor } from "../utils/csvProcessor.js";
+import { shouldEnableBashTool } from "../utils/toolUtils.js";
+const MAX_OUTPUT_BYTES = 102400; // 100KB
+function truncateOutput(output) {
+    if (output.length > MAX_OUTPUT_BYTES) {
+        return (output.slice(0, MAX_OUTPUT_BYTES) + "\n... [output truncated at 100KB]");
+    }
+    return output;
+}
 // Runtime Google Search tool creation - bypasses TypeScript strict typing
 function createGoogleSearchTools() {
     const searchTool = {};
@@ -534,6 +543,9 @@ export const directAgentTools = {
             }
         },
     }),
+    // NOTE: executeBashCommand was moved to a separate opt-in export (bashTool) for security.
+    // It is only included in directAgentTools when NEUROLINK_ENABLE_BASH_TOOL=true or
+    // toolConfig.enableBashTool is explicitly set to true. See shouldEnableBashTool() in toolUtils.ts.
     websearchGrounding: tool({
         description: "Search the web for current information using Google Search grounding. Returns raw search data for AI processing.",
         parameters: z.object({
@@ -657,6 +669,116 @@ export const directAgentTools = {
         },
     }),
 };
+/**
+ * Bash command execution tool - exported separately for opt-in use.
+ *
+ * SECURITY: This tool is NOT included in directAgentTools by default.
+ * It must be explicitly enabled via:
+ *   - Environment variable: NEUROLINK_ENABLE_BASH_TOOL=true
+ *   - Config: toolConfig.enableBashTool = true
+ *
+ * Import this directly when you need bash execution capabilities:
+ *   import { bashTool } from '../agent/directTools.js';
+ */
+export const bashTool = tool({
+    description: "Execute a bash/shell command and return stdout, stderr, and exit code. Supports full shell syntax including pipes, redirects, and variable expansion. Requires HITL confirmation when enabled.",
+    parameters: z.object({
+        command: z
+            .string()
+            .describe("The shell command to execute (supports pipes, redirects, etc.)"),
+        timeout: z
+            .number()
+            .optional()
+            .default(30000)
+            .describe("Timeout in milliseconds (default: 30000, max: 120000)"),
+        cwd: z
+            .string()
+            .optional()
+            .describe("Working directory (defaults to process.cwd())"),
+    }),
+    execute: async ({ command, timeout = 30000, cwd }) => {
+        try {
+            const effectiveTimeout = Math.min(Math.max(timeout, 100), 120000);
+            const resolvedCwd = cwd ? path.resolve(cwd) : process.cwd();
+            const currentCwd = process.cwd();
+            // Verify cwd exists before resolving symlinks
+            if (!fs.existsSync(resolvedCwd) ||
+                !fs.statSync(resolvedCwd).isDirectory()) {
+                return {
+                    success: false,
+                    code: -1,
+                    stdout: "",
+                    stderr: "",
+                    error: `Directory does not exist: ${resolvedCwd}`,
+                };
+            }
+            // Security: resolve symlinks and prevent execution outside current directory
+            try {
+                const realCwd = fs.realpathSync(currentCwd);
+                const realResolvedCwd = fs.realpathSync(resolvedCwd);
+                if (!realResolvedCwd.startsWith(realCwd)) {
+                    return {
+                        success: false,
+                        code: -1,
+                        stdout: "",
+                        stderr: "",
+                        error: "Access denied: Cannot execute commands outside current directory",
+                    };
+                }
+            }
+            catch {
+                return {
+                    success: false,
+                    code: -1,
+                    stdout: "",
+                    stderr: "",
+                    error: "Access denied: Cannot resolve directory path",
+                };
+            }
+            // Use /bin/bash -c to support full shell syntax (pipes, redirects, etc.)
+            return await new Promise((resolve) => {
+                execFile("/bin/bash", ["-c", command], {
+                    timeout: effectiveTimeout,
+                    cwd: resolvedCwd,
+                    maxBuffer: MAX_OUTPUT_BYTES,
+                }, (error, stdout, stderr) => {
+                    if (error) {
+                        const exitCode = typeof error.code === "number" ? error.code : 1;
+                        resolve({
+                            success: false,
+                            code: exitCode,
+                            stdout: truncateOutput(stdout || ""),
+                            stderr: truncateOutput(stderr || error.message),
+                            error: error.killed ? "Command timed out" : error.message,
+                        });
+                    }
+                    else {
+                        resolve({
+                            success: true,
+                            code: 0,
+                            stdout: truncateOutput(stdout),
+                            stderr: truncateOutput(stderr),
+                        });
+                    }
+                });
+            });
+        }
+        catch (error) {
+            return {
+                success: false,
+                code: -1,
+                stdout: "",
+                stderr: "",
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    },
+});
+// Conditionally inject executeBashCommand into directAgentTools when opted in.
+// This ensures the tool is only available to SDK consumers who explicitly enable it.
+if (shouldEnableBashTool()) {
+    directAgentTools.executeBashCommand = bashTool;
+}
 // eslint-disable-next-line no-redeclare
 export function getToolsForCategory(category = "all") {
     switch (category) {

package/dist/cli/commands/config.d.ts

@@ -83,13 +83,13 @@ declare const ConfigSchema: z.ZodObject<{
             model: z.ZodDefault<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             model: string;
-            apiKey?: string | undefined;
             endpoint?: string | undefined;
+            apiKey?: string | undefined;
             deploymentId?: string | undefined;
         }, {
             model?: string | undefined;
-            apiKey?: string | undefined;
             endpoint?: string | undefined;
+            apiKey?: string | undefined;
             deploymentId?: string | undefined;
         }>>;
         "google-ai": z.ZodOptional<z.ZodObject<{
@@ -163,8 +163,8 @@ declare const ConfigSchema: z.ZodObject<{
         } | undefined;
         azure?: {
             model: string;
-            apiKey?: string | undefined;
             endpoint?: string | undefined;
+            apiKey?: string | undefined;
             deploymentId?: string | undefined;
         } | undefined;
         "google-ai"?: {
@@ -212,8 +212,8 @@ declare const ConfigSchema: z.ZodObject<{
         } | undefined;
         azure?: {
             model?: string | undefined;
-            apiKey?: string | undefined;
             endpoint?: string | undefined;
+            apiKey?: string | undefined;
             deploymentId?: string | undefined;
         } | undefined;
         "google-ai"?: {
@@ -483,8 +483,8 @@ declare const ConfigSchema: z.ZodObject<{
         } | undefined;
         azure?: {
             model: string;
-            apiKey?: string | undefined;
             endpoint?: string | undefined;
+            apiKey?: string | undefined;
             deploymentId?: string | undefined;
         } | undefined;
         "google-ai"?: {
@@ -581,8 +581,8 @@ declare const ConfigSchema: z.ZodObject<{
         } | undefined;
         azure?: {
             model?: string | undefined;
-            apiKey?: string | undefined;
             endpoint?: string | undefined;
+            apiKey?: string | undefined;
             deploymentId?: string | undefined;
         } | undefined;
         "google-ai"?: {

package/dist/context/contextCompactor.d.ts

@@ -10,8 +10,7 @@
  */
 import type { ChatMessage, ConversationMemoryConfig } from "../types/conversation.js";
 import type { CompactionResult, CompactionConfig } from "../types/contextTypes.js";
-export type { CompactionResult, CompactionConfig, } from "../types/contextTypes.js";
-export type CompactionStage = "prune" | "deduplicate" | "summarize" | "truncate";
+export type { CompactionConfig, CompactionResult, CompactionStage, } from "../types/contextTypes.js";
 export declare class ContextCompactor {
     private config;
     constructor(config?: CompactionConfig);

package/dist/context/contextCompactor.js

@@ -15,8 +15,8 @@ import { SpanSerializer, SpanType, SpanStatus, } from "../observability/index.js
 import { getMetricsAggregator } from "../observability/index.js";
 import { pruneToolOutputs } from "./stages/toolOutputPruner.js";
 import { deduplicateFileReads } from "./stages/fileReadDeduplicator.js";
-import { summarizeMessages } from "./stages/structuredSummarizer.js";
 import { truncateWithSlidingWindow } from "./stages/slidingWindowTruncator.js";
+import { summarizeMessages } from "./stages/structuredSummarizer.js";
 const DEFAULT_CONFIG = {
     enablePrune: true,
     enableDeduplicate: true,
@@ -106,6 +106,7 @@ export class ContextCompactor {
                         model: this.config.summarizationModel,
                         keepRecentRatio: this.config.keepRecentRatio,
                         memoryConfig,
+                        targetTokens,
                     }), 120_000, "LLM summarization timed out after 120s");
                     if (summarizeResult.summarized) {
                         currentMessages = summarizeResult.messages;
@@ -146,6 +147,11 @@ export class ContextCompactor {
                 const stageTokensBefore = estimateMessagesTokens(currentMessages, provider);
                 const truncResult = truncateWithSlidingWindow(currentMessages, {
                     fraction: this.config.truncationFraction,
+                    currentTokens: stageTokensBefore,
+                    targetTokens: targetTokens,
+                    provider: provider,
+                    adaptiveBuffer: 0.15,
+                    maxIterations: 3,
                 });
                 if (truncResult.truncated) {
                     currentMessages = truncResult.messages;

package/dist/context/prompts/summarizationPrompt.d.ts

@@ -1,12 +1,12 @@
 /**
  * Summarization Prompt Builder
  *
- * Builds prompts for summarizing conversation context into a 9-section structure.
+ * Builds prompts for summarizing conversation context into a 10-section structure.
  * Supports both initial summarization and incremental merging with existing summaries.
  */
 import type { SummarizationPromptOptions } from "../../types/contextTypes.js";
 export type { SummarizationPromptOptions } from "../../types/contextTypes.js";
-declare const NINE_SECTIONS: string[];
+declare const SUMMARY_SECTIONS: string[];
 /**
  * Builds a summarization prompt based on the provided options.
  *
@@ -14,4 +14,4 @@ declare const NINE_SECTIONS: string[];
  * @returns The constructed prompt string
  */
 export declare function buildSummarizationPrompt(options: SummarizationPromptOptions): string;
-export { NINE_SECTIONS };
+export { SUMMARY_SECTIONS };