@juspay/neurolink 7.29.1 → 7.29.2

package/dist/lib/neurolink.js

@@ -24,6 +24,7 @@ import { ProviderRegistry } from "./factories/providerRegistry.js";
 import { createCustomToolServerInfo, detectCategory, } from "./utils/mcpDefaults.js";
 // Factory processing imports
 import { processFactoryOptions, enhanceTextGenerationOptions, validateFactoryConfig, processStreamingFactoryOptions, createCleanStreamOptions, } from "./utils/factoryProcessing.js";
+// Tool detection and execution imports
 // Transformation utilities
 import { transformToolExecutions, transformToolExecutionsForMCP, transformAvailableTools, transformToolsForMCP, transformToolsToExpectedFormat, transformToolsToDescriptions, extractToolNames, transformParamsForLogging, optimizeToolForCollection, } from "./utils/transformationUtils.js";
 // Enhanced error handling imports
@@ -54,14 +55,21 @@ export class NeuroLink {
      * @param toolName - Name of the tool
      * @param startTime - Timestamp when tool execution started
      * @param success - Whether the tool execution was successful
+     * @param result - The result of the tool execution (optional)
+     * @param error - The error if execution failed (optional)
      */
-    emitToolEndEvent(toolName, startTime, success) {
+    emitToolEndEvent(toolName, startTime, success, result, error) {
+        // Emit tool end event (NeuroLink format - enhanced with result/error)
         this.emitter.emit("tool:end", {
             toolName,
             responseTime: Date.now() - startTime,
             success,
             timestamp: Date.now(),
+            result: result, // Enhanced: include actual result
+            error: error, // Enhanced: include error if present
         });
+        // ADD: Bedrock-compatible tool:end event (positional parameters)
+        this.emitter.emit("tool:end", toolName, success ? result : error);
     }
     // Conversation memory support
     conversationMemory;
@@ -816,11 +824,15 @@ export class NeuroLink {
             options.input.text = this.contextManager.getContextForPrompt("user", options.input.text);
         }
         const startTime = Date.now();
-        // Emit generation start event
+        // Emit generation start event (NeuroLink format - keep existing)
         this.emitter.emit("generation:start", {
             provider: options.provider || "auto",
             timestamp: startTime,
         });
+        // ADD: Bedrock-compatible response:start event
+        this.emitter.emit("response:start");
+        // ADD: Bedrock-compatible message event
+        this.emitter.emit("message", `Starting ${options.provider || "auto"} text generation...`);
         // Process factory configuration
         const factoryResult = processFactoryOptions(options);
         // Validate factory configuration if present
@@ -863,13 +875,18 @@ export class NeuroLink {
         }
         // Use redesigned generation logic
         const textResult = await this.generateTextInternal(textOptions);
-        // Emit generation completion event
+        // Emit generation completion event (NeuroLink format - enhanced with content)
         this.emitter.emit("generation:end", {
             provider: textResult.provider,
             responseTime: Date.now() - startTime,
             toolsUsed: textResult.toolsUsed,
             timestamp: Date.now(),
+            result: textResult, // Enhanced: include full result
         });
+        // ADD: Bedrock-compatible response:end event with content
+        this.emitter.emit("response:end", textResult.content || "");
+        // ADD: Bedrock-compatible message event
+        this.emitter.emit("message", `Generation completed in ${Date.now() - startTime}ms`);
         // Convert back to GenerateResult
         const generateResult = {
             content: textResult.content,
@@ -1002,6 +1019,10 @@ export class NeuroLink {
             promptLength: options.prompt?.length || 0,
             hasConversationMemory: !!this.conversationMemory,
         });
+        // ADD: Bedrock-compatible response:start event for generateTextInternal
+        this.emitter.emit("response:start");
+        // ADD: Bedrock-compatible message event for generateTextInternal
+        this.emitter.emit("message", `Starting ${options.provider || "auto"} text generation (internal)...`);
         try {
             // 🚀 EXHAUSTIVE LOGGING POINT G002: CONVERSATION MEMORY INITIALIZATION
             const conversationMemoryStartTime = process.hrtime.bigint();
@@ -1148,6 +1169,8 @@ export class NeuroLink {
                             });
                             // Store conversation turn
                             await storeConversationTurn(this.conversationMemory, options, mcpResult);
+                            // ADD: Bedrock-compatible response:end event for MCP success path
+                            this.emitter.emit("response:end", mcpResult.content || "");
                             return mcpResult;
                         }
                         else {
@@ -1164,6 +1187,8 @@ export class NeuroLink {
                                 logger.debug(`[${functionTag}] Found tool executions but no content, continuing with result`);
                                 // Store conversation turn even with empty content if tools executed
                                 await storeConversationTurn(this.conversationMemory, options, mcpResult);
+                                // ADD: Bedrock-compatible response:end event for MCP tool execution success path
+                                this.emitter.emit("response:end", mcpResult.content || "");
                                 return mcpResult;
                             }
                         }
@@ -1188,12 +1213,20 @@ export class NeuroLink {
             logger.debug(`[${functionTag}] Direct generation successful`);
             // Store conversation turn
             await storeConversationTurn(this.conversationMemory, options, directResult);
+            // ADD: Bedrock-compatible response:end event for generateTextInternal
+            this.emitter.emit("response:end", directResult.content || "");
+            // ADD: Bedrock-compatible message event for generateTextInternal completion
+            this.emitter.emit("message", `Text generation completed successfully`);
             return directResult;
         }
         catch (error) {
             logger.error(`[${functionTag}] All generation methods failed`, {
                 error: error instanceof Error ? error.message : String(error),
             });
+            // ADD: Bedrock-compatible response:end event for error path (empty content)
+            this.emitter.emit("response:end", "");
+            // ADD: Centralized error event emission
+            this.emitter.emit("error", error instanceof Error ? error : new Error(String(error)));
             throw error;
         }
     }
