@juspay/neurolink 7.30.0 → 7.30.1

package/dist/lib/providers/amazonBedrock.js

@@ -1,390 +1,973 @@
-import { createAmazonBedrock } from "@ai-sdk/amazon-bedrock";
-import { streamText } from "ai";
+import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand, } from "@aws-sdk/client-bedrock-runtime";
+import { BedrockClient, ListFoundationModelsCommand, } from "@aws-sdk/client-bedrock";
 import { BaseProvider } from "../core/baseProvider.js";
 import { logger } from "../utils/logger.js";
-import { createTimeoutController, TimeoutError } from "../utils/timeout.js";
-import { DEFAULT_MAX_TOKENS, DEFAULT_MAX_STEPS } from "../core/constants.js";
-import { validateApiKey, createAWSAccessKeyConfig, createAWSSecretConfig, getAWSRegion, getAWSSessionToken, } from "../utils/providerConfig.js";
-import { buildMessagesArray } from "../utils/messageBuilder.js";
-import { createProxyFetch } from "../proxy/proxyFetch.js";
-import { AWSCredentialProvider } from "./aws/credentialProvider.js";
-import { BedrockRuntimeClient } from "@aws-sdk/client-bedrock-runtime";
-// Configuration helpers
-const getBedrockModelId = () => {
-    const model = process.env.BEDROCK_MODEL || process.env.BEDROCK_MODEL_ID;
-    if (!model) {
-        throw new Error("BEDROCK_MODEL (or BEDROCK_MODEL_ID) is required. Example: 'anthropic.claude-3-haiku-20240307-v1:0' or a valid inference profile ARN.");
-    }
-    return model;
-};
-// Configuration helpers - now using consolidated utility
-const getAWSAccessKeyId = () => {
-    return validateApiKey(createAWSAccessKeyConfig());
-};
-const getAWSSecretAccessKey = () => {
-    return validateApiKey(createAWSSecretConfig());
-};
-// Note: getAWSRegion and getAWSSessionToken are now directly imported from consolidated utility
-const getAppEnvironment = () => {
-    return process.env.PUBLIC_APP_ENVIRONMENT || "production";
-};
-/**
- * Amazon Bedrock Provider v3 - Enhanced Authentication Implementation
- *
- * BEDROCK-MCP-CONNECTOR COMPATIBILITY: Complete AWS SDK credential chain support
- *
- * Features:
- * - Extends BaseProvider for shared functionality
- * - 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
- */
+import { zodToJsonSchema } from "zod-to-json-schema";
 export class AmazonBedrockProvider extends BaseProvider {
-    awsCredentialProvider;
     bedrockClient;
-    bedrock;
-    model;
-    constructor(modelName, credentialConfig, neurolink) {
+    conversationHistory = [];
+    constructor(modelName, neurolink) {
         super(modelName, "bedrock", neurolink);
-        // Debug: Bedrock initialization started
-        logger.debug("[Bedrock] Provider initialization started", {
-            requestedModel: modelName || "default",
-            environment: getAppEnvironment(),
-        });
-        // Initialize AWS credential provider with full credential chain support
-        const defaultCredentialConfig = {
-            region: getAWSRegion(),
-            enableDebugLogging: getAppEnvironment() === "dev",
-            ...credentialConfig,
-        };
-        // Debug: AWS configuration
-        logger.debug("[Bedrock] AWS configuration resolved", {
-            region: defaultCredentialConfig.region,
-            enableDebugLogging: defaultCredentialConfig.enableDebugLogging,
-            credentialConfigProvided: !!credentialConfig,
-        });
-        this.awsCredentialProvider = new AWSCredentialProvider(defaultCredentialConfig);
-        // Debug: AWS credential detection status
-        logger.debug("[Bedrock] AWS credential detection status", {
-            hasAccessKey: !!process.env.AWS_ACCESS_KEY_ID,
-            hasSecretKey: !!process.env.AWS_SECRET_ACCESS_KEY,
-            hasSessionToken: !!process.env.AWS_SESSION_TOKEN,
-            hasProfile: !!process.env.AWS_PROFILE,
-            credentialChainEnabled: true,
-        });
-        // Create AWS SDK v3 Bedrock client for direct access (Bedrock-MCP-Connector compatibility)
-        // Proxy support will be injected lazily when needed
-        this.bedrockClient = new BedrockRuntimeClient({
-            region: defaultCredentialConfig.region,
-            credentials: this.awsCredentialProvider.getCredentialProvider(),
-        });
-        // Debug: AWS region and service endpoint
-        logger.debug("[Bedrock] AWS service configuration", {
-            region: defaultCredentialConfig.region,
-            serviceEndpoint: `https://bedrock-runtime.${defaultCredentialConfig.region}.amazonaws.com`,
-            credentialProviderType: "AWS SDK v3 defaultProvider chain",
-        });
-        // For now, use legacy configuration as AI SDK may not support credential providers directly
-        // TODO: Update when @ai-sdk/amazon-bedrock supports credential providers
-        const legacyAwsConfig = this.createLegacyAWSConfig();
+        logger.debug("[AmazonBedrockProvider] Starting constructor with extensive logging for debugging");
+        // Log environment variables for debugging
+        logger.debug(`[AmazonBedrockProvider] Environment check: AWS_REGION=${process.env.AWS_REGION || "undefined"}, AWS_ACCESS_KEY_ID=${process.env.AWS_ACCESS_KEY_ID ? "SET" : "undefined"}, AWS_SECRET_ACCESS_KEY=${process.env.AWS_SECRET_ACCESS_KEY ? "SET" : "undefined"}`);
         try {
-            this.bedrock = createAmazonBedrock(legacyAwsConfig);
+            // Create BedrockRuntimeClient with clean configuration like working Bedrock-MCP-Connector
+            // Absolutely no proxy interference - let AWS SDK handle everything natively
+            logger.debug("[AmazonBedrockProvider] Creating BedrockRuntimeClient with clean configuration");
+            this.bedrockClient = new BedrockRuntimeClient({
+                region: process.env.AWS_REGION || "us-east-1",
+                // Clean configuration - AWS SDK will handle credentials via:
+                // 1. IAM roles (preferred in production)
+                // 2. Environment variables
+                // 3. AWS config files
+                // 4. Instance metadata
+            });
+            logger.debug(`[AmazonBedrockProvider] Successfully created BedrockRuntimeClient with model: ${this.modelName}, region: ${process.env.AWS_REGION || "us-east-1"}`);
+            // Immediate health check to catch credential issues early
+            this.performInitialHealthCheck();
         }
         catch (error) {
-            logger.error("Failed to create AI SDK provider", {
-                error: error instanceof Error ? error.message : String(error),
-            });
-            throw new Error(`Failed to initialize Amazon Bedrock AI SDK: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        // Pre-initialize model for efficiency
-        const resolvedModelId = this.modelName || getBedrockModelId();
-        // Debug: Bedrock model validation process
-        logger.debug("[Bedrock] Model validation and ARN processing", {
-            requestedModel: this.modelName || "from environment",
-            resolvedModelId: resolvedModelId,
-            isInferenceProfile: resolvedModelId.includes(":inference-profile/"),
-            isFoundationModel: resolvedModelId.startsWith("anthropic.") ||
-                resolvedModelId.startsWith("amazon.") ||
-                resolvedModelId.startsWith("meta."),
-            modelARNValidation: resolvedModelId.includes("arn:aws:bedrock:")
-                ? "Full ARN provided"
-                : "Model ID provided",
-        });
-        this.model = this.bedrock(resolvedModelId);
-        logger.debug("Amazon Bedrock Provider v3 initialized", {
-            modelName: this.modelName,
-            region: defaultCredentialConfig.region,
-            credentialProvider: "AWS SDK v3 defaultProvider",
-            hasDualAccess: true,
-            provider: this.providerName,
-        });
+            logger.error(`[AmazonBedrockProvider] CRITICAL: Failed to initialize BedrockRuntimeClient:`, error);
+            throw error;
+        }
     }
     /**
-     * Legacy AWS configuration for backward compatibility
+     * Perform initial health check to catch credential/connectivity issues early
+     * This prevents the health check failure we saw in production logs
      */
-    createLegacyAWSConfig() {
-        const awsConfig = {
-            accessKeyId: getAWSAccessKeyId(),
-            secretAccessKey: getAWSSecretAccessKey(),
-            region: getAWSRegion(),
-            fetch: createProxyFetch(),
-        };
-        // Add session token for development environment
-        if (getAppEnvironment() === "dev") {
-            const sessionToken = getAWSSessionToken();
-            if (sessionToken) {
-                awsConfig.sessionToken = sessionToken;
+    async performInitialHealthCheck() {
+        const bedrockClient = new BedrockClient({
+            region: process.env.AWS_REGION || "us-east-1",
+        });
+        try {
+            logger.debug("[AmazonBedrockProvider] Starting initial health check to validate credentials and connectivity");
+            // Try to list foundation models as a lightweight health check
+            const command = new ListFoundationModelsCommand({});
+            const startTime = Date.now();
+            await bedrockClient.send(command);
+            const responseTime = Date.now() - startTime;
+            logger.debug(`[AmazonBedrockProvider] Health check PASSED - credentials valid, connectivity good, responseTime: ${responseTime}ms`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`[AmazonBedrockProvider] Health check FAILED - this will cause production failures:`, {
+                error: errorMessage,
+                errorType: error instanceof Error ? error.constructor.name : "Unknown",
+                region: process.env.AWS_REGION || "us-east-1",
+                hasAccessKey: !!process.env.AWS_ACCESS_KEY_ID,
+                hasSecretKey: !!process.env.AWS_SECRET_ACCESS_KEY,
+            });
+            // Don't throw here - let the actual usage fail with better context
+        }
+        finally {
+            try {
+                bedrockClient.destroy();
+            }
+            catch {
+                // Ignore destroy errors during cleanup
             }
         }
-        return awsConfig;
+    }
+    // Not using AI SDK approach in conversation management
+    getAISDKModel() {
+        throw new Error("AmazonBedrockProvider does not use AI SDK models");
     }
     getProviderName() {
         return "bedrock";
     }
     getDefaultModel() {
-        return getBedrockModelId();
-    }
-    /**
-     * Returns the Vercel AI SDK model instance for AWS Bedrock
-     */
-    getAISDKModel() {
-        return this.model;
-    }
-    /**
-     * 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() {
-        // Note: For synchronous access, proxy support is configured lazily
-        // If proxy support is critical, use getBedrockClientWithProxy() instead
-        return this.bedrockClient;
+        return (process.env.BEDROCK_MODEL || "anthropic.claude-3-sonnet-20240229-v1:0");
     }
-    /**
-     * Get AWS SDK BedrockRuntimeClient with proxy support ensured
-     * Use this method when proxy support is critical for the operation
-     */
-    async getBedrockClientWithProxy() {
-        await this.ensureProxySupport();
-        return this.bedrockClient;
+    // Override the main generate method to implement conversation management
+    async generate(optionsOrPrompt) {
+        logger.debug("[AmazonBedrockProvider] generate() called with conversation management");
+        const options = typeof optionsOrPrompt === "string"
+            ? { prompt: optionsOrPrompt }
+            : optionsOrPrompt;
+        // Clear conversation history for new generation
+        this.conversationHistory = [];
+        // Add user message to conversation
+        const userMessage = {
+            role: "user",
+            content: [{ text: options.prompt }],
+        };
+        this.conversationHistory.push(userMessage);
+        logger.debug(`[AmazonBedrockProvider] Starting conversation with prompt: ${options.prompt}`);
+        // Start conversation loop and return enhanced result
+        const text = await this.conversationLoop(options);
+        return {
+            content: text, // CLI expects 'content' not 'text'
+            usage: { total: 0, input: 0, output: 0 },
+            model: this.modelName || this.getDefaultModel(),
+            provider: this.getProviderName(),
+        };
     }
-    /**
-     * Get AWS credential provider for advanced credential management
-     */
-    getCredentialProvider() {
-        return this.awsCredentialProvider;
+    async conversationLoop(options) {
+        const maxIterations = 10; // Prevent infinite loops
+        let iteration = 0;
+        while (iteration < maxIterations) {
+            iteration++;
+            logger.debug(`[AmazonBedrockProvider] Conversation iteration ${iteration}`);
+            try {
+                logger.debug(`[AmazonBedrockProvider] About to call Bedrock API`);
+                const response = await this.callBedrock(options);
+                logger.debug(`[AmazonBedrockProvider] Received Bedrock response`, JSON.stringify(response, null, 2));
+                const result = await this.handleBedrockResponse(response);
+                logger.debug(`[AmazonBedrockProvider] Handle response result:`, result);
+                if (result.shouldContinue) {
+                    logger.debug(`[AmazonBedrockProvider] Continuing conversation loop...`);
+                    continue;
+                }
+                else {
+                    logger.debug(`[AmazonBedrockProvider] Conversation completed with final text`);
+                    logger.debug(`[AmazonBedrockProvider] Returning final text: "${result.text}"`);
+                    return result.text || "";
+                }
+            }
+            catch (error) {
+                logger.error(`[AmazonBedrockProvider] Error in conversation loop:`, error);
+                throw this.handleProviderError(error);
+            }
+        }
+        throw new Error("Conversation loop exceeded maximum iterations");
     }
-    /**
-     * Ensure proxy support is configured for AWS SDK client if needed
-     */
-    async ensureProxySupport() {
+    async callBedrock(options) {
+        const startTime = Date.now();
+        logger.info(`🚀 [AmazonBedrockProvider] Starting Bedrock API call at ${new Date().toISOString()}`);
         try {
-            const { createAWSProxyHandler } = await import("../proxy/awsProxyIntegration.js");
-            const proxyHandler = await createAWSProxyHandler();
-            if (proxyHandler) {
-                logger.debug("[Bedrock] Reinitializing client with proxy support");
-                // Recreate the client with proxy handler
-                this.bedrockClient = new BedrockRuntimeClient({
-                    region: this.awsCredentialProvider.getConfig().region,
-                    credentials: this.awsCredentialProvider.getCredentialProvider(),
-                    requestHandler: proxyHandler,
-                });
+            // Pre-call validation and logging
+            const region = typeof this.bedrockClient.config.region === "function"
+                ? await this.bedrockClient.config.region()
+                : this.bedrockClient.config.region;
+            logger.info(`🔧 [AmazonBedrockProvider] Client region: ${region}`);
+            logger.info(`🔧 [AmazonBedrockProvider] Model: ${this.modelName || this.getDefaultModel()}`);
+            logger.info(`🔧 [AmazonBedrockProvider] Conversation history length: ${this.conversationHistory.length}`);
+            // Get all available tools
+            const aiTools = await this.getAllTools();
+            const allTools = this.convertAISDKToolsToToolDefinitions(aiTools);
+            const toolConfig = this.formatToolsForBedrock(allTools);
+            const commandInput = {
+                modelId: this.modelName || this.getDefaultModel(),
+                messages: this.convertToAWSMessages(this.conversationHistory),
+                system: [
+                    {
+                        text: options.systemPrompt ||
+                            "You are a helpful assistant with access to external tools. Use tools when necessary to provide accurate information.",
+                    },
+                ],
+                inferenceConfig: {
+                    maxTokens: options.maxTokens || 4096,
+                    temperature: options.temperature || 0.7,
+                },
+            };
+            if (toolConfig) {
+                commandInput.toolConfig = toolConfig;
+                logger.info(`🛠️ [AmazonBedrockProvider] Tools configured: ${toolConfig.tools?.length || 0}`);
             }
+            // Log command details for debugging
+            logger.info(`📋 [AmazonBedrockProvider] Command input summary:`);
+            logger.info(`  - Model ID: ${commandInput.modelId}`);
+            logger.info(`  - Messages count: ${commandInput.messages?.length || 0}`);
+            logger.info(`  - System prompts: ${commandInput.system?.length || 0}`);
+            logger.info(`  - Max tokens: ${commandInput.inferenceConfig?.maxTokens}`);
+            logger.info(`  - Temperature: ${commandInput.inferenceConfig?.temperature}`);
+            logger.debug(`[AmazonBedrockProvider] Calling Bedrock with ${this.conversationHistory.length} messages and ${toolConfig?.tools?.length || 0} tools`);
+            // Create command and attempt API call
+            const command = new ConverseCommand(commandInput);
+            logger.info(`⏳ [AmazonBedrockProvider] Sending ConverseCommand to Bedrock...`);
+            const apiCallStartTime = Date.now();
+            const response = await this.bedrockClient.send(command);
+            const apiCallDuration = Date.now() - apiCallStartTime;
+            logger.info(`✅ [AmazonBedrockProvider] Bedrock API call successful!`);
+            logger.info(`⏱️ [AmazonBedrockProvider] API call duration: ${apiCallDuration}ms`);
+            logger.info(`📊 [AmazonBedrockProvider] Response metadata:`);
+            logger.info(`  - Stop reason: ${response.stopReason}`);
+            logger.info(`  - Usage tokens: ${JSON.stringify(response.usage || {})}`);
+            logger.info(`  - Metrics: ${JSON.stringify(response.metrics || {})}`);
+            const totalDuration = Date.now() - startTime;
+            logger.info(`🎯 [AmazonBedrockProvider] Total callBedrock duration: ${totalDuration}ms`);
+            return response;
         }
         catch (error) {
-            logger.warn("[Bedrock] Failed to configure proxy support", { error });
-            // Continue without proxy support
+            const errorDuration = Date.now() - startTime;
+            logger.error(`❌ [AmazonBedrockProvider] Bedrock API call failed after ${errorDuration}ms`);
+            logger.error(`🔍 [AmazonBedrockProvider] Error details:`);
+            if (error instanceof Error) {
+                logger.error(`  - Error name: ${error.name}`);
+                logger.error(`  - Error message: ${error.message}`);
+                logger.error(`  - Error stack: ${error.stack}`);
+            }
+            // Log AWS SDK specific error details
+            if (error && typeof error === "object") {
+                const awsError = error;
+                if (awsError.$metadata && typeof awsError.$metadata === "object") {
+                    const metadata = awsError.$metadata;
+                    logger.error(`🏭 [AmazonBedrockProvider] AWS SDK metadata:`);
+                    logger.error(`  - HTTP status: ${metadata.httpStatusCode}`);
+                    logger.error(`  - Request ID: ${metadata.requestId}`);
+                    logger.error(`  - Attempts: ${metadata.attempts}`);
+                    logger.error(`  - Total retry delay: ${metadata.totalRetryDelay}`);
+                }
+                if (awsError.Code) {
+                    logger.error(`  - AWS Error Code: ${awsError.Code}`);
+                }
+                if (awsError.Type) {
+                    logger.error(`  - AWS Error Type: ${awsError.Type}`);
+                }
+                if (awsError.Fault) {
+                    logger.error(`  - AWS Fault: ${awsError.Fault}`);
+                }
+            }
+            // Log environment details for debugging
+            logger.error(`🌍 [AmazonBedrockProvider] Environment diagnostics:`);
+            logger.error(`  - AWS_REGION: ${process.env.AWS_REGION || "not set"}`);
+            logger.error(`  - AWS_PROFILE: ${process.env.AWS_PROFILE || "not set"}`);
+            logger.error(`  - AWS_ACCESS_KEY_ID: ${process.env.AWS_ACCESS_KEY_ID ? "set" : "not set"}`);
+            logger.error(`  - AWS_SECRET_ACCESS_KEY: ${process.env.AWS_SECRET_ACCESS_KEY ? "set" : "not set"}`);
+            logger.error(`  - AWS_SESSION_TOKEN: ${process.env.AWS_SESSION_TOKEN ? "set" : "not set"}`);
+            throw error;
         }
     }
-    /**
-     * Test AWS credentials and Bedrock connectivity
-     * Useful for debugging authentication issues
-     */
-    async testConnectivity() {
-        const startTime = Date.now();
-        try {
-            // Ensure proxy support is configured before testing
-            await this.ensureProxySupport();
-            const { CredentialTester } = await import("./aws/credentialTester.js");
-            // Add timeout protection using AbortController
-            const timeout = 15000; // 15 second timeout
-            const abortController = new AbortController();
-            const timeoutId = setTimeout(() => {
-                abortController.abort();
-            }, timeout);
-            try {
-                const [credentialResult, connectivityResult] = await Promise.race([
-                    Promise.all([
-                        CredentialTester.validateCredentials(this.awsCredentialProvider),
-                        CredentialTester.testBedrockConnectivity(this.awsCredentialProvider),
-                    ]),
-                    new Promise((_, reject) => {
-                        abortController.signal.addEventListener("abort", () => {
-                            reject(new Error("Connectivity test timeout"));
+    async handleBedrockResponse(response) {
+        logger.debug(`[AmazonBedrockProvider] Received response with stopReason: ${response.stopReason}`);
+        if (!response.output || !response.output.message) {
+            throw new Error("Invalid response structure from Bedrock API");
+        }
+        const assistantMessage = response.output.message;
+        const stopReason = response.stopReason;
+        // Add assistant message to conversation history
+        const bedrockAssistantMessage = {
+            role: "assistant",
+            content: (assistantMessage.content || []).map((item) => {
+                const bedrockItem = {};
+                if ("text" in item && item.text) {
+                    bedrockItem.text = item.text;
+                }
+                if ("toolUse" in item && item.toolUse) {
+                    bedrockItem.toolUse = {
+                        toolUseId: item.toolUse.toolUseId || "",
+                        name: item.toolUse.name || "",
+                        input: item.toolUse.input || {},
+                    };
+                }
+                if ("toolResult" in item && item.toolResult) {
+                    bedrockItem.toolResult = {
+                        toolUseId: item.toolResult.toolUseId || "",
+                        content: (item.toolResult.content || []).map((c) => ({
+                            text: typeof c === "object" && "text" in c
+                                ? c.text || ""
+                                : "",
+                        })),
+                        status: item.toolResult.status || "unknown",
+                    };
+                }
+                return bedrockItem;
+            }),
+        };
+        this.conversationHistory.push(bedrockAssistantMessage);
+        if (stopReason === "end_turn" || stopReason === "stop_sequence") {
+            // Extract text from assistant message
+            const textContent = bedrockAssistantMessage.content
+                .filter((item) => item.text)
+                .map((item) => item.text)
+                .join(" ");
+            return { shouldContinue: false, text: textContent };
+        }
+        else if (stopReason === "tool_use") {
+            logger.debug(`[AmazonBedrockProvider] Tool use detected - executing tools immediately`);
+            // Execute all tool uses in the message
+            const toolResults = [];
+            for (const contentItem of bedrockAssistantMessage.content) {
+                if (contentItem.toolUse) {
+                    logger.debug(`[AmazonBedrockProvider] Executing tool: ${contentItem.toolUse.name}`);
+                    try {
+                        // Execute tool using BaseProvider's tool execution
+                        logger.debug(`[AmazonBedrockProvider] Debug toolUse.input:`, JSON.stringify(contentItem.toolUse.input, null, 2));
+                        const toolResult = await this.executeSingleTool(contentItem.toolUse.name, contentItem.toolUse.input || {}, contentItem.toolUse.toolUseId);
+                        logger.debug(`[AmazonBedrockProvider] Tool execution successful: ${contentItem.toolUse.name}`);
+                        toolResults.push({
+                            toolResult: {
+                                toolUseId: contentItem.toolUse.toolUseId,
+                                content: [{ text: String(toolResult) }],
+                                status: "success",
+                            },
                         });
-                    }),
-                ]);
-                clearTimeout(timeoutId);
-                return {
-                    credentialsValid: credentialResult.isValid,
-                    bedrockAccessible: connectivityResult.bedrockAccessible,
-                    credentialSource: credentialResult.credentialSource,
-                    error: credentialResult.error || connectivityResult.error,
-                    responseTime: Date.now() - startTime,
+                    }
+                    catch (error) {
+                        logger.error(`[AmazonBedrockProvider] Tool execution failed: ${contentItem.toolUse.name}`, error);
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        // Still create toolResult for failed tools to maintain 1:1 mapping with toolUse blocks
+                        toolResults.push({
+                            toolResult: {
+                                toolUseId: contentItem.toolUse.toolUseId,
+                                content: [
+                                    {
+                                        text: `Error executing tool ${contentItem.toolUse.name}: ${errorMessage}`,
+                                    },
+                                ],
+                                status: "error",
+                            },
+                        });
+                    }
+                }
+            }
+            // Add tool results as user message
+            if (toolResults.length > 0) {
+                const userMessageWithToolResults = {
+                    role: "user",
+                    content: toolResults,
                 };
+                this.conversationHistory.push(userMessageWithToolResults);
+                logger.debug(`[AmazonBedrockProvider] Added ${toolResults.length} tool results to conversation`);
             }
-            catch (timeoutError) {
-                clearTimeout(timeoutId);
-                throw timeoutError;
+            return { shouldContinue: true };
+        }
+        else if (stopReason === "max_tokens") {
+            // Handle max tokens by continuing conversation
+            const userMessage = {
+                role: "user",
+                content: [{ text: "Please continue." }],
+            };
+            this.conversationHistory.push(userMessage);
+            return { shouldContinue: true };
+        }
+        else {
+            logger.warn(`[AmazonBedrockProvider] Unrecognized stop reason "${stopReason}", ending conversation.`);
+            return { shouldContinue: false, text: "" };
+        }
+    }
+    convertToAWSMessages(bedrockMessages) {
+        return bedrockMessages.map((msg) => ({
+            role: msg.role,
+            content: msg.content.map((item) => {
+                if (item.text) {
+                    return {
+                        text: item.text,
+                    };
+                }
+                if (item.toolUse) {
+                    return {
+                        toolUse: {
+                            toolUseId: item.toolUse.toolUseId,
+                            name: item.toolUse.name,
+                            input: item.toolUse.input,
+                        },
+                    };
+                }
+                if (item.toolResult) {
+                    return {
+                        toolResult: {
+                            toolUseId: item.toolResult.toolUseId,
+                            content: item.toolResult.content,
+                            status: item.toolResult.status,
+                        },
+                    };
+                }
+                return { text: "" };
+            }),
+        }));
+    }
+    async executeSingleTool(toolName, args, _toolUseId) {
+        logger.debug(`[AmazonBedrockProvider] Executing single tool: ${toolName}`, {
+            args,
+        });
+        try {
+            // Use BaseProvider's tool execution mechanism
+            const aiTools = await this.getAllTools();
+            const tools = this.convertAISDKToolsToToolDefinitions(aiTools);
+            if (!tools[toolName]) {
+                throw new Error(`Tool not found: ${toolName}`);
+            }
+            const tool = tools[toolName];
+            if (!tool || !tool.execute) {
+                throw new Error(`Tool ${toolName} does not have execute method`);
+            }
+            // Apply robust parameter handling like Bedrock-MCP-Connector
+            // Bedrock toolUse.input already contains the correct parameter structure
+            const toolInput = args || {};
+            // Add default parameters for common tools that Claude might call without required params
+            if (toolName === "list_directory" && !toolInput.path) {
+                toolInput.path = ".";
+                logger.debug(`[AmazonBedrockProvider] Added default path '.' for list_directory tool`);
+            }
+            logger.debug(`[AmazonBedrockProvider] Tool input parameters:`, toolInput);
+            // Convert Record<string, unknown> to ToolArgs by filtering out non-JsonValue types
+            const toolArgs = {};
+            for (const [key, value] of Object.entries(toolInput)) {
+                // Only include values that are JsonValue compatible
+                if (value === null ||
+                    typeof value === "string" ||
+                    typeof value === "number" ||
+                    typeof value === "boolean" ||
+                    (typeof value === "object" && value !== null)) {
+                    toolArgs[key] = value;
+                }
+            }
+            const result = await tool.execute(toolArgs);
+            logger.debug(`[AmazonBedrockProvider] Tool execution result:`, {
+                toolName,
+                result,
+            });
+            // Handle ToolResult type
+            if (result && typeof result === "object" && "success" in result) {
+                if (result.success && result.data !== undefined) {
+                    if (typeof result.data === "string") {
+                        return result.data;
+                    }
+                    else if (typeof result.data === "object") {
+                        return JSON.stringify(result.data, null, 2);
+                    }
+                    else {
+                        return String(result.data);
+                    }
+                }
+                else if (result.error) {
+                    throw new Error(result.error.message || "Tool execution failed");
+                }
+            }
+            // Fallback for non-ToolResult return types
+            if (typeof result === "string") {
+                return result;
+            }
+            else if (typeof result === "object") {
+                return JSON.stringify(result, null, 2);
+            }
+            else {
+                return String(result);
             }
         }
         catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
+            logger.error(`[AmazonBedrockProvider] Tool execution error:`, {
+                toolName,
+                error,
+            });
+            throw error;
+        }
+    }
+    convertAISDKToolsToToolDefinitions(aiTools) {
+        const result = {};
+        for (const [name, tool] of Object.entries(aiTools)) {
+            if ("description" in tool && tool.description) {
+                result[name] = {
+                    description: tool.description,
+                    parameters: "parameters" in tool ? tool.parameters : undefined,
+                    execute: async (params) => {
+                        if ("execute" in tool && tool.execute) {
+                            const result = await tool.execute(params, {
+                                toolCallId: `tool_${Date.now()}`,
+                                messages: [],
+                            });
+                            return {
+                                success: true,
+                                data: result,
+                            };
+                        }
+                        throw new Error(`Tool ${name} has no execute method`);
+                    },
+                };
+            }
+        }
+        return result;
+    }
+    formatToolsForBedrock(tools) {
+        if (!tools || Object.keys(tools).length === 0) {
+            return null;
+        }
+        const bedrockTools = Object.entries(tools).map(([name, tool]) => {
+            // Handle Zod schema or plain object schema
+            let schema;
+            if (tool.parameters && typeof tool.parameters === "object") {
+                // Check if it's a Zod schema
+                if ("_def" in tool.parameters) {
+                    // It's a Zod schema, convert to JSON schema
+                    schema = zodToJsonSchema(tool.parameters);
+                }
+                else {
+                    // It's already a plain object schema
+                    schema = tool.parameters;
+                }
+            }
+            else {
+                schema = {
+                    type: "object",
+                    properties: {},
+                    required: [],
+                };
+            }
+            // Ensure the schema always has type: "object" at the root level
+            if (!schema.type || schema.type !== "object") {
+                schema = {
+                    type: "object",
+                    properties: schema.properties || {},
+                    required: schema.required || [],
+                };
+            }
+            const toolSpec = {
+                name,
+                description: tool.description,
+                inputSchema: {
+                    json: schema,
+                },
+            };
             return {
-                credentialsValid: false,
-                bedrockAccessible: false,
-                credentialSource: "unknown",
-                error: errorMessage,
-                responseTime: Date.now() - startTime,
+                toolSpec,
+            };
+        });
+        logger.debug(`[AmazonBedrockProvider] Formatted ${bedrockTools.length} tools for Bedrock`);
+        return { tools: bedrockTools };
+    }
+    // Bedrock-MCP-Connector compatibility
+    getBedrockClient() {
+        return this.bedrockClient;
+    }
+    async executeStream(options) {
+        logger.debug("🟢 [TRACE] executeStream ENTRY - starting streaming attempt");
+        logger.info("🚀 [AmazonBedrockProvider] Attempting real streaming with ConverseStreamCommand");
+        try {
+            logger.debug("🟢 [TRACE] executeStream TRY block - about to call streamingConversationLoop");
+            // CRITICAL FIX: Initialize conversation history like generate() does
+            // Clear conversation history for new streaming session
+            this.conversationHistory = [];
+            // Add user message to conversation - exactly like generate() does
+            const userMessage = {
+                role: "user",
+                content: [{ text: options.input.text }],
             };
+            this.conversationHistory.push(userMessage);
+            logger.debug(`[AmazonBedrockProvider] Starting streaming conversation with prompt: ${options.input.text}`);
+            // Call the actual streaming implementation that already exists
+            logger.debug("🟢 [TRACE] executeStream - calling streamingConversationLoop NOW");
+            const result = await this.streamingConversationLoop(options);
+            logger.debug("🟢 [TRACE] executeStream - streamingConversationLoop SUCCESS, returning result");
+            return result;
+        }
+        catch (error) {
+            logger.debug("🔴 [TRACE] executeStream CATCH - error caught from streamingConversationLoop");
+            const errorObj = error;
+            // Check if error is related to streaming permissions
+            const isPermissionError = errorObj?.name ===
+                "AccessDeniedException" ||
+                errorObj?.name ===
+                    "UnauthorizedOperation" ||
+                errorObj?.message?.includes("bedrock:InvokeModelWithResponseStream") ||
+                errorObj?.message?.includes("streaming") ||
+                errorObj?.message?.includes("ConverseStream");
+            logger.debug("🔴 [TRACE] executeStream CATCH - checking if permission error");
+            logger.debug(`🔴 [TRACE] executeStream CATCH - isPermissionError=${isPermissionError}`);
+            if (isPermissionError) {
+                logger.debug("🟡 [TRACE] executeStream CATCH - PERMISSION ERROR DETECTED, starting fallback");
+                logger.warn(`[AmazonBedrockProvider] Streaming permissions not available, falling back to generate method: ${errorObj.message}`);
+                // Fallback to generate method and convert to streaming format
+                const generateResult = await this.generate({
+                    prompt: options.input.text,
+                });
+                if (!generateResult) {
+                    throw new Error("Generate method returned null result");
+                }
+                // Convert generate result to streaming format
+                const stream = new ReadableStream({
+                    start(controller) {
+                        // Split the response into chunks for pseudo-streaming
+                        const responseText = generateResult.content || "";
+                        const chunks = responseText.split(" ");
+                        chunks.forEach((word, _index) => {
+                            controller.enqueue({ content: word + " " });
+                        });
+                        controller.enqueue({ content: "" });
+                        controller.close();
+                    },
+                });
+                // Convert ReadableStream to AsyncIterable like streamingConversationLoop does
+                const asyncIterable = {
+                    async *[Symbol.asyncIterator]() {
+                        const reader = stream.getReader();
+                        try {
+                            while (true) {
+                                const { done, value } = await reader.read();
+                                if (done) {
+                                    break;
+                                }
+                                yield value;
+                            }
+                        }
+                        finally {
+                            reader.releaseLock();
+                        }
+                    },
+                };
+                return {
+                    stream: asyncIterable,
+                    usage: { total: 0, input: 0, output: 0 },
+                    model: this.modelName || this.getDefaultModel(),
+                    provider: this.getProviderName(),
+                    metadata: {
+                        fallback: true,
+                    },
+                };
+            }
+            // Re-throw non-permission errors
+            throw error;
         }
     }
-    // executeGenerate removed - BaseProvider handles all generation with tools
-    async executeStream(options, _analysisSchema) {
+    async streamingConversationLoop(options) {
+        logger.debug("🟦 [TRACE] streamingConversationLoop ENTRY");
+        const maxIterations = 10;
+        let iteration = 0;
+        // The REAL issue: ReadableStream errors don't bubble up to the caller
+        // So we need to make the first streaming call synchronously to test permissions
         try {
-            this.validateStreamOptions(options);
-            const timeout = this.getTimeout(options);
-            const timeoutController = createTimeoutController(timeout, this.providerName, "stream");
-            // Get tools consistently with generate method (now supports streaming with tools)
-            const shouldUseTools = !options.disableTools && this.supportsTools();
-            const tools = shouldUseTools ? await this.getAllTools() : {};
-            // Build message array from options
-            const messages = buildMessagesArray(options);
-            const result = streamText({
-                model: this.model,
-                messages: messages,
-                tools,
-                maxSteps: options.maxSteps || DEFAULT_MAX_STEPS,
-                toolChoice: shouldUseTools ? "auto" : "none",
-                maxTokens: options.maxTokens || DEFAULT_MAX_TOKENS,
-                temperature: options.temperature,
-                abortSignal: timeoutController?.controller.signal,
-            });
-            const streamResult = {
-                stream: (async function* (self) {
-                    let chunkCount = 0;
-                    let streamStarted = false;
-                    let timeoutId = null;
+            logger.debug("🟦 [TRACE] streamingConversationLoop - testing first streaming call");
+            const commandInput = await this.prepareStreamCommand(options);
+            const command = new ConverseStreamCommand(commandInput);
+            const response = await this.bedrockClient.send(command);
+            logger.debug("🟦 [TRACE] streamingConversationLoop - first streaming call SUCCESS");
+            // Process the first response immediately to avoid waste
+            const stream = new ReadableStream({
+                start: async (controller) => {
+                    logger.debug("🟦 [TRACE] streamingConversationLoop - ReadableStream start() called");
                     try {
-                        // Create timeout promise for first chunk with proper cleanup
-                        const timeoutPromise = new Promise((_, reject) => {
-                            timeoutId = setTimeout(() => {
-                                if (!streamStarted && chunkCount === 0) {
-                                    reject(new Error("❌ Amazon Bedrock Streaming Timeout\n\n" +
-                                        "Stream failed to produce any content within 5 seconds.\n\n" +
-                                        "🔧 Common Causes:\n" +
-                                        "1. Expired AWS credentials - run: aws sts get-caller-identity\n" +
-                                        "2. Missing Bedrock permissions - need: bedrock:InvokeModelWithResponseStream\n" +
-                                        "3. Model not available in your region\n" +
-                                        "4. Network connectivity issues\n\n" +
-                                        '💡 Try: neurolink generate "test" --provider bedrock\n' +
-                                        "   (Generate mode provides more detailed error messages)"));
+                        // Process the first response we already have
+                        if (response.stream) {
+                            for await (const chunk of response.stream) {
+                                if (chunk.contentBlockDelta?.delta?.text) {
+                                    controller.enqueue({
+                                        content: chunk.contentBlockDelta.delta.text,
+                                    });
+                                }
+                                if (chunk.messageStop) {
+                                    controller.close();
+                                    return;
                                 }
-                            }, 5000);
-                        });
-                        // Process stream with timeout handling
-                        const streamIterator = result.textStream[Symbol.asyncIterator]();
-                        let timeoutActive = true;
-                        while (true) {
-                            let nextResult;
-                            if (timeoutActive) {
-                                // 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) {
+                        }
+                        // Continue with normal iterations if needed
+                        while (iteration < maxIterations) {
+                            iteration++;
+                            logger.debug(`[AmazonBedrockProvider] Streaming iteration ${iteration}`);
+                            const commandInput = await this.prepareStreamCommand(options);
+                            const { stopReason, assistantMessage } = await this.processStreamResponse(commandInput, controller);
+                            const shouldContinue = await this.handleStreamStopReason(stopReason, assistantMessage, controller);
+                            if (!shouldContinue) {
                                 break;
                             }
-                            if (!streamStarted) {
-                                streamStarted = true;
-                                timeoutActive = false;
-                                // Clear the timeout now that we have content
-                                if (timeoutId) {
-                                    clearTimeout(timeoutId);
-                                    timeoutId = null;
-                                }
-                            }
-                            chunkCount++;
-                            yield { content: nextResult.value };
                         }
-                        // If no chunks received, likely an authentication error
-                        if (chunkCount === 0) {
-                            throw new Error("❌ Amazon Bedrock Streaming Error\n\n" +
-                                "Stream completed with no content.\n\n" +
-                                "🔧 Most Likely Causes:\n" +
-                                "1. AWS credentials are expired or invalid\n" +
-                                "2. Insufficient Bedrock permissions\n" +
-                                "3. Model access not enabled in AWS console\n" +
-                                "4. Region mismatch\n\n" +
-                                "🔍 Debug Steps:\n" +
-                                "1. Check credentials: aws sts get-caller-identity\n" +
-                                '2. Test generate mode: neurolink generate "test" --provider bedrock\n' +
-                                '3. Verify region: AWS_REGION=us-east-1 neurolink stream "test" --provider bedrock');
+                        if (iteration >= maxIterations) {
+                            controller.error(new Error("Streaming conversation exceeded maximum iterations"));
                         }
                     }
                     catch (error) {
-                        // Clean up timeout on error
-                        if (timeoutId) {
-                            clearTimeout(timeoutId);
-                        }
-                        throw self.handleStreamError
-                            ? self.handleStreamError(error)
-                            : error;
+                        logger.debug("🔴 [TRACE] streamingConversationLoop - CATCH block hit in ReadableStream");
+                        controller.error(error);
                     }
-                })(this),
-                provider: this.providerName,
-                model: this.modelName,
+                },
+            });
+            return {
+                stream: this.convertToAsyncIterable(stream),
+                usage: { total: 0, input: 0, output: 0 },
+                model: this.modelName || this.getDefaultModel(),
+                provider: this.getProviderName(),
             };
-            timeoutController?.cleanup();
-            return streamResult;
         }
         catch (error) {
-            throw this.handleProviderError(error);
+            logger.debug("🔴 [TRACE] streamingConversationLoop - first streaming call FAILED, throwing");
+            throw error; // This will be caught by executeStream
         }
     }
-    handleStreamError(error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        // Stream-specific error handling
-        if (errorMessage.includes("no content") ||
-            errorMessage.includes("Streaming Timeout") ||
-            errorMessage.includes("Stream failed")) {
-            return new Error(errorMessage); // Already formatted in stream logic
-        }
-        // For other errors, use standard provider error handling
-        return this.handleProviderError(error);
+    convertToAsyncIterable(stream) {
+        return {
+            async *[Symbol.asyncIterator]() {
+                const reader = stream.getReader();
+                try {
+                    while (true) {
+                        const { done, value } = await reader.read();
+                        if (done) {
+                            break;
+                        }
+                        yield value;
+                    }
+                }
+                finally {
+                    reader.releaseLock();
+                }
+            },
+        };
     }
-    handleProviderError(error) {
-        if (error instanceof Error && error.name === "TimeoutError") {
-            return new TimeoutError(`Amazon Bedrock request timed out. Consider increasing timeout or using a lighter model.`, this.defaultTimeout);
+    async prepareStreamCommand(options) {
+        // CRITICAL DEBUG: Log conversation history before conversion
+        logger.info(`🔍 [AmazonBedrockProvider] BEFORE conversion - conversationHistory length: ${this.conversationHistory.length}`);
+        this.conversationHistory.forEach((msg, index) => {
+            logger.info(`🔍 [AmazonBedrockProvider] Message ${index}: role=${msg.role}, content=${JSON.stringify(msg.content)}`);
+        });
+        // Get all available tools
+        const aiTools = await this.getAllTools();
+        const allTools = this.convertAISDKToolsToToolDefinitions(aiTools);
+        const toolConfig = this.formatToolsForBedrock(allTools);
+        const convertedMessages = this.convertToAWSMessages(this.conversationHistory);
+        logger.info(`🔍 [AmazonBedrockProvider] AFTER conversion - messages length: ${convertedMessages.length}`);
+        convertedMessages.forEach((msg, index) => {
+            logger.info(`🔍 [AmazonBedrockProvider] Converted Message ${index}: role=${msg.role}, content=${JSON.stringify(msg.content)}`);
+        });
+        const commandInput = {
+            modelId: this.modelName || this.getDefaultModel(),
+            messages: convertedMessages,
+            system: [
+                {
+                    text: options.systemPrompt ||
+                        "You are a helpful assistant with access to external tools. Use tools when necessary to provide accurate information.",
+                },
+            ],
+            inferenceConfig: {
+                maxTokens: options.maxTokens || 4096,
+                temperature: options.temperature || 0.7,
+            },
+        };
+        if (toolConfig) {
+            commandInput.toolConfig = toolConfig;
+        }
+        logger.debug(`[AmazonBedrockProvider] Calling Bedrock streaming with ${this.conversationHistory.length} messages`);
+        // DEBUG: Log exact conversation structure being sent to Bedrock
+        logger.debug(`[AmazonBedrockProvider] DEBUG - Conversation structure:`);
+        this.conversationHistory.forEach((msg, index) => {
+            logger.debug(`  Message ${index} (${msg.role}): ${msg.content.length} content items`);
+            msg.content.forEach((item, itemIndex) => {
+                const keys = Object.keys(item);
+                logger.debug(`    Content ${itemIndex}: ${keys.join(", ")}`);
+            });
+        });
+        return commandInput;
+    }
+    async processStreamResponse(commandInput, controller) {
+        const command = new ConverseStreamCommand(commandInput);
+        const response = await this.bedrockClient.send(command);
+        if (!response.stream) {
+            throw new Error("No stream returned from Bedrock");
+        }
+        const currentMessageContent = [];
+        let stopReason = "";
+        let currentText = "";
+        // Process streaming chunks
+        for await (const chunk of response.stream) {
+            if (chunk.contentBlockStart) {
+                // Starting a new content block
+                currentMessageContent.push({});
+            }
+            if (chunk.contentBlockDelta?.delta?.text) {
+                // Text delta - stream it to user
+                const textDelta = chunk.contentBlockDelta.delta.text;
+                currentText += textDelta;
+                controller.enqueue({
+                    content: textDelta,
+                });
+            }
+            if (chunk.contentBlockStart?.start?.toolUse) {
+                // Tool use block starting - initialize tool information
+                const currentBlock = currentMessageContent[currentMessageContent.length - 1];
+                currentBlock.toolUse = {
+                    name: chunk.contentBlockStart.start.toolUse.name || "",
+                    input: {}, // Initialize empty - will be populated by delta chunks
+                    toolUseId: chunk.contentBlockStart.start.toolUse.toolUseId ||
+                        `tool_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+                };
+            }
+            if (chunk.contentBlockDelta?.delta?.toolUse) {
+                // Tool use delta - accumulate tool information
+                const currentBlock = currentMessageContent[currentMessageContent.length - 1];
+                if (!currentBlock.toolUse) {
+                    currentBlock.toolUse = {
+                        name: "",
+                        input: {},
+                        toolUseId: `tool_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
+                    };
+                }
+                // Use robust parameter merging like Bedrock-MCP-Connector
+                if (chunk.contentBlockDelta.delta.toolUse.input) {
+                    // Merge parameters more robustly to avoid missing required parameters
+                    const deltaInput = chunk.contentBlockDelta.delta.toolUse.input;
+                    if (typeof deltaInput === "string") {
+                        currentBlock.toolUse.input = { value: deltaInput };
+                    }
+                    else if (deltaInput &&
+                        typeof deltaInput === "object" &&
+                        !Array.isArray(deltaInput)) {
+                        // Ensure both objects are properly typed before spreading
+                        const currentInput = currentBlock.toolUse.input || {};
+                        const newInput = deltaInput;
+                        currentBlock.toolUse.input = {
+                            ...currentInput,
+                            ...newInput,
+                        };
+                    }
+                }
+            }
+            if (chunk.contentBlockStop) {
+                // Content block completed
+                const currentBlock = currentMessageContent[currentMessageContent.length - 1];
+                if (currentText && currentBlock && !currentBlock.toolUse) {
+                    // Only add text to blocks that don't have toolUse
+                    currentBlock.text = currentText;
+                }
+                currentText = "";
+            }
+            if (chunk.messageStop) {
+                stopReason = chunk.messageStop.stopReason || "end_turn";
+                break;
+            }
+        }
+        // Add assistant message to conversation history
+        const assistantMessage = {
+            role: "assistant",
+            content: currentMessageContent,
+        };
+        this.conversationHistory.push(assistantMessage);
+        return { stopReason, assistantMessage };
+    }
+    async handleStreamStopReason(stopReason, assistantMessage, controller) {
+        if (stopReason === "end_turn" || stopReason === "stop_sequence") {
+            // Conversation completed
+            controller.close();
+            return false;
+        }
+        else if (stopReason === "tool_use") {
+            logger.debug(`🛠️ [AmazonBedrockProvider] Tool use detected in streaming - executing tools`);
+            await this.executeStreamTools(assistantMessage.content);
+            return true; // Continue conversation loop
         }
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        if (errorMessage.includes("InvalidRequestException")) {
-            return new Error(`❌ Amazon Bedrock Request Error\n\nThe request was invalid: ${errorMessage}\n\n🔧 Common Solutions:\n1. Check your model ID format\n2. Verify your request parameters\n3. Ensure your AWS account has Bedrock access`);
+        else if (stopReason === "max_tokens") {
+            // Handle max tokens by continuing conversation
+            const userMessage = {
+                role: "user",
+                content: [{ text: "Please continue." }],
+            };
+            this.conversationHistory.push(userMessage);
+            return true; // Continue conversation loop
+        }
+        else {
+            // Unknown stop reason - end conversation
+            controller.close();
+            return false;
+        }
+    }
+    async executeStreamTools(messageContent) {
+        // Execute all tool uses in the message - ensure 1:1 mapping like Bedrock-MCP-Connector
+        const toolResults = [];
+        let toolUseCount = 0;
+        // Count toolUse blocks first to ensure 1:1 mapping
+        for (const contentItem of messageContent) {
+            if (contentItem.toolUse) {
+                toolUseCount++;
+            }
         }
-        if (errorMessage.includes("AccessDeniedException")) {
-            return new Error(`❌ Amazon Bedrock Access Denied\n\nYour AWS credentials don't have permission to access Bedrock.\n\n🔧 Required Steps:\n1. Ensure your IAM user has bedrock:InvokeModel permission\n2. Check if Bedrock is available in your region\n3. Verify model access is enabled in Bedrock console`);
+        logger.debug(`🔍 [AmazonBedrockProvider] Found ${toolUseCount} toolUse blocks in assistant message`);
+        for (const contentItem of messageContent) {
+            if (contentItem.toolUse) {
+                logger.debug(`🔧 [AmazonBedrockProvider] Executing tool: ${contentItem.toolUse.name}`);
+                try {
+                    const toolResult = await this.executeSingleTool(contentItem.toolUse.name, contentItem.toolUse.input || {}, contentItem.toolUse.toolUseId);
+                    logger.debug(`✅ [AmazonBedrockProvider] Tool execution successful: ${contentItem.toolUse.name}`);
+                    // Ensure exact structure matching Bedrock-MCP-Connector
+                    toolResults.push({
+                        toolResult: {
+                            toolUseId: contentItem.toolUse.toolUseId,
+                            content: [{ text: String(toolResult) }],
+                            status: "success",
+                        },
+                    });
+                }
+                catch (error) {
+                    logger.error(`❌ [AmazonBedrockProvider] Tool execution failed: ${contentItem.toolUse.name}`, error);
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    toolResults.push({
+                        toolResult: {
+                            toolUseId: contentItem.toolUse.toolUseId,
+                            content: [
+                                {
+                                    text: `Error executing tool ${contentItem.toolUse.name}: ${errorMessage}`,
+                                },
+                            ],
+                            status: "error",
+                        },
+                    });
+                }
+            }
+        }
+        logger.debug(`📊 [AmazonBedrockProvider] Created ${toolResults.length} toolResult blocks for ${toolUseCount} toolUse blocks`);
+        // Validate 1:1 mapping before adding to conversation
+        if (toolResults.length !== toolUseCount) {
+            logger.error(`❌ [AmazonBedrockProvider] Mismatch: ${toolResults.length} toolResults vs ${toolUseCount} toolUse blocks`);
+            throw new Error(`Tool mapping mismatch: ${toolResults.length} toolResults for ${toolUseCount} toolUse blocks`);
+        }
+        // Add tool results as user message - exact structure like Bedrock-MCP-Connector
+        if (toolResults.length > 0) {
+            const userMessageWithToolResults = {
+                role: "user",
+                content: toolResults,
+            };
+            this.conversationHistory.push(userMessageWithToolResults);
+            logger.debug(`📤 [AmazonBedrockProvider] Added ${toolResults.length} tool results to conversation (1:1 mapping validated)`);
+        }
+    }
+    /**
+     * Health check for Amazon Bedrock service
+     * Uses ListFoundationModels API to validate connectivity and permissions
+     */
+    async checkBedrockHealth() {
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
+        // Create a separate BedrockClient for health checks (not BedrockRuntimeClient)
+        // Use simple configuration like working example - no custom proxy handler
+        const healthCheckClient = new BedrockClient({
+            region: process.env.AWS_REGION || "us-east-1",
+        });
+        try {
+            logger.debug("🔍 [AmazonBedrockProvider] Starting health check...");
+            const command = new ListFoundationModelsCommand({});
+            const response = await healthCheckClient.send(command, {
+                abortSignal: controller.signal,
+            });
+            const models = response.modelSummaries || [];
+            const activeModels = models.filter((model) => model.modelLifecycle?.status === "ACTIVE");
+            logger.debug(`✅ [AmazonBedrockProvider] Health check passed - Found ${activeModels.length} active models out of ${models.length} total models`);
+            if (activeModels.length === 0) {
+                throw new Error("No active foundation models available in the region");
+            }
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            const errorObj = error;
+            if (errorObj.name === "AbortError") {
+                throw new Error("Bedrock health check timed out after 10 seconds");
+            }
+            const errorMessage = typeof errorObj.message === "string" ? errorObj.message : "";
+            if (errorMessage.includes("UnauthorizedOperation") ||
+                errorMessage.includes("AccessDenied")) {
+                throw new Error("Bedrock access denied. Check your AWS credentials and IAM permissions for bedrock:ListFoundationModels");
+            }
+            if (errorObj.code === "ECONNREFUSED" || errorObj.code === "ENOTFOUND") {
+                throw new Error("Unable to connect to Bedrock service. Check your network connectivity and AWS region configuration");
+            }
+            logger.error("❌ [AmazonBedrockProvider] Health check failed:", error);
+            throw new Error(`Bedrock health check failed: ${errorMessage || "Unknown error"}`);
+        }
+        finally {
+            clearTimeout(timeoutId);
+            try {
+                healthCheckClient.destroy();
+            }
+            catch {
+                // Ignore destroy errors during cleanup
+            }
+        }
+    }
+    handleProviderError(error) {
+        // Handle AWS SDK specific errors
+        const message = error instanceof Error ? error.message : String(error);
+        if (message.includes("AccessDeniedException")) {
+            return new Error("AWS Bedrock access denied. Check your credentials and permissions.");
         }
-        if (errorMessage.includes("ValidationException")) {
-            return new Error(`❌ Amazon Bedrock Validation Error\n\n${errorMessage}\n\n🔧 Check:\n1. Model ID format (should be ARN or model identifier)\n2. Request parameters are within limits\n3. Region configuration is correct`);
+        if (message.includes("ValidationException")) {
+            return new Error(`AWS Bedrock validation error: ${message}`);
         }
-        return new Error(`❌ Amazon Bedrock Provider Error\n\n${errorMessage || "Unknown error occurred"}\n\n🔧 Troubleshooting:\n1. Check AWS credentials and permissions\n2. Verify model availability\n3. Check network connectivity`);
+        return new Error(`AWS Bedrock error: ${message}`);
     }
 }
-export default AmazonBedrockProvider;