@juspay/neurolink 2.0.0 → 3.0.0

package/dist/lib/providers/agent-enhanced-provider.js

@@ -9,6 +9,7 @@ import { anthropic } from "@ai-sdk/anthropic";
 import { getToolsForCategory, } from "../agent/direct-tools.js";
 import { UnifiedMCPSystem } from "../mcp/unified-mcp.js";
 import { mcpLogger } from "../mcp/logging.js";
+import { parseTimeout } from "../utils/timeout.js";
 /**
  * Agent-Enhanced Provider Class
  * Provides AI generation with tool calling capabilities
@@ -65,14 +66,15 @@ export class AgentEnhancedProvider {
         try {
             mcpLogger.info("[AgentEnhancedProvider] Initializing MCP integration...");
             this.mcpSystem = new UnifiedMCPSystem({
-                configPath: this.config.mcpDiscoveryOptions?.configFiles?.[0] || ".mcp-config.json",
+                configPath: this.config.mcpDiscoveryOptions?.configFiles?.[0] ||
+                    ".mcp-config.json",
                 enableExternalServers: true,
                 enableInternalServers: true,
-                autoInitialize: false
+                autoInitialize: false,
             });
             // ADD TIMEOUT to prevent hanging forever
             const initPromise = this.mcpSystem.initialize();
-            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('MCP initialization timeout after 15 seconds')), this.config.mcpInitTimeoutMs || 15000));
+            const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("MCP initialization timeout after 15 seconds")), this.config.mcpInitTimeoutMs || 15000));
             await Promise.race([initPromise, timeoutPromise]);
             this.mcpInitialized = true;
             mcpLogger.info("[AgentEnhancedProvider] MCP integration initialized successfully");
@@ -100,10 +102,13 @@ export class AgentEnhancedProvider {
             return directTools;
         }
         // Get MCP tools if available
-        let mcpTools = {};
+        const mcpTools = {};
         try {
             // Skip if MCP failed to initialize or is still initializing
-            if (this.mcpInitFailed || this.mcpInitializing || !this.mcpInitialized || !this.mcpSystem) {
+            if (this.mcpInitFailed ||
+                this.mcpInitializing ||
+                !this.mcpInitialized ||
+                !this.mcpSystem) {
                 return directTools;
             }
             const mcpToolInfos = await this.mcpSystem.listTools();
@@ -114,33 +119,51 @@ export class AgentEnhancedProvider {
                     description: toolInfo.description || `MCP tool: ${toolInfo.name}`,
                     parameters: toolInfo.inputSchema || {},
                     execute: async (args) => {
+                        let timeoutId;
                         try {
+                            // Create timeout controller for tool execution if configured
+                            const toolTimeout = this.config.toolExecutionTimeout;
+                            const toolAbortController = toolTimeout
+                                ? new AbortController()
+                                : undefined;
+                            if (toolAbortController && toolTimeout) {
+                                const timeoutMs = typeof toolTimeout === "string"
+                                    ? parseTimeout(toolTimeout)
+                                    : toolTimeout;
+                                timeoutId = setTimeout(() => {
+                                    toolAbortController.abort();
+                                }, timeoutMs);
+                            }
                             const context = {
-                                sessionId: 'cli-session',
-                                userId: 'cli-user',
+                                sessionId: "cli-session",
+                                userId: "cli-user",
                                 secureFS: {
                                     readFile: async (path, encoding) => {
-                                        const fs = await import('fs/promises');
-                                        return encoding ? fs.readFile(path, { encoding: encoding }) : fs.readFile(path);
+                                        const fs = await import("fs/promises");
+                                        return encoding
+                                            ? fs.readFile(path, {
+                                                encoding: encoding,
+                                            })
+                                            : fs.readFile(path);
                                     },
                                     writeFile: async (path, content) => {
-                                        const fs = await import('fs/promises');
+                                        const fs = await import("fs/promises");
                                         await fs.writeFile(path, content);
                                     },
                                     readdir: async (path) => {
-                                        const fs = await import('fs/promises');
+                                        const fs = await import("fs/promises");
                                         return fs.readdir(path);
                                     },
                                     stat: async (path) => {
-                                        const fs = await import('fs/promises');
+                                        const fs = await import("fs/promises");
                                         return fs.stat(path);
                                     },
                                     mkdir: async (path, options) => {
-                                        const fs = await import('fs/promises');
+                                        const fs = await import("fs/promises");
                                         await fs.mkdir(path, options);
                                     },
                                     exists: async (path) => {
-                                        const fs = await import('fs/promises');
+                                        const fs = await import("fs/promises");
                                         try {
                                             await fs.access(path);
                                             return true;
@@ -148,34 +171,34 @@ export class AgentEnhancedProvider {
                                         catch {
                                             return false;
                                         }
-                                    }
+                                    },
                                 },
                                 path: {
                                     join: (...paths) => {
-                                        const path = require('path');
+                                        const path = require("path");
                                         return path.join(...paths);
                                     },
                                     resolve: (...paths) => {
-                                        const path = require('path');
+                                        const path = require("path");
                                         return path.resolve(...paths);
                                     },
                                     relative: (from, to) => {
-                                        const path = require('path');
+                                        const path = require("path");
                                         return path.relative(from, to);
                                     },
                                     dirname: (path) => {
-                                        const pathLib = require('path');
+                                        const pathLib = require("path");
                                         return pathLib.dirname(path);
                                     },
                                     basename: (path, ext) => {
-                                        const pathLib = require('path');
+                                        const pathLib = require("path");
                                         return pathLib.basename(path, ext);
-                                    }
+                                    },
                                 },
-                                grantedPermissions: ['read', 'write', 'execute'],
+                                grantedPermissions: ["read", "write", "execute"],
                                 log: (level, message, data) => {
                                     const logFn = mcpLogger[level];
-                                    if (typeof logFn === 'function') {
+                                    if (typeof logFn === "function") {
                                         if (data) {
                                             logFn(`${message} ${JSON.stringify(data)}`);
                                         }
@@ -183,16 +206,39 @@ export class AgentEnhancedProvider {
                                             logFn(message);
                                         }
                                     }
-                                }
+                                },
                             };
-                            const result = await this.mcpSystem.executeTool(toolInfo.name, args, context);
+                            const toolPromise = this.mcpSystem.executeTool(toolInfo.name, args, context);
+                            let result;
+                            if (toolAbortController) {
+                                // Race between tool execution and timeout
+                                result = await Promise.race([
+                                    toolPromise,
+                                    new Promise((_, reject) => {
+                                        toolAbortController.signal.addEventListener("abort", () => {
+                                            reject(new Error(`Tool ${toolInfo.name} timed out after ${this.config.toolExecutionTimeout}`));
+                                        });
+                                    }),
+                                ]);
+                            }
+                            else {
+                                result = await toolPromise;
+                            }
+                            // Clear timeout if successful
+                            if (timeoutId) {
+                                clearTimeout(timeoutId);
+                            }
                             return result.data || result;
                         }
                         catch (error) {
+                            // Clear timeout on error
+                            if (timeoutId) {
+                                clearTimeout(timeoutId);
+                            }
                             mcpLogger.error(`MCP tool ${toolInfo.name} execution failed:`, error);
                             throw error;
                         }
-                    }
+                    },
                 };
             }
             mcpLogger.info(`[AgentEnhancedProvider] Loaded ${Object.keys(mcpTools).length} MCP tools`);
@@ -206,20 +252,26 @@ export class AgentEnhancedProvider {
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt, schema, } = options;
+        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt, schema, timeout, } = options;
         // Get combined tools (direct + MCP) if enabled
-        const tools = this.config.enableTools
-            ? await this.getCombinedTools()
-            : {};
+        const tools = this.config.enableTools ? await this.getCombinedTools() : {};
         const log = (msg, data) => {
-            mcpLogger.info(`[AgentEnhancedProvider] ${msg}`, data ? JSON.stringify(data, null, 2) : '');
+            mcpLogger.info(`[AgentEnhancedProvider] ${msg}`, data ? JSON.stringify(data, null, 2) : "");
         };
-        log('Starting text generation', {
+        log("Starting text generation", {
             prompt: prompt.substring(0, 100),
             toolsCount: Object.keys(tools).length,
-            maxSteps: this.config.maxSteps
+            maxSteps: this.config.maxSteps,
         });
         try {
+            // Parse timeout if provided
+            let abortSignal;
+            if (timeout) {
+                const timeoutMs = typeof timeout === "string" ? parseTimeout(timeout) : timeout;
+                if (timeoutMs !== undefined) {
+                    abortSignal = AbortSignal.timeout(timeoutMs);
+                }
+            }
             // The AI SDK with maxSteps automatically handles tool calling and result integration
             const result = await generateText({
                 model: this.model,
@@ -231,25 +283,28 @@ export class AgentEnhancedProvider {
                 temperature,
                 maxTokens,
                 toolChoice: this.shouldForceToolUsage(prompt) ? "required" : "auto",
+                abortSignal, // Pass abort signal for timeout support
             });
-            log('Generation completed', {
+            log("Generation completed", {
                 text: result.text?.substring(0, 200),
                 finishReason: result.finishReason,
                 toolCallsCount: result.toolCalls?.length || 0,
                 toolResultsCount: result.toolResults?.length || 0,
-                stepsCount: result.steps?.length || 0
+                stepsCount: result.steps?.length || 0,
             });
             // Check if tools were called but no final text was generated
-            if (result.finishReason === 'tool-calls' && !result.text && result.toolResults?.length > 0) {
-                log('Tools called but no final text generated, creating summary response');
+            if (result.finishReason === "tool-calls" &&
+                !result.text &&
+                result.toolResults?.length > 0) {
+                log("Tools called but no final text generated, creating summary response");
                 try {
                     // Extract tool results and create a summary prompt
-                    let toolResultsSummary = '';
+                    let toolResultsSummary = "";
                     if (result.toolResults) {
                         for (const toolResult of result.toolResults) {
                             const resultData = toolResult.result || toolResult;
                             // Try to extract meaningful data from the result
-                            if (typeof resultData === 'object' && resultData !== null) {
+                            if (typeof resultData === "object" && resultData !== null) {
                                 if (resultData.success && resultData.items) {
                                     // This looks like a filesystem listing
                                     toolResultsSummary += `Directory listing for ${resultData.path}:\n`;
@@ -264,34 +319,36 @@ export class AgentEnhancedProvider {
                             else {
                                 toolResultsSummary += String(resultData);
                             }
-                            toolResultsSummary += '\n\n';
+                            toolResultsSummary += "\n\n";
                         }
                     }
-                    log('Tool results extracted', {
+                    log("Tool results extracted", {
                         summaryLength: toolResultsSummary.length,
-                        preview: toolResultsSummary.substring(0, 200)
+                        preview: toolResultsSummary.substring(0, 200),
                     });
                     // Create a simple, direct summary
                     const finalText = `Based on the user request "${prompt}", here's what I found:\n\n${toolResultsSummary}`;
-                    log('Final text created', {
+                    log("Final text created", {
                         textLength: finalText.length,
-                        preview: finalText.substring(0, 200)
+                        preview: finalText.substring(0, 200),
                     });
                     // Return result with the formatted text
                     return {
                         ...result,
                         text: finalText,
-                        finishReason: 'stop'
+                        finishReason: "stop",
                     };
                 }
                 catch (error) {
-                    log('Error in summary generation', { error: error instanceof Error ? error.message : String(error) });
+                    log("Error in summary generation", {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
                     // Fallback: return raw tool results
                     const fallbackText = `Tool execution completed. Raw results: ${JSON.stringify(result.toolResults, null, 2)}`;
                     return {
                         ...result,
                         text: fallbackText,
-                        finishReason: 'stop'
+                        finishReason: "stop",
                     };
                 }
             }
@@ -307,12 +364,18 @@ export class AgentEnhancedProvider {
         const options = typeof optionsOrPrompt === "string"
             ? { prompt: optionsOrPrompt }
             : optionsOrPrompt;
-        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt, } = options;
+        const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt, timeout, } = options;
         // Get combined tools (direct + MCP) if enabled
-        const tools = this.config.enableTools
-            ? await this.getCombinedTools()
-            : {};
+        const tools = this.config.enableTools ? await this.getCombinedTools() : {};
         try {
+            // Parse timeout if provided
+            let abortSignal;
+            if (timeout) {
+                const timeoutMs = typeof timeout === "string" ? parseTimeout(timeout) : timeout;
+                if (timeoutMs !== undefined) {
+                    abortSignal = AbortSignal.timeout(timeoutMs);
+                }
+            }
             const result = await streamText({
                 model: this.model,
                 prompt: systemPrompt
@@ -323,6 +386,7 @@ export class AgentEnhancedProvider {
                 temperature,
                 maxTokens,
                 toolChoice: this.shouldForceToolUsage(prompt) ? "required" : "auto",
+                abortSignal, // Pass abort signal for timeout support
             });
             return result;
         }

package/dist/lib/providers/amazonBedrock.js

@@ -1,6 +1,7 @@
 import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
 import { streamText, generateText, Output, } from "ai";
 import { logger } from "../utils/logger.js";
+import { createTimeoutController, TimeoutError, getDefaultTimeout, } from "../utils/timeout.js";
 // Default system context
 const DEFAULT_SYSTEM_CONTEXT = {
     systemPrompt: "You are a helpful AI assistant.",
@@ -128,7 +129,7 @@ export class AmazonBedrock {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, } = options;
+            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "stream"), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Stream request started`, {
@@ -137,13 +138,20 @@ export class AmazonBedrock {
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
+                timeout,
             });
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, provider, "stream");
             const streamOptions = {
                 model: this.model,
                 prompt: prompt,
                 system: systemPrompt,
                 temperature,
                 maxTokens,
+                // Add abort signal if available
+                ...(timeoutController && {
+                    abortSignal: timeoutController.controller.signal,
+                }),
                 onError: (event) => {
                     const error = event.error;
                     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -193,16 +201,30 @@ export class AmazonBedrock {
                 modelName: this.modelName,
                 promptLength: prompt.length,
             });
+            // For streaming, we can't clean up immediately, but the timeout will auto-clean
+            // The user should handle the stream and any timeout errors
             return result;
         }
         catch (err) {
-            logger.error(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                region: getAWSRegion(),
-                message: "Error in streaming text",
-                err: String(err),
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    region: getAWSRegion(),
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.error(`[${functionTag}] Exception`, {
+                    provider,
+                    modelName: this.modelName,
+                    region: getAWSRegion(),
+                    message: "Error in streaming text",
+                    err: String(err),
+                });
+            }
             throw err; // Re-throw error to trigger fallback
         }
     }
@@ -214,7 +236,7 @@ export class AmazonBedrock {
             const options = typeof optionsOrPrompt === "string"
                 ? { prompt: optionsOrPrompt }
                 : optionsOrPrompt;
-            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, } = options;
+            const { prompt, temperature = 0.7, maxTokens = 1000, systemPrompt = DEFAULT_SYSTEM_CONTEXT.systemPrompt, schema, timeout = getDefaultTimeout(provider, "generate"), } = options;
             // Use schema from options or fallback parameter
             const finalSchema = schema || analysisSchema;
             logger.debug(`[${functionTag}] Generate text started`, {
@@ -224,36 +246,64 @@ export class AmazonBedrock {
                 promptLength: prompt.length,
                 temperature,
                 maxTokens,
+                timeout,
             });
+            // Create timeout controller if timeout is specified
+            const timeoutController = createTimeoutController(timeout, provider, "generate");
             const generateOptions = {
                 model: this.model,
                 prompt: prompt,
                 system: systemPrompt,
                 temperature,
                 maxTokens,
+                // Add abort signal if available
+                ...(timeoutController && {
+                    abortSignal: timeoutController.controller.signal,
+                }),
             };
             if (finalSchema) {
                 generateOptions.experimental_output = Output.object({
                     schema: finalSchema,
                 });
             }
-            const result = await generateText(generateOptions);
-            logger.debug(`[${functionTag}] Generate text completed`, {
-                provider,
-                modelName: this.modelName,
-                usage: result.usage,
-                finishReason: result.finishReason,
-                responseLength: result.text?.length || 0,
-            });
-            return result;
+            try {
+                const result = await generateText(generateOptions);
+                // Clean up timeout if successful
+                timeoutController?.cleanup();
+                logger.debug(`[${functionTag}] Generate text completed`, {
+                    provider,
+                    modelName: this.modelName,
+                    usage: result.usage,
+                    finishReason: result.finishReason,
+                    responseLength: result.text?.length || 0,
+                    timeout,
+                });
+                return result;
+            }
+            finally {
+                // Always cleanup timeout
+                timeoutController?.cleanup();
+            }
         }
         catch (err) {
-            logger.error(`[${functionTag}] Exception`, {
-                provider,
-                modelName: this.modelName,
-                message: "Error in generating text",
-                err: String(err),
-            });
+            // Log timeout errors specifically
+            if (err instanceof TimeoutError) {
+                logger.error(`[${functionTag}] Timeout error`, {
+                    provider,
+                    modelName: this.modelName,
+                    region: getAWSRegion(),
+                    timeout: err.timeout,
+                    message: err.message,
+                });
+            }
+            else {
+                logger.error(`[${functionTag}] Exception`, {
+                    provider,
+                    modelName: this.modelName,
+                    message: "Error in generating text",
+                    err: String(err),
+                });
+            }
             throw err; // Re-throw error to trigger fallback instead of returning null
         }
     }