@@ -1299,6 +1332,9 @@ export class NeuroLink {
             // Create provider and generate
             const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
             this);
+            // ADD: Emit connection events for all providers (Bedrock-compatible)
+            this.emitter.emit("connected");
+            this.emitter.emit("message", `${providerName} provider initialized successfully`);
             // Enable tool execution for the provider using BaseProvider method
             provider.setupToolExecutor({
                 customTools: this.getCustomTools(),
@@ -1393,6 +1429,9 @@ export class NeuroLink {
                 const conversationMessages = await getConversationMessages(this.conversationMemory, options);
                 const provider = await AIProviderFactory.createProvider(providerName, options.model, !options.disableTools, // Pass disableTools as inverse of enableMCP
                 this);
+                // ADD: Emit connection events for successful provider creation (Bedrock-compatible)
+                this.emitter.emit("connected");
+                this.emitter.emit("message", `${providerName} provider initialized successfully`);
                 // Enable tool execution for direct provider generation using BaseProvider method
                 provider.setupToolExecutor({
                     customTools: this.getCustomTools(),
@@ -1454,7 +1493,7 @@ export class NeuroLink {
      * Execute tools if available through centralized registry
      * Simplified approach without domain detection - relies on tool registry
      */
-    async detectAndExecuteTools(prompt, domainType) {
+    async detectAndExecuteTools(prompt, _domainType) {
         const functionTag = "NeuroLink.detectAndExecuteTools";
         try {
             // Simplified: Just return original prompt without complex detection
@@ -1669,7 +1708,7 @@ export class NeuroLink {
                         global.gc();
                         return process.memoryUsage();
                     }
-                    catch (e) {
+                    catch (_e) {
                         return null;
                     }
                 })()
@@ -1807,11 +1846,15 @@ export class NeuroLink {
             cpuAfterValidation: process.cpuUsage(),
             message: "EXHAUSTIVE validation success - proceeding with stream processing",
         });
-        // Emit stream start event
+        // Emit stream start event (NeuroLink format - keep existing)
         this.emitter.emit("stream:start", {
             provider: options.provider || "auto",
             timestamp: startTime,
         });
+        // ADD: Bedrock-compatible response:start event
+        this.emitter.emit("response:start");
+        // ADD: Bedrock-compatible message event
+        this.emitter.emit("message", `Starting ${options.provider || "auto"} stream generation...`);
         // Process factory configuration for streaming
         const factoryResult = processFactoryOptions(options);
         const streamingResult = processStreamingFactoryOptions(options);
@@ -1903,6 +1946,8 @@ export class NeuroLink {
                             // Ensure chunk has content property and it's a string
                             if (typeof chunk.content === "string") {
                                 accumulatedContent += chunk.content;
+                                // ADD: Bedrock-compatible response:chunk event
+                                self.emitter.emit("response:chunk", chunk.content);
                             }
                             else if (chunk.content === undefined ||
                                 chunk.content === null) {
@@ -1914,6 +1959,8 @@ export class NeuroLink {
                                 const stringContent = String(chunk.content || "");
                                 processedChunk = { ...chunk, content: stringContent };
                                 accumulatedContent += stringContent;
+                                // ADD: Bedrock-compatible response:chunk event
+                                self.emitter.emit("response:chunk", stringContent);
                             }
                         }
                         else if (chunk === null || chunk === undefined) {
@@ -1950,11 +1997,16 @@ export class NeuroLink {
                 responseTime,
                 provider: providerName,
             });
-            // Emit stream completion event
+            // Emit stream completion event (NeuroLink format - enhanced with content)
             this.emitter.emit("stream:end", {
                 provider: providerName,
                 responseTime,
+                result: { content: accumulatedContent }, // Enhanced: include accumulated content
             });
+            // ADD: Bedrock-compatible response:end event with full response
+            this.emitter.emit("response:end", accumulatedContent);
+            // ADD: Bedrock-compatible message event
+            this.emitter.emit("message", `Stream completed in ${responseTime}ms (${accumulatedContent.length} chars)`);
             // Convert to StreamResult format - Include analytics and evaluation from provider
             return {
                 stream: processedStream,
@@ -1983,6 +2035,8 @@ export class NeuroLink {
             };
         }
         catch (error) {
+            // ADD: Error event emission for MCP streaming failure
+            this.emitter.emit("error", error instanceof Error ? error : new Error(String(error)));
             // Fall back to regular streaming if MCP fails
             mcpLogger.warn(`[${functionTag}] MCP streaming failed, falling back to regular`, {
                 error: error instanceof Error ? error.message : String(error),
@@ -2018,6 +2072,8 @@ export class NeuroLink {
                     for await (const chunk of streamResult.stream) {
                         if (chunk && typeof chunk.content === "string") {
                             fallbackAccumulatedContent += chunk.content;
+                            // ADD: Bedrock-compatible response:chunk event for fallback
+                            self.emitter.emit("response:chunk", chunk.content);
                         }
                         yield chunk; // Preserve original streaming behavior
                     }
@@ -2045,12 +2101,17 @@ export class NeuroLink {
                 }
             })(this);
             const responseTime = Date.now() - startTime;
-            // Emit stream completion event for fallback
+            // Emit stream completion event for fallback (NeuroLink format - enhanced with content)
             this.emitter.emit("stream:end", {
                 provider: providerName,
                 responseTime,
                 fallback: true,
+                result: { content: fallbackAccumulatedContent }, // Enhanced: include accumulated content
             });
+            // ADD: Bedrock-compatible response:end event with full response
+            this.emitter.emit("response:end", fallbackAccumulatedContent);
+            // ADD: Bedrock-compatible message event
+            this.emitter.emit("message", `Fallback stream completed in ${responseTime}ms (${fallbackAccumulatedContent.length} chars)`);
             return {
                 stream: fallbackProcessedStream,
                 provider: providerName,
@@ -2271,7 +2332,7 @@ export class NeuroLink {
             timestamp: Date.now(),
         });
         try {
-            // --- Start: Added Validation Logic ---
+            // --- Start: Enhanced Validation Logic with FlexibleToolValidator ---
             if (!name || typeof name !== "string") {
                 throw new Error("Invalid tool name");
             }
@@ -2281,55 +2342,36 @@ export class NeuroLink {
             if (typeof tool.execute !== "function") {
                 throw new Error(`Tool '${name}' must have an execute method.`);
             }
-            // --- End: Added Validation Logic ---
-            // Import validation functions synchronously - they are pure functions
-            let validateTool;
-            let isToolNameAvailable;
-            let suggestToolNames;
+            // Use FlexibleToolValidator for consistent validation across SDK and toolRegistry
             try {
-                // Try ES module import first
-                const toolRegistrationModule = require("./sdk/toolRegistration.js");
-                ({ validateTool, isToolNameAvailable, suggestToolNames } =
-                    toolRegistrationModule);
+                const flexibleValidatorModule = require("./mcp/flexibleToolValidator.js");
+                const FlexibleToolValidator = flexibleValidatorModule.FlexibleToolValidator;
+                // Use the same validation logic as toolRegistry (static method)
+                const validationResult = FlexibleToolValidator.validateToolName(name);
+                if (!validationResult.isValid) {
+                    throw new Error(`Tool validation failed: ${validationResult.error}`);
+                }
             }
             catch (error) {
-                // Fallback: skip validation if import fails (graceful degradation)
-                logger.warn("Tool validation module not available, skipping advanced validation", {
+                // If FlexibleToolValidator import fails, use basic safety checks
+                logger.warn("FlexibleToolValidator not available, using basic validation", {
                     error: error instanceof Error ? error.message : String(error),
                 });
-                // Create minimal validation functions
-                validateTool = () => { }; // No-op
-                isToolNameAvailable = () => true; // Allow all names
-                suggestToolNames = () => ["alternative_tool"];
-            }
-            // Check if tool name is available (not reserved)
-            if (!isToolNameAvailable(name)) {
-                const suggestions = suggestToolNames(name);
-                throw new Error(`Tool name '${name}' is not available (reserved or invalid format). ` +
-                    `Suggested alternatives: ${suggestions.slice(0, 3).join(", ")}`);
-            }
-            // Create a simplified tool object for validation
-            const toolForValidation = {
-                description: tool.description || "",
-                execute: async (params) => {
-                    if (tool.execute) {
-                        const result = await tool.execute(params);
-                        return result;
-                    }
-                    return "";
-                },
-                parameters: tool.inputSchema,
-                metadata: {
-                    category: "custom",
-                },
-            };
-            // Use comprehensive validation logic
-            try {
-                validateTool(name, toolForValidation);
-            }
-            catch (error) {
-                throw new Error(`Tool registration failed: ${error instanceof Error ? error.message : String(error)}`);
+                // Basic safety checks to prevent obvious issues
+                if (name.trim() === "") {
+                    throw new Error("Tool name cannot be empty");
+                }
+                if (name.length > 100) {
+                    throw new Error("Tool name is too long (maximum 100 characters)");
+                }
+                // eslint-disable-next-line no-control-regex
+                if (/[\x00-\x1F\x7F]/.test(name)) {
+                    throw new Error("Tool name contains invalid control characters");
+                }
             }
+            // --- End: Enhanced Validation Logic ---
+            // Tool object validation is now handled by FlexibleToolValidator above
+            // Proceed with tool registration since validation passed
             // SMART DEFAULTS: Use utility to eliminate boilerplate creation
             const mcpServerInfo = createCustomToolServerInfo(name, tool);
             // Register with toolRegistry using MCPServerInfo directly
@@ -2489,11 +2531,14 @@ export class NeuroLink {
                 : params,
             hasExternalManager: !!this.externalServerManager,
         });
-        // Emit tool start event
+        // Emit tool start event (NeuroLink format - keep existing)
         this.emitter.emit("tool:start", {
             toolName,
             timestamp: executionStartTime,
+            input: params, // Enhanced: add input parameters
         });
+        // ADD: Bedrock-compatible tool:start event (positional parameters)
+        this.emitter.emit("tool:start", toolName, params);
         // Set default options
         const finalOptions = {
             timeout: options?.timeout || 30000, // 30 second default timeout
@@ -2519,13 +2564,15 @@ export class NeuroLink {
             });
         }
         const metrics = this.toolExecutionMetrics.get(toolName);
-        metrics.totalExecutions++;
+        if (metrics) {
+            metrics.totalExecutions++;
+        }
         try {
             mcpLogger.debug(`[${functionTag}] Executing tool: ${toolName}`, {
                 toolName,
                 params,
                 options: finalOptions,
-                circuitBreakerState: circuitBreaker.getState(),
+                circuitBreakerState: circuitBreaker?.getState(),
             });
             // Execute with circuit breaker, timeout, and retry logic
             const result = await circuitBreaker.execute(async () => {
@@ -2546,12 +2593,14 @@ export class NeuroLink {
             });
             // Update success metrics
             const executionTime = Date.now() - executionStartTime;
-            metrics.successfulExecutions++;
-            metrics.lastExecutionTime = executionTime;
-            metrics.averageExecutionTime =
-                (metrics.averageExecutionTime * (metrics.successfulExecutions - 1) +
-                    executionTime) /
-                    metrics.successfulExecutions;
+            if (metrics) {
+                metrics.successfulExecutions++;
+                metrics.lastExecutionTime = executionTime;
+                metrics.averageExecutionTime =
+                    (metrics.averageExecutionTime * (metrics.successfulExecutions - 1) +
+                        executionTime) /
+                        metrics.successfulExecutions;
+            }
             // Track memory usage
             const endMemory = MemoryManager.getMemoryUsageMB();
             const memoryDelta = endMemory.heapUsed - startMemory.heapUsed;
@@ -2566,15 +2615,17 @@ export class NeuroLink {
                 toolName,
                 executionTime,
                 memoryDelta,
-                circuitBreakerState: circuitBreaker.getState(),
+                circuitBreakerState: circuitBreaker?.getState(),
             });
             // Emit tool end event using the helper method
-            this.emitToolEndEvent(toolName, executionStartTime, true);
+            this.emitToolEndEvent(toolName, executionStartTime, true, result);
             return result;
         }
         catch (error) {
             // Update failure metrics
-            metrics.failedExecutions++;
+            if (metrics) {
+                metrics.failedExecutions++;
+            }
             const executionTime = Date.now() - executionStartTime;
             // Create structured error
             let structuredError;
@@ -2605,8 +2656,10 @@ export class NeuroLink {
             else {
                 structuredError = ErrorFactory.toolExecutionFailed(toolName, new Error(String(error)));
             }
+            // ADD: Centralized error event emission
+            this.emitter.emit("error", structuredError);
             // Emit tool end event using the helper method
-            this.emitToolEndEvent(toolName, executionStartTime, false);
+            this.emitToolEndEvent(toolName, executionStartTime, false, undefined, structuredError);
             // Add execution context to structured error
             structuredError = new NeuroLinkError({
                 ...structuredError,
@@ -2615,8 +2668,8 @@ export class NeuroLink {
                     executionTime,
                     params,
                     options: finalOptions,
-                    circuitBreakerState: circuitBreaker.getState(),
-                    circuitBreakerFailures: circuitBreaker.getFailureCount(),
+                    circuitBreakerState: circuitBreaker?.getState(),
+                    circuitBreakerFailures: circuitBreaker?.getFailureCount(),
                     metrics: { ...metrics },
                 },
             });
@@ -2667,9 +2720,21 @@ export class NeuroLink {
                 userId: "neurolink-user",
             };
             const result = (await toolRegistry.executeTool(toolName, params, context));
+            // ADD: Check if result indicates a failure and emit error event
+            if (result &&
+                typeof result === "object" &&
+                "success" in result &&
+                result.success === false) {
+                const errorMessage = result.error || "Tool execution failed";
+                const errorToEmit = new Error(errorMessage);
+                this.emitter.emit("error", errorToEmit);
+            }
             return result;
         }
         catch (error) {
+            // ADD: Emergency error event emission (fallback)
+            const errorToEmit = error instanceof Error ? error : new Error(String(error));
+            this.emitter.emit("error", errorToEmit);
             // Check if tool was not found
             if (error instanceof Error && error.message.includes("not found")) {
                 const availableTools = await this.getAllAvailableTools();
@@ -2841,6 +2906,9 @@ export class NeuroLink {
         }
         const { AIProviderFactory } = await import("./core/factory.js");
         const { hasProviderEnvVars } = await import("./utils/providerUtils.js");
+        // Keep references to prevent unused variable warnings
+        void AIProviderFactory;
+        void hasProviderEnvVars;
         const providers = [
             "openai",
             "bedrock",
@@ -3103,7 +3171,7 @@ export class NeuroLink {
             const inMemoryServers = this.getInMemoryServers();
             if (inMemoryServers.has(serverId)) {
                 const serverInfo = inMemoryServers.get(serverId);
-                return !!(serverInfo.tools && serverInfo.tools.length > 0);
+                return !!(serverInfo?.tools && serverInfo.tools.length > 0);
             }
             // Test external MCP servers
             const externalServer = this.externalServerManager.getServer(serverId);
@@ -3610,7 +3678,7 @@ export class NeuroLink {
      * Convert JSON Schema to AI SDK compatible format
      * For now, we'll skip schema validation and let the AI SDK handle parameters dynamically
      */
-    convertJSONSchemaToAISDKFormat(inputSchema) {
+    convertJSONSchemaToAISDKFormat(_inputSchema) {
         // The simplest approach: don't provide parameters schema
         // This lets the AI SDK handle the tool without schema validation
         // Tools will still work, they just won't have strict parameter validation

package/dist/lib/providers/amazonBedrock.d.ts

@@ -3,29 +3,70 @@ import { type LanguageModelV1 } from "ai";
 import type { AIProviderName } from "../core/types.js";
 import type { StreamOptions, StreamResult } from "../types/streamTypes.js";
 import { BaseProvider } from "../core/baseProvider.js";
+import { AWSCredentialProvider } from "./aws/credentialProvider.js";
+import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
+import type { AWSCredentialConfig } from "../types/providers.js";
+import type { NeuroLink } from "../neurolink.js";
 /**
- * Amazon Bedrock Provider v2 - BaseProvider Implementation
+ * Amazon Bedrock Provider v3 - Enhanced Authentication Implementation
  *
- * PHASE 3.3: Simple BaseProvider wrap around existing @ai-sdk/amazon-bedrock implementation
+ * BEDROCK-MCP-CONNECTOR COMPATIBILITY: Complete AWS SDK credential chain support
  *
  * Features:
  * - Extends BaseProvider for shared functionality
- * - Preserves existing AWS credential configuration
- * - Maintains inference profile ARN support
- * - Uses pre-initialized Bedrock instance for efficiency
+ * - AWS SDK v3 defaultProvider credential chain (9 sources)
+ * - Dual access: AI SDK + Direct AWS SDK BedrockRuntimeClient
+ * - Full backward compatibility with existing configurations
  * - Enhanced error handling with setup guidance
+ * - Bedrock-MCP-Connector compatible authentication patterns
  */
 export declare class AmazonBedrockProvider extends BaseProvider {
+    private awsCredentialProvider;
+    private bedrockClient;
     private bedrock;
     private model;
-    constructor(modelName?: string);
+    constructor(modelName?: string, credentialConfig?: AWSCredentialConfig, neurolink?: NeuroLink);
+    /**
+     * Legacy AWS configuration for backward compatibility
+     */
+    private createLegacyAWSConfig;
     protected getProviderName(): AIProviderName;
     protected getDefaultModel(): string;
     /**
      * Returns the Vercel AI SDK model instance for AWS Bedrock
      */
     protected getAISDKModel(): LanguageModelV1;
+    /**
+     * Get AWS SDK BedrockRuntimeClient for direct access (Bedrock-MCP-Connector compatibility)
+     * This provides the same direct AWS SDK access that Bedrock-MCP-Connector uses
+     */
+    getBedrockClient(): BedrockRuntimeClient;
+    /**
+     * Get AWS SDK BedrockRuntimeClient with proxy support ensured
+     * Use this method when proxy support is critical for the operation
+     */
+    getBedrockClientWithProxy(): Promise<BedrockRuntimeClient>;
+    /**
+     * Get AWS credential provider for advanced credential management
+     */
+    getCredentialProvider(): AWSCredentialProvider;
+    /**
+     * Ensure proxy support is configured for AWS SDK client if needed
+     */
+    private ensureProxySupport;
+    /**
+     * Test AWS credentials and Bedrock connectivity
+     * Useful for debugging authentication issues
+     */
+    testConnectivity(): Promise<{
+        credentialsValid: boolean;
+        bedrockAccessible: boolean;
+        credentialSource: string;
+        error?: string;
+        responseTime?: number;
+    }>;
     protected executeStream(options: StreamOptions, _analysisSchema?: ZodUnknownSchema): Promise<StreamResult>;
+    protected handleStreamError(error: unknown): Error;
     protected handleProviderError(error: unknown): Error;
 }
 export default AmazonBedrockProvider;