@juspay/neurolink 7.29.0 → 7.29.2

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [7.29.2](https://github.com/juspay/neurolink/compare/v7.29.1...v7.29.2) (2025-08-29)
+
+### Bug Fixes
+
+- **(providers):** enable drop-in replacement for bedrock-mcp-connector ([9b67d23](https://github.com/juspay/neurolink/commit/9b67d233c2e8400a401759e34ffaf46a9a9c77a8))
+
+## [7.29.1](https://github.com/juspay/neurolink/compare/v7.29.0...v7.29.1) (2025-08-28)
+
+### Bug Fixes
+
+- **(vertex):** restored support for adc ([238666a](https://github.com/juspay/neurolink/commit/238666ab907fc16945d5de6c5f79637be128f4e6))
+
 ## [7.29.0](https://github.com/juspay/neurolink/compare/v7.28.1...v7.29.0) (2025-08-26)
 
 ### Features

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

@@ -60,8 +60,8 @@ declare const ConfigSchema: z.ZodObject<{
         }, {
             model?: string | undefined;
             projectId?: string | undefined;
-            location?: string | undefined;
             credentials?: string | undefined;
+            location?: string | undefined;
             serviceAccountKey?: string | undefined;
             clientEmail?: string | undefined;
             privateKey?: string | undefined;
@@ -201,8 +201,8 @@ declare const ConfigSchema: z.ZodObject<{
         vertex?: {
             model?: string | undefined;
             projectId?: string | undefined;
-            location?: string | undefined;
             credentials?: string | undefined;
+            location?: string | undefined;
             serviceAccountKey?: string | undefined;
             clientEmail?: string | undefined;
             privateKey?: string | undefined;
@@ -570,8 +570,8 @@ declare const ConfigSchema: z.ZodObject<{
         vertex?: {
             model?: string | undefined;
             projectId?: string | undefined;
-            location?: string | undefined;
             credentials?: string | undefined;
+            location?: string | undefined;
             serviceAccountKey?: string | undefined;
             clientEmail?: string | undefined;
             privateKey?: string | undefined;

package/dist/cli/commands/mcp.js

@@ -10,6 +10,31 @@ import chalk from "chalk";
 import ora from "ora";
 import fs from "fs";
 import path from "path";
+// Using MCPCommandArgs from types/cli.ts
+/**
+ * Response interface for MCP status information returned from the NeuroLink SDK.
+ * This interface represents the raw status data that gets converted to CLI-friendly format.
+ *
+ * @interface MCPStatusResponse
+ * @since 7.6.1
+ *
+ * @example
+ * ```typescript
+ * const status: MCPStatusResponse = {
+ *   autoDiscoveredServers: [
+ *     {
+ *       name: "filesystem",
+ *       id: "fs-server-001",
+ *       status: "connected",
+ *       source: "claude-desktop"
+ *     }
+ *   ],
+ *   mcpInitialized: true,
+ *   totalServers: 3,
+ *   availableServers: 2
+ * };
+ * ```
+ */
 /**
  * Popular MCP servers registry
  */

package/dist/cli/factories/commandFactory.d.ts

@@ -8,6 +8,7 @@ export declare class CLICommandFactory {
     private static processOptions;
     private static handleOutput;
     private static isValidTokenUsage;
+    private static normalizeTokenUsage;
     private static formatAnalyticsForTextMode;
     /**
      * Create the new primary 'generate' command

package/dist/cli/factories/commandFactory.js

@@ -273,14 +273,53 @@ export class CLICommandFactory {
             logger.always(output);
         }
     }
-    // Helper method to validate token usage data
+    // Helper method to validate token usage data with fallback handling
     static isValidTokenUsage(tokens) {
-        return !!(tokens &&
-            typeof tokens === "object" &&
-            tokens !== null &&
-            typeof tokens.input === "number" &&
-            typeof tokens.output === "number" &&
-            typeof tokens.total === "number");
+        if (!tokens || typeof tokens !== "object" || tokens === null) {
+            return false;
+        }
+        const tokensObj = tokens;
+        // Check primary format: analytics.tokens {input, output, total}
+        if (typeof tokensObj.input === "number" &&
+            typeof tokensObj.output === "number" &&
+            typeof tokensObj.total === "number") {
+            return true;
+        }
+        // Check fallback format: tokenUsage {inputTokens, outputTokens, totalTokens}
+        if (typeof tokensObj.inputTokens === "number" &&
+            typeof tokensObj.outputTokens === "number" &&
+            typeof tokensObj.totalTokens === "number") {
+            return true;
+        }
+        return false;
+    }
+    // Helper method to normalize token usage data to standard format
+    static normalizeTokenUsage(tokens) {
+        if (!this.isValidTokenUsage(tokens)) {
+            return null;
+        }
+        const tokensObj = tokens;
+        // Primary format: analytics.tokens {input, output, total}
+        if (typeof tokensObj.input === "number" &&
+            typeof tokensObj.output === "number" &&
+            typeof tokensObj.total === "number") {
+            return {
+                input: tokensObj.input,
+                output: tokensObj.output,
+                total: tokensObj.total,
+            };
+        }
+        // Fallback format: tokenUsage {inputTokens, outputTokens, totalTokens}
+        if (typeof tokensObj.inputTokens === "number" &&
+            typeof tokensObj.outputTokens === "number" &&
+            typeof tokensObj.totalTokens === "number") {
+            return {
+                input: tokensObj.inputTokens,
+                output: tokensObj.outputTokens,
+                total: tokensObj.totalTokens,
+            };
+        }
+        return null;
     }
     // Helper method to format analytics for text mode display
     static formatAnalyticsForTextMode(result) {
@@ -299,10 +338,10 @@ export class CLICommandFactory {
             analyticsText += ` (${modelName})`;
         }
         analyticsText += "\n";
-        // Token usage
-        if (this.isValidTokenUsage(analytics.tokens)) {
-            const tokens = analytics.tokens;
-            analyticsText += `   Tokens: ${tokens.input} input + ${tokens.output} output = ${tokens.total} total\n`;
+        // Token usage with fallback handling
+        const normalizedTokens = this.normalizeTokenUsage(analytics.tokens);
+        if (normalizedTokens) {
+            analyticsText += `   Tokens: ${normalizedTokens.input} input + ${normalizedTokens.output} output = ${normalizedTokens.total} total\n`;
         }
         // Cost information
         if (analytics.cost !== undefined &&
@@ -310,9 +349,12 @@ export class CLICommandFactory {
             typeof analytics.cost === "number") {
             analyticsText += `   Cost: $${analytics.cost.toFixed(5)}\n`;
         }
-        // Response time
-        if (analytics.responseTime && typeof analytics.responseTime === "number") {
-            const timeInSeconds = (analytics.responseTime / 1000).toFixed(1);
+        // Response time with fallback handling for requestDuration vs responseTime
+        const duration = analytics.responseTime ||
+            analytics.requestDuration ||
+            analytics.duration;
+        if (duration && typeof duration === "number") {
+            const timeInSeconds = (duration / 1000).toFixed(1);
             analyticsText += `   Time: ${timeInSeconds}s\n`;
         }
         // Tools used
@@ -935,14 +977,66 @@ export class CLICommandFactory {
                     : undefined,
             });
             let fullContent = "";
-            // Process the stream
-            for await (const chunk of stream.stream) {
-                if (options.delay && options.delay > 0) {
-                    // Demo mode - add delay between chunks
-                    await new Promise((resolve) => setTimeout(resolve, options.delay));
+            let contentReceived = false;
+            const abortController = new AbortController();
+            // Create timeout promise for stream consumption (30 seconds)
+            const timeoutPromise = new Promise((_, reject) => {
+                const timeoutId = setTimeout(() => {
+                    if (!contentReceived) {
+                        const timeoutError = new Error("\n❌ Stream timeout - no content received within 30 seconds\n" +
+                            "This usually indicates authentication or network issues\n\n" +
+                            "🔧 Try these steps:\n" +
+                            "1. Check your provider credentials are configured correctly\n" +
+                            `2. Test generate mode: neurolink generate "test" --provider ${options.provider}\n` +
+                            `3. Use debug mode: neurolink stream "test" --provider ${options.provider} --debug`);
+                        reject(timeoutError);
+                    }
+                }, 30000);
+                // Clean up timeout when aborted
+                abortController.signal.addEventListener("abort", () => {
+                    clearTimeout(timeoutId);
+                });
+            });
+            try {
+                // Process the stream with timeout handling
+                const streamIterator = stream.stream[Symbol.asyncIterator]();
+                let timeoutActive = true;
+                while (true) {
+                    let nextResult;
+                    if (timeoutActive && !contentReceived) {
+                        // Race between next chunk and timeout for first chunk only
+                        nextResult = await Promise.race([
+                            streamIterator.next(),
+                            timeoutPromise,
+                        ]);
+                    }
+                    else {
+                        // No timeout for subsequent chunks
+                        nextResult = await streamIterator.next();
+                    }
+                    if (nextResult.done) {
+                        break;
+                    }
+                    if (!contentReceived) {
+                        contentReceived = true;
+                        timeoutActive = false;
+                        abortController.abort(); // Cancel timeout
+                    }
+                    if (options.delay && options.delay > 0) {
+                        // Demo mode - add delay between chunks
+                        await new Promise((resolve) => setTimeout(resolve, options.delay));
+                    }
+                    process.stdout.write(nextResult.value.content);
+                    fullContent += nextResult.value.content;
                 }
-                process.stdout.write(chunk.content);
-                fullContent += chunk.content;
+            }
+            catch (error) {
+                abortController.abort(); // Clean up timeout
+                throw error;
+            }
+            if (!contentReceived) {
+                throw new Error("\n❌ No content received from stream\n" +
+                    "Check your credentials and provider configuration");
             }
             if (!options.quiet) {
                 process.stdout.write("\n");

package/dist/cli/index.js

@@ -14,6 +14,14 @@ import { fileURLToPath } from "url";
 import { CLICommandFactory } from "./factories/commandFactory.js";
 import { AuthenticationError, AuthorizationError, NetworkError, RateLimitError, } from "../lib/types/errors.js";
 import { logger } from "../lib/utils/logger.js";
+// Clean up pnpm-specific environment variables that cause npm warnings
+// These variables are set by pnpm but cause "Unknown env config" warnings in npm
+if (process.env.npm_config_verify_deps_before_run) {
+    delete process.env.npm_config_verify_deps_before_run;
+}
+if (process.env.npm_config__jsr_registry) {
+    delete process.env.npm_config__jsr_registry;
+}
 // Get version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);

package/dist/core/factory.js

@@ -55,12 +55,18 @@ export class AIProviderFactory {
      * @returns AIProvider instance
      */
     static async createProvider(providerName, modelName, enableMCP = true, sdk) {
-        const functionTag = "AIawait ProviderFactory.createProvider";
+        const functionTag = "AIProviderFactory.createProvider";
         // Providers are registered via ProviderFactory.initialize() on first use
         logger.debug(`[${functionTag}] Provider creation started`, {
             providerName,
             modelName: modelName || "default",
             enableMCP,
+            environmentVariables: {
+                BEDROCK_MODEL: process.env.BEDROCK_MODEL || "not set",
+                BEDROCK_MODEL_ID: process.env.BEDROCK_MODEL_ID || "not set",
+                VERTEX_MODEL: process.env.VERTEX_MODEL || "not set",
+                OPENAI_MODEL: process.env.OPENAI_MODEL || "not set",
+            },
         });
         try {
             // DYNAMIC MODEL PROVIDER STATUS (2025): Enhanced with timeout handling
@@ -73,12 +79,57 @@ export class AIProviderFactory {
             //
             // The dynamic model provider now provides reliable functionality without hanging
             let resolvedModelName = modelName;
-            // Enable dynamic model resolution with timeout-protected initialization
+            // PRIORITY 1: Check environment variables BEFORE dynamic resolution
             if (!modelName || modelName === "default") {
+                logger.debug(`[${functionTag}] Checking environment variables for provider: ${providerName}`);
+                // Check for provider-specific environment variables first
+                if (providerName.toLowerCase().includes("bedrock")) {
+                    const envModel = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
+                    if (envModel) {
+                        resolvedModelName = envModel;
+                        logger.debug(`[${functionTag}] Environment variable found for Bedrock`, {
+                            envVariable: process.env.BEDROCK_MODEL
+                                ? "BEDROCK_MODEL"
+                                : "BEDROCK_MODEL_ID",
+                            resolvedModel: envModel,
+                        });
+                    }
+                    else {
+                        logger.debug(`[${functionTag}] No Bedrock environment variables found (BEDROCK_MODEL, BEDROCK_MODEL_ID)`);
+                    }
+                }
+                else if (providerName.toLowerCase().includes("vertex")) {
+                    const envModel = process.env.VERTEX_MODEL;
+                    if (envModel) {
+                        resolvedModelName = envModel;
+                        logger.debug(`[${functionTag}] Environment variable found for Vertex`, {
+                            envVariable: "VERTEX_MODEL",
+                            resolvedModel: envModel,
+                        });
+                    }
+                    else {
+                        logger.debug(`[${functionTag}] No Vertex environment variables found (VERTEX_MODEL)`);
+                    }
+                }
+                else {
+                    logger.debug(`[${functionTag}] Provider ${providerName} - no environment variable check implemented`);
+                }
+            }
+            else {
+                logger.debug(`[${functionTag}] Skipping environment variable check - explicit model provided: ${modelName}`);
+            }
+            // PRIORITY 2: Enable dynamic model resolution only if no env var found
+            if ((!resolvedModelName || resolvedModelName === "default") &&
+                (!modelName || modelName === "default")) {
+                logger.debug(`[${functionTag}] Attempting dynamic model resolution`, {
+                    currentResolvedModel: resolvedModelName || "none",
+                    reason: "No environment variable found and no explicit model provided",
+                });
                 try {
                     const normalizedProvider = this.normalizeProviderName(providerName);
                     // Initialize with timeout protection - won't hang anymore
                     if (dynamicModelProvider.needsRefresh()) {
+                        logger.debug(`[${functionTag}] Dynamic model provider needs refresh - initializing`);
                         await this.initializeDynamicProviderWithTimeout();
                     }
                     const dynamicModel = dynamicModelProvider.resolveModel(normalizedProvider, modelName || undefined);
@@ -92,6 +143,12 @@ export class AIProviderFactory {
                             pricing: dynamicModel.pricing.input,
                         });
                     }
+                    else {
+                        logger.debug(`[${functionTag}] Dynamic model resolution returned null`, {
+                            provider: normalizedProvider,
+                            requestedModel: modelName || "default",
+                        });
+                    }
                 }
                 catch (resolveError) {
                     logger.debug(`[${functionTag}] Dynamic model resolution failed, using static fallback`, {
@@ -102,6 +159,12 @@ export class AIProviderFactory {
                     // Continue with static model name - no functionality loss
                 }
             }
+            else {
+                logger.debug(`[${functionTag}] Skipping dynamic model resolution`, {
+                    resolvedModelName: resolvedModelName || "none",
+                    reason: "Model already resolved from environment variables or explicit parameter",
+                });
+            }
             // CRITICAL FIX: Initialize providers before using them
             await ProviderRegistry.registerAllProviders();
             // PURE FACTORY PATTERN: No switch statements - use ProviderFactory exclusively
@@ -109,8 +172,18 @@ export class AIProviderFactory {
             const finalModelName = resolvedModelName === "default" || resolvedModelName === null
                 ? undefined
                 : resolvedModelName;
+            logger.debug(`[${functionTag}] Final provider configuration`, {
+                originalProviderName: providerName,
+                normalizedProviderName: normalizedName,
+                originalModelName: modelName || "not provided",
+                resolvedModelName: resolvedModelName || "not resolved",
+                finalModelName: finalModelName || "using provider default",
+            });
             // Create provider with enhanced SDK
             const provider = await ProviderFactory.createProvider(normalizedName, finalModelName, sdk);
+            // Summary logging in format expected by debugging tools
+            logger.debug(`[AIProviderFactory] Provider creation completed { providerName: '${normalizedName}', modelName: '${finalModelName}' }`);
+            logger.debug(`[AIProviderFactory] Resolved model: ${finalModelName}`);
             logger.debug(componentIdentifier, "Pure factory pattern provider created", {
                 providerName: normalizedName,
                 modelName: finalModelName,
@@ -153,7 +226,7 @@ export class AIProviderFactory {
      * @returns AIProvider instance
      */
     static async createProviderWithModel(provider, model) {
-        const functionTag = "AIawait ProviderFactory.createProviderWithModel";
+        const functionTag = "AIProviderFactory.createProviderWithModel";
         logger.debug(`[${functionTag}] Provider model creation started`, {
             provider,
             model,
@@ -214,7 +287,7 @@ export class AIProviderFactory {
      * @returns Object with primary and fallback providers
      */
     static async createProviderWithFallback(primaryProvider, fallbackProvider, modelName, enableMCP = true) {
-        const functionTag = "AIawait ProviderFactory.createProviderWithFallback";
+        const functionTag = "AIProviderFactory.createProviderWithFallback";
         logger.debug(`[${functionTag}] Fallback provider setup started`, {
             primaryProvider,
             fallbackProvider,

package/dist/factories/providerFactory.js

@@ -42,6 +42,9 @@ export class ProviderFactory {
             if (providerName.toLowerCase().includes("vertex")) {
                 model = process.env.VERTEX_MODEL;
             }
+            else if (providerName.toLowerCase().includes("bedrock")) {
+                model = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
+            }
             // Fallback to registry default if no env var
             model = model || registration.defaultModel;
         }

package/dist/factories/providerRegistry.js

@@ -39,9 +39,9 @@ export class ProviderRegistry {
                 return new AnthropicProvider(modelName, sdk);
             }, "claude-3-5-sonnet-20241022", ["claude", "anthropic"]);
             // Register Amazon Bedrock provider
-            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName) => {
+            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName, _providerName, sdk) => {
                 const { AmazonBedrockProvider } = await import("../providers/amazonBedrock.js");
-                return new AmazonBedrockProvider(modelName);
+                return new AmazonBedrockProvider(modelName, undefined, sdk);
             }, undefined, // Let provider read BEDROCK_MODEL from .env
             ["bedrock", "aws"]);
             // Register Azure OpenAI provider

package/dist/lib/core/factory.js

@@ -55,12 +55,18 @@ export class AIProviderFactory {
      * @returns AIProvider instance
      */
     static async createProvider(providerName, modelName, enableMCP = true, sdk) {
-        const functionTag = "AIawait ProviderFactory.createProvider";
+        const functionTag = "AIProviderFactory.createProvider";
         // Providers are registered via ProviderFactory.initialize() on first use
         logger.debug(`[${functionTag}] Provider creation started`, {
             providerName,
             modelName: modelName || "default",
             enableMCP,
+            environmentVariables: {
+                BEDROCK_MODEL: process.env.BEDROCK_MODEL || "not set",
+                BEDROCK_MODEL_ID: process.env.BEDROCK_MODEL_ID || "not set",
+                VERTEX_MODEL: process.env.VERTEX_MODEL || "not set",
+                OPENAI_MODEL: process.env.OPENAI_MODEL || "not set",
+            },
         });
         try {
             // DYNAMIC MODEL PROVIDER STATUS (2025): Enhanced with timeout handling
@@ -73,12 +79,57 @@ export class AIProviderFactory {
             //
             // The dynamic model provider now provides reliable functionality without hanging
             let resolvedModelName = modelName;
-            // Enable dynamic model resolution with timeout-protected initialization
+            // PRIORITY 1: Check environment variables BEFORE dynamic resolution
             if (!modelName || modelName === "default") {
+                logger.debug(`[${functionTag}] Checking environment variables for provider: ${providerName}`);
+                // Check for provider-specific environment variables first
+                if (providerName.toLowerCase().includes("bedrock")) {
+                    const envModel = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
+                    if (envModel) {
+                        resolvedModelName = envModel;
+                        logger.debug(`[${functionTag}] Environment variable found for Bedrock`, {
+                            envVariable: process.env.BEDROCK_MODEL
+                                ? "BEDROCK_MODEL"
+                                : "BEDROCK_MODEL_ID",
+                            resolvedModel: envModel,
+                        });
+                    }
+                    else {
+                        logger.debug(`[${functionTag}] No Bedrock environment variables found (BEDROCK_MODEL, BEDROCK_MODEL_ID)`);
+                    }
+                }
+                else if (providerName.toLowerCase().includes("vertex")) {
+                    const envModel = process.env.VERTEX_MODEL;
+                    if (envModel) {
+                        resolvedModelName = envModel;
+                        logger.debug(`[${functionTag}] Environment variable found for Vertex`, {
+                            envVariable: "VERTEX_MODEL",
+                            resolvedModel: envModel,
+                        });
+                    }
+                    else {
+                        logger.debug(`[${functionTag}] No Vertex environment variables found (VERTEX_MODEL)`);
+                    }
+                }
+                else {
+                    logger.debug(`[${functionTag}] Provider ${providerName} - no environment variable check implemented`);
+                }
+            }
+            else {
+                logger.debug(`[${functionTag}] Skipping environment variable check - explicit model provided: ${modelName}`);
+            }
+            // PRIORITY 2: Enable dynamic model resolution only if no env var found
+            if ((!resolvedModelName || resolvedModelName === "default") &&
+                (!modelName || modelName === "default")) {
+                logger.debug(`[${functionTag}] Attempting dynamic model resolution`, {
+                    currentResolvedModel: resolvedModelName || "none",
+                    reason: "No environment variable found and no explicit model provided",
+                });
                 try {
                     const normalizedProvider = this.normalizeProviderName(providerName);
                     // Initialize with timeout protection - won't hang anymore
                     if (dynamicModelProvider.needsRefresh()) {
+                        logger.debug(`[${functionTag}] Dynamic model provider needs refresh - initializing`);
                         await this.initializeDynamicProviderWithTimeout();
                     }
                     const dynamicModel = dynamicModelProvider.resolveModel(normalizedProvider, modelName || undefined);
@@ -92,6 +143,12 @@ export class AIProviderFactory {
                             pricing: dynamicModel.pricing.input,
                         });
                     }
+                    else {
+                        logger.debug(`[${functionTag}] Dynamic model resolution returned null`, {
+                            provider: normalizedProvider,
+                            requestedModel: modelName || "default",
+                        });
+                    }
                 }
                 catch (resolveError) {
                     logger.debug(`[${functionTag}] Dynamic model resolution failed, using static fallback`, {
@@ -102,6 +159,12 @@ export class AIProviderFactory {
                     // Continue with static model name - no functionality loss
                 }
             }
+            else {
+                logger.debug(`[${functionTag}] Skipping dynamic model resolution`, {
+                    resolvedModelName: resolvedModelName || "none",
+                    reason: "Model already resolved from environment variables or explicit parameter",
+                });
+            }
             // CRITICAL FIX: Initialize providers before using them
             await ProviderRegistry.registerAllProviders();
             // PURE FACTORY PATTERN: No switch statements - use ProviderFactory exclusively
@@ -109,8 +172,18 @@ export class AIProviderFactory {
             const finalModelName = resolvedModelName === "default" || resolvedModelName === null
                 ? undefined
                 : resolvedModelName;
+            logger.debug(`[${functionTag}] Final provider configuration`, {
+                originalProviderName: providerName,
+                normalizedProviderName: normalizedName,
+                originalModelName: modelName || "not provided",
+                resolvedModelName: resolvedModelName || "not resolved",
+                finalModelName: finalModelName || "using provider default",
+            });
             // Create provider with enhanced SDK
             const provider = await ProviderFactory.createProvider(normalizedName, finalModelName, sdk);
+            // Summary logging in format expected by debugging tools
+            logger.debug(`[AIProviderFactory] Provider creation completed { providerName: '${normalizedName}', modelName: '${finalModelName}' }`);
+            logger.debug(`[AIProviderFactory] Resolved model: ${finalModelName}`);
             logger.debug(componentIdentifier, "Pure factory pattern provider created", {
                 providerName: normalizedName,
                 modelName: finalModelName,
@@ -153,7 +226,7 @@ export class AIProviderFactory {
      * @returns AIProvider instance
      */
     static async createProviderWithModel(provider, model) {
-        const functionTag = "AIawait ProviderFactory.createProviderWithModel";
+        const functionTag = "AIProviderFactory.createProviderWithModel";
         logger.debug(`[${functionTag}] Provider model creation started`, {
             provider,
             model,
@@ -214,7 +287,7 @@ export class AIProviderFactory {
      * @returns Object with primary and fallback providers
      */
     static async createProviderWithFallback(primaryProvider, fallbackProvider, modelName, enableMCP = true) {
-        const functionTag = "AIawait ProviderFactory.createProviderWithFallback";
+        const functionTag = "AIProviderFactory.createProviderWithFallback";
         logger.debug(`[${functionTag}] Fallback provider setup started`, {
             primaryProvider,
             fallbackProvider,

package/dist/lib/factories/providerFactory.js

@@ -42,6 +42,9 @@ export class ProviderFactory {
             if (providerName.toLowerCase().includes("vertex")) {
                 model = process.env.VERTEX_MODEL;
             }
+            else if (providerName.toLowerCase().includes("bedrock")) {
+                model = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
+            }
             // Fallback to registry default if no env var
             model = model || registration.defaultModel;
         }

package/dist/lib/factories/providerRegistry.js

@@ -39,9 +39,9 @@ export class ProviderRegistry {
                 return new AnthropicProvider(modelName, sdk);
             }, "claude-3-5-sonnet-20241022", ["claude", "anthropic"]);
             // Register Amazon Bedrock provider
-            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName) => {
+            ProviderFactory.registerProvider(AIProviderName.BEDROCK, async (modelName, _providerName, sdk) => {
                 const { AmazonBedrockProvider } = await import("../providers/amazonBedrock.js");
-                return new AmazonBedrockProvider(modelName);
+                return new AmazonBedrockProvider(modelName, undefined, sdk);
             }, undefined, // Let provider read BEDROCK_MODEL from .env
             ["bedrock", "aws"]);
             // Register Azure OpenAI provider

package/dist/lib/mcp/externalServerManager.js

@@ -664,6 +664,9 @@ export class ExternalServerManager extends EventEmitter {
         const delay = Math.min(1000 *
             Math.pow(this.config.restartBackoffMultiplier, instance.reconnectAttempts - 1), 30000);
         mcpLogger.info(`[ExternalServerManager] Scheduling restart for ${serverId} in ${delay}ms (attempt ${instance.reconnectAttempts})`);
+        if (instance.restartTimer) {
+            return;
+        } // already scheduled
         instance.restartTimer = setTimeout(async () => {
             try {
                 await this.stopServer(serverId);
@@ -914,6 +917,7 @@ export class ExternalServerManager extends EventEmitter {
         }
         try {
             mcpLogger.debug(`[ExternalServerManager] Registering ${instance.toolsMap.size} tools with main registry for server: ${serverId}`);
+            const registrations = [];
             for (const [toolName, tool] of instance.toolsMap.entries()) {
                 const toolId = `${serverId}.${toolName}`;
                 const toolInfo = {
@@ -923,21 +927,16 @@ export class ExternalServerManager extends EventEmitter {
                     serverId: serverId,
                     category: detectCategory({ isExternal: true, serverId }),
                 };
-                // Register with main tool registry
-                try {
-                    toolRegistry.registerTool(toolId, toolInfo, {
-                        execute: async (params, context) => {
-                            // Execute tool via ExternalServerManager for proper lifecycle management
-                            return await this.executeTool(serverId, toolName, params, { timeout: this.config.defaultTimeout });
-                        },
-                    });
-                    mcpLogger.debug(`[ExternalServerManager] Registered tool with main registry: ${toolId}`);
-                }
-                catch (registrationError) {
-                    mcpLogger.warn(`[ExternalServerManager] Failed to register tool ${toolId} with main registry:`, registrationError);
-                }
+                registrations.push(toolRegistry.registerTool(toolId, toolInfo, {
+                    execute: async (params) => await this.executeTool(serverId, toolName, params, {
+                        timeout: this.config.defaultTimeout,
+                    }),
+                }));
             }
-            mcpLogger.info(`[ExternalServerManager] Successfully registered ${instance.toolsMap.size} tools with main registry for ${serverId}`);
+            const results = await Promise.allSettled(registrations);
+            const ok = results.filter((r) => r.status === "fulfilled").length;
+            const failed = results.length - ok;
+            mcpLogger.info(`[ExternalServerManager] Registered ${ok}/${results.length} tools with main registry for ${serverId}${failed ? ` (${failed} failed)` : ""}`);
         }
         catch (error) {
             mcpLogger.error(`[ExternalServerManager] Failed to register tools with main registry for ${serverId}:`, error);