@juspay/neurolink 11.6.0 → 11.7.0

package/dist/lib/providers/amazonBedrock/client.js

@@ -1,16 +1,15 @@
-import { BedrockRuntimeClient, ConverseCommand, ConverseStreamCommand, ImageFormat, } from "@aws-sdk/client-bedrock-runtime";
+import { BedrockRuntimeClient, ImageFormat, } from "@aws-sdk/client-bedrock-runtime";
 import path from "path";
 import { createAnalytics } from "../../core/analytics.js";
 import { BaseProvider } from "../../core/baseProvider.js";
 import { DEFAULT_MAX_STEPS } from "../../core/constants.js";
-import { withInferenceProfileFallback } from "./inferenceProfile.js";
+import { runAgenticLoop } from "../../core/loopEngine.js";
+import { createBedrockLoopAdapter } from "./loopAdapter.js";
 import { AuthenticationError, ProviderError, RateLimitError, } from "../../types/index.js";
 import { classifyProviderError } from "../../utils/errorClassifier.js";
 import { isAbortError, withTimeout } from "../../utils/errorHandling.js";
-import { emitToolEndFromStepFinish } from "../../utils/toolEndEmitter.js";
 import { logger } from "../../utils/logger.js";
 import { resolveSamplingParams } from "../../models/modelRegistry.js";
-import { calculateCost } from "../../utils/pricing.js";
 import { buildMultimodalMessagesArray } from "../../utils/messageBuilder.js";
 import { buildMultimodalOptions } from "../../utils/multimodalOptionsBuilder.js";
 import { convertZodToJsonSchema } from "../../utils/schemaConversion.js";
@@ -196,8 +195,10 @@ export class AmazonBedrockProvider extends BaseProvider {
         let text;
         let usage;
         let finishReason;
+        let rawFinishReason;
         try {
-            ({ text, usage, finishReason } = await this.conversationLoop(options));
+            ({ text, usage, finishReason, rawFinishReason } =
+                await this.conversationLoop(options));
         }
         catch (error) {
             // Emit failure generation:end so Pipeline B records the failed generation
@@ -244,344 +245,78 @@ export class AmazonBedrockProvider extends BaseProvider {
             usage,
             model: this.modelName || this.getDefaultModel(),
             provider: this.getProviderName(),
+            ...(finishReason !== undefined && { finishReason }),
+            ...(rawFinishReason !== undefined && { rawFinishReason }),
         };
     }
     async conversationLoop(options) {
-        const maxIterations = 10; // Prevent infinite loops
-        let iteration = 0;
-        let totalInputTokens = 0;
-        let totalOutputTokens = 0;
-        let totalCacheReadTokens = 0;
-        let totalCacheWriteTokens = 0;
-        let lastFinishReason;
-        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));
-                // Accumulate real token counts and capture the stop reason so
-                // Pipeline B (Langfuse) gets correct usage and finishReason.
-                // Converse follows the Anthropic additive convention: inputTokens is
-                // the UNCACHED remainder; cache reads/writes are reported separately.
-                totalInputTokens += response.usage?.inputTokens ?? 0;
-                totalOutputTokens += response.usage?.outputTokens ?? 0;
-                totalCacheReadTokens += response.usage?.cacheReadInputTokens ?? 0;
-                totalCacheWriteTokens += response.usage?.cacheWriteInputTokens ?? 0;
-                if (response.stopReason) {
-                    lastFinishReason = response.stopReason;
-                }
-                const result = await this.handleBedrockResponse(response);
-                logger.debug(`[AmazonBedrockProvider] Handle response result:`, result);
-                if (result.shouldContinue) {
-                    logger.debug(`[AmazonBedrockProvider] Continuing conversation loop...`);
-                }
-                else {
-                    logger.debug(`[AmazonBedrockProvider] Conversation completed with final text`);
-                    logger.debug(`[AmazonBedrockProvider] Returning final text: "${result.text}"`);
-                    return {
-                        text: result.text || "",
-                        usage: {
-                            input: totalInputTokens,
-                            output: totalOutputTokens,
-                            // Cache reads/writes are billed tokens reported separately
-                            // from inputTokens — the total must include them.
-                            total: totalInputTokens +
-                                totalCacheReadTokens +
-                                totalCacheWriteTokens +
-                                totalOutputTokens,
-                            ...(totalCacheReadTokens > 0 && {
-                                cacheReadTokens: totalCacheReadTokens,
-                            }),
-                            ...(totalCacheWriteTokens > 0 && {
-                                cacheCreationTokens: totalCacheWriteTokens,
-                            }),
-                        },
-                        finishReason: lastFinishReason,
-                    };
-                }
-            }
-            catch (error) {
-                logger.error(`[AmazonBedrockProvider] Error in conversation loop:`, error);
-                throw this.handleProviderError(error);
-            }
-        }
-        throw new Error("Conversation loop exceeded maximum iterations");
-    }
-    async callBedrock(options) {
-        const startTime = Date.now();
-        return bedrockTracer.startActiveSpan("bedrock.generate", {
-            kind: SpanKind.CLIENT,
-            attributes: {
-                "gen_ai.system": "aws.bedrock",
-                "gen_ai.request.model": this.modelName || this.getDefaultModel(),
-                "gen_ai.operation.name": "chat",
-            },
-        }, async (generateSpan) => {
-            logger.info(`[AmazonBedrockProvider] Starting Bedrock API call at ${new Date().toISOString()}`);
-            try {
-                // Pre-call validation and logging
-                let region = "unknown";
-                try {
-                    region =
-                        typeof this.bedrockClient.config.region === "function"
-                            ? await this.bedrockClient.config.region()
-                            : (this.bedrockClient.config.region ?? "unknown");
-                }
-                catch {
-                    // Region lookup failed — not critical, only used for logging
-                }
-                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);
-                // Registry-driven strip: models that reject sampling params
-                // (Sonnet 5 / Opus 4.7+ / Fable 5 Claude families on Bedrock)
-                // must not receive the legacy 0.7 default temperature.
-                const generateSampling = resolveSamplingParams(this.providerName, this.modelName || this.getDefaultModel(), { temperature: options.temperature ?? 0.7 }, "bedrock.converse");
-                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, // No default limit - unlimited unless specified
-                        ...(generateSampling.temperature !== undefined && {
-                            temperature: generateSampling.temperature,
-                        }),
+        // The step cap is now the same `maxSteps || DEFAULT_MAX_STEPS` the
+        // streaming path has always used. It used to be a hardcoded 10 that
+        // ignored the caller's maxSteps entirely, and reaching it threw — which
+        // then propagated into NeuroLink's provider-level retry and ran the whole
+        // turn twice more, so a runaway tool loop cost thirty billed calls. The
+        // engine stops at the cap and returns what the turn produced.
+        const maxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
+        const tools = await this.resolveTurnTools(options.tools, options.disableTools);
+        const toolConfig = this.formatToolsForBedrock(tools);
+        const sampling = resolveSamplingParams(this.providerName, this.modelName || this.getDefaultModel(), { temperature: options.temperature ?? 0.7 }, "bedrock.converse");
+        const adapter = createBedrockLoopAdapter({
+            client: this.bedrockClient,
+            streaming: false,
+            region: this.region,
+            maxSteps,
+            buildCommandInput: (conversation) => ({
+                modelId: this.modelName || this.getDefaultModel(),
+                messages: this.convertToAWSMessages(conversation),
+                system: [
+                    {
+                        text: options.systemPrompt ||
+                            "You are a helpful assistant with access to external tools. Use tools when necessary to provide accurate information.",
                     },
-                };
-                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`);
-                logger.debug("[Observability] Bedrock API request", {
-                    model: commandInput.modelId,
-                    region: region,
-                    messageCount: commandInput.messages?.length || 0,
-                    toolCount: commandInput.toolConfig?.tools?.length || 0,
-                    maxTokens: commandInput.inferenceConfig?.maxTokens,
-                });
-                const apiCallStartTime = Date.now();
-                const response = await withInferenceProfileFallback(commandInput.modelId ?? "", 
-                // `this.region`, not the local `region` above: that one is
-                // best-effort for logging and stays "unknown" if the lookup
-                // throws. It must also match the id the streaming path keys its
-                // cache by, or a resolution found here is never reused there.
-                this.region, (effectiveModelId) => withTimeout(this.bedrockClient.send(new ConverseCommand({
-                    ...commandInput,
-                    modelId: effectiveModelId,
-                })), 120_000, new Error("Bedrock API call timed out")));
-                const apiCallDuration = Date.now() - apiCallStartTime;
-                logger.debug("[Observability] Bedrock API response", {
-                    model: commandInput.modelId,
-                    durationMs: apiCallDuration,
-                    hasContent: !!response.output?.message?.content?.length,
-                    stopReason: response.stopReason,
-                    usage: response.usage
-                        ? {
-                            inputTokens: response.usage.inputTokens,
-                            outputTokens: response.usage.outputTokens,
-                            totalTokens: (response.usage.inputTokens || 0) +
-                                (response.usage.outputTokens || 0),
-                        }
-                        : undefined,
-                });
-                logger.info(`[AmazonBedrockProvider] Bedrock API call successful`);
-                logger.info(`[AmazonBedrockProvider] API call duration: ${apiCallDuration}ms`);
-                const totalDuration = Date.now() - startTime;
-                logger.info(`[AmazonBedrockProvider] Total callBedrock duration: ${totalDuration}ms`);
-                generateSpan.setAttribute("gen_ai.response.stop_reason", response.stopReason ?? "");
-                const spanCacheRead = response.usage?.cacheReadInputTokens ?? 0;
-                const spanCacheWrite = response.usage?.cacheWriteInputTokens ?? 0;
-                // Converse's inputTokens is only the UNCACHED remainder — the span
-                // attribute reports the FULL prompt (uncached + cache read/write)
-                // so telemetry matches the cache-inclusive pricing inputs below.
-                generateSpan.setAttribute("gen_ai.usage.input_tokens", (response.usage?.inputTokens ?? 0) + spanCacheRead + spanCacheWrite);
-                generateSpan.setAttribute("gen_ai.usage.cache_read_input_tokens", spanCacheRead);
-                generateSpan.setAttribute("gen_ai.usage.cache_creation_input_tokens", spanCacheWrite);
-                generateSpan.setAttribute("gen_ai.usage.output_tokens", response.usage?.outputTokens ?? 0);
-                const cost = calculateCost(this.providerName, this.modelName, {
-                    input: response.usage?.inputTokens ?? 0,
-                    output: response.usage?.outputTokens ?? 0,
-                    total: (response.usage?.inputTokens ?? 0) +
-                        spanCacheRead +
-                        spanCacheWrite +
-                        (response.usage?.outputTokens ?? 0),
-                    ...(spanCacheRead > 0 && { cacheReadTokens: spanCacheRead }),
-                    ...(spanCacheWrite > 0 && {
-                        cacheCreationTokens: spanCacheWrite,
+                ],
+                inferenceConfig: {
+                    maxTokens: options.maxTokens,
+                    ...(sampling.temperature !== undefined && {
+                        temperature: sampling.temperature,
                     }),
-                });
-                if (cost && cost > 0) {
-                    generateSpan.setAttribute("neurolink.cost", cost);
-                }
-                generateSpan.setStatus({ code: SpanStatusCode.OK });
-                generateSpan.end();
-                return response;
-            }
-            catch (error) {
-                const errorDuration = Date.now() - startTime;
-                // Extract AWS metadata for structured logging
-                const awsError = error && typeof error === "object"
-                    ? error
-                    : null;
-                const metadata = awsError?.$metadata && typeof awsError.$metadata === "object"
-                    ? awsError.$metadata
-                    : null;
-                logger.debug("[Observability] Bedrock API request failed", {
-                    model: this.modelName || this.getDefaultModel(),
-                    durationMs: errorDuration,
-                    error: error instanceof Error ? error.message : String(error),
-                    errorName: error instanceof Error ? error.name : undefined,
-                    httpStatus: metadata?.httpStatusCode,
-                    awsRequestId: metadata?.requestId,
-                    awsErrorCode: awsError?.Code,
-                });
-                logger.error(`[AmazonBedrockProvider] Bedrock API call failed after ${errorDuration}ms`);
-                if (error instanceof Error) {
-                    logger.error(`[AmazonBedrockProvider] Error: ${error.name} - ${error.message}`);
-                }
-                if (metadata) {
-                    logger.error(`[AmazonBedrockProvider] AWS SDK metadata`, {
-                        httpStatus: metadata.httpStatusCode,
-                        requestId: metadata.requestId,
-                        attempts: metadata.attempts,
-                        totalRetryDelay: metadata.totalRetryDelay,
-                    });
-                }
-                generateSpan.setStatus({
-                    code: SpanStatusCode.ERROR,
-                    message: error instanceof Error ? error.message : String(error),
-                });
-                generateSpan.recordException(error instanceof Error ? error : new Error(String(error)));
-                generateSpan.end();
-                throw error;
-            }
-        }); // end bedrockTracer.startActiveSpan('bedrock.generate')
-    }
-    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;
+                },
+                ...(toolConfig ? { toolConfig } : {}),
             }),
-        };
-        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",
-                            },
-                        });
-                    }
-                    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`);
-            }
-            return { shouldContinue: true };
-        }
-        else if (stopReason === "max_tokens") {
-            // Max tokens reached — return what we have rather than continuing,
-            // since the model hit the configured limit.
-            const textContent = bedrockAssistantMessage.content
-                .filter((item) => item.text)
-                .map((item) => item.text)
-                .join(" ");
-            return { shouldContinue: false, text: textContent };
+        });
+        try {
+            const { resultPromise } = runAgenticLoop(adapter, this.conversationHistory, {
+                tools: this.toEngineTools(tools),
+                abortSignal: options.abortSignal,
+            });
+            const result = await resultPromise;
+            this.conversationHistory = result.conversation;
+            const input = result.usage.inputTokens;
+            const output = result.usage.outputTokens;
+            const cacheRead = result.usage.cacheReadTokens ?? 0;
+            const cacheWrite = result.usage.cacheWriteTokens ?? 0;
+            return {
+                text: result.text || "",
+                usage: {
+                    input,
+                    output,
+                    // Cache reads/writes are billed tokens reported separately from
+                    // inputTokens — the total must include them.
+                    total: input + cacheRead + cacheWrite + output,
+                    ...(cacheRead > 0 && { cacheReadTokens: cacheRead }),
+                    ...(cacheWrite > 0 && { cacheCreationTokens: cacheWrite }),
+                },
+                // The MAPPED reason, matching the streaming path and every AI-SDK
+                // backed provider. This path previously surfaced Bedrock's raw value,
+                // so a turn stopped at the step cap reported "tool_use" here while
+                // the same turn reported "tool-calls" when streamed. The raw value is
+                // kept alongside rather than dropped.
+                finishReason: result.finishReason,
+                rawFinishReason: result.rawStopReason,
+            };
         }
-        else {
-            logger.warn(`[AmazonBedrockProvider] Unrecognized stop reason "${stopReason}", ending conversation.`);
-            return { shouldContinue: false, text: "" };
+        catch (error) {
+            logger.error(`[AmazonBedrockProvider] Error in conversation loop:`, error);
+            throw this.handleProviderError(error);
         }
     }
     convertToAWSMessages(bedrockMessages) {
@@ -625,7 +360,16 @@ export class AmazonBedrockProvider extends BaseProvider {
             }),
         }));
     }
-    async executeSingleTool(toolName, args, _toolUseId) {
+    /**
+     * `tools` is passed in rather than re-resolved from `getAllTools()`. That
+     * call returns only the provider's own registry, so resolving here meant a
+     * tool the caller passed to generate/stream could never execute — the
+     * streaming path advertised it to the model and then failed every call to
+     * it with "Tool not found", and the generate path never advertised it at
+     * all. The turn's full merged tool set is resolved once by the caller and
+     * handed down.
+     */
+    async executeSingleTool(tools, toolName, args, _toolUseId) {
         return bedrockTracer.startActiveSpan("bedrock.tool.execute", {
             kind: SpanKind.CLIENT,
             attributes: {
@@ -637,9 +381,6 @@ export class AmazonBedrockProvider extends BaseProvider {
                 logger.debug(`[AmazonBedrockProvider] Executing single tool: ${toolName}`, {
                     args,
                 });
-                // 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}`);
                 }
@@ -727,6 +468,39 @@ export class AmazonBedrockProvider extends BaseProvider {
             }
         });
     }
+    /**
+     * Resolve the turn's tools once: whatever the caller passed, else the
+     * provider's own registry. `BaseProvider.stream()` has already merged base
+     * tools into `options.tools` by the time it reaches the streaming path;
+     * the generate path has no such pre-merge, so it falls back here.
+     */
+    async resolveTurnTools(optionTools, disableTools) {
+        // `generate()` reaches conversationLoop() without going through
+        // BaseProvider's tool preparation, so `options.tools` is undefined there
+        // and the getAllTools() fallback would hand the model the whole registry
+        // even when the caller asked for no tools at all.
+        if (disableTools) {
+            return {};
+        }
+        const aiTools = optionTools ??
+            (await this.getAllTools());
+        return this.convertAISDKToolsToToolDefinitions(aiTools);
+    }
+    /**
+     * Present the resolved tools in the shape `runAgenticLoop` dispatches
+     * through. Execution still goes through `executeSingleTool`, so the tool
+     * span, the parameter defaults and the ToolResult unwrapping are unchanged
+     * — only which tools are reachable changes.
+     */
+    toEngineTools(tools) {
+        const engineTools = {};
+        for (const name of Object.keys(tools)) {
+            engineTools[name] = {
+                execute: (args) => this.executeSingleTool(tools, name, args),
+            };
+        }
+        return engineTools;
+    }
     convertAISDKToolsToToolDefinitions(aiTools) {
         const result = {};
         for (const [name, tool] of Object.entries(aiTools)) {
@@ -1052,631 +826,183 @@ export class AmazonBedrockProvider extends BaseProvider {
         });
     }
     async streamingConversationLoop(options, streamSpan) {
-        logger.debug("[TRACE] streamingConversationLoop ENTRY");
         const startTime = Date.now();
-        const maxIterations = options.maxSteps || DEFAULT_MAX_STEPS;
-        let iteration = 0;
-        // Shared counters updated by both the first-iteration inline loop and
-        // the processStreamResponse loop. Read by the final generation:end emit
-        // so Pipeline B (Langfuse) gets real token counts from Bedrock streams.
-        let streamTotalInputTokens = 0;
-        let streamTotalOutputTokens = 0;
-        let streamTotalCacheReadTokens = 0;
-        let streamTotalCacheWriteTokens = 0;
-        let streamLastStopReason;
-        // 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 {
-            logger.debug("[TRACE] streamingConversationLoop - testing first streaming call");
-            const commandInput = await this.prepareStreamCommand(options);
-            logger.debug("[Observability] Bedrock streaming API request", {
-                model: commandInput.modelId,
-                messageCount: commandInput.messages?.length || 0,
-                toolCount: commandInput.toolConfig?.tools?.length || 0,
-            });
-            streamSpan.addEvent("stream.api_call", {
-                "bedrock.message_count": commandInput.messages?.length || 0,
-                "bedrock.tool_count": commandInput.toolConfig?.tools?.length || 0,
-            });
-            const streamStartTime = Date.now();
-            const response = await withInferenceProfileFallback(commandInput.modelId ?? "", this.region, (effectiveModelId) => withTimeout(this.bedrockClient.send(new ConverseStreamCommand({
-                ...commandInput,
-                modelId: effectiveModelId,
-            })), 120_000, new Error("Bedrock streaming API call timed out")));
-            logger.debug("[Observability] Bedrock streaming API connection established", {
-                model: commandInput.modelId,
-                durationMs: Date.now() - streamStartTime,
-                hasStream: !!response.stream,
-            });
-            // Process the first response immediately to avoid waste
-            const stream = new ReadableStream({
-                start: async (controller) => {
-                    logger.debug("[TRACE] streamingConversationLoop - ReadableStream start() called");
-                    try {
-                        // Process the first response we already have, tracking all event types
-                        let firstStopReason = "";
-                        if (response.stream) {
-                            const firstMessageContent = [];
-                            let firstText = "";
-                            for await (const chunk of response.stream) {
-                                if (chunk.contentBlockStart) {
-                                    firstMessageContent.push({});
-                                }
-                                if (chunk.contentBlockDelta?.delta?.text) {
-                                    const textDelta = chunk.contentBlockDelta.delta.text;
-                                    firstText += textDelta;
-                                    controller.enqueue({ content: textDelta });
-                                }
-                                if (chunk.contentBlockStart?.start?.toolUse) {
-                                    const currentBlock = firstMessageContent[firstMessageContent.length - 1];
-                                    currentBlock.toolUse = {
-                                        name: chunk.contentBlockStart.start.toolUse.name || "",
-                                        input: {},
-                                        toolUseId: chunk.contentBlockStart.start.toolUse.toolUseId ||
-                                            `tool_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
-                                    };
-                                }
-                                if (chunk.contentBlockDelta?.delta?.toolUse) {
-                                    const currentBlock = firstMessageContent[firstMessageContent.length - 1];
-                                    if (!currentBlock.toolUse) {
-                                        currentBlock.toolUse = {
-                                            name: "",
-                                            input: {},
-                                            toolUseId: `tool_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`,
-                                        };
-                                    }
-                                    const deltaInput = chunk.contentBlockDelta.delta.toolUse.input;
-                                    if (!deltaInput) {
-                                        // no input delta
-                                    }
-                                    else if (typeof deltaInput === "string") {
-                                        currentBlock._inputBuffer =
-                                            (currentBlock._inputBuffer || "") + deltaInput;
-                                    }
-                                    else if (typeof deltaInput === "object" &&
-                                        !Array.isArray(deltaInput)) {
-                                        const currentInput = currentBlock.toolUse.input || {};
-                                        currentBlock.toolUse.input = {
-                                            ...currentInput,
-                                            ...deltaInput,
-                                        };
-                                    }
-                                }
-                                if (chunk.contentBlockStop) {
-                                    const currentBlock = firstMessageContent[firstMessageContent.length - 1];
-                                    if (currentBlock?.toolUse && currentBlock._inputBuffer) {
-                                        try {
-                                            currentBlock.toolUse.input = JSON.parse(currentBlock._inputBuffer);
-                                        }
-                                        catch {
-                                            currentBlock.toolUse.input = {};
-                                        }
-                                        delete currentBlock._inputBuffer;
-                                    }
-                                    if (firstText && currentBlock && !currentBlock.toolUse) {
-                                        currentBlock.text = firstText;
-                                    }
-                                    firstText = "";
-                                }
-                                if (chunk.messageStop) {
-                                    firstStopReason = chunk.messageStop.stopReason || "end_turn";
-                                    // Don't break — metadata chunk with usage comes after messageStop
-                                    continue;
-                                }
-                                // Accumulate usage from Bedrock metadata chunk for Pipeline B.
-                                // The metadata chunk is emitted after messageStop with aggregate usage.
-                                if (chunk.metadata?.usage) {
-                                    streamTotalInputTokens +=
-                                        chunk.metadata.usage.inputTokens ?? 0;
-                                    streamTotalOutputTokens +=
-                                        chunk.metadata.usage.outputTokens ?? 0;
-                                    // inputTokens excludes cache reads/writes (Converse follows
-                                    // the Anthropic additive convention) — track them too.
-                                    streamTotalCacheReadTokens +=
-                                        chunk.metadata.usage.cacheReadInputTokens ?? 0;
-                                    streamTotalCacheWriteTokens +=
-                                        chunk.metadata.usage.cacheWriteInputTokens ?? 0;
-                                    // Stream is effectively complete after metadata chunk
-                                    break;
-                                }
-                            }
-                            if (firstStopReason) {
-                                streamLastStopReason = firstStopReason;
-                            }
-                            // Add first assistant message to conversation history
-                            const firstAssistantMessage = {
-                                role: "assistant",
-                                content: firstMessageContent,
-                            };
-                            this.conversationHistory.push(firstAssistantMessage);
-                            streamSpan.addEvent("stream.turn_complete", {
-                                iteration: 0,
-                                stop_reason: firstStopReason,
-                            });
-                            if (firstStopReason === "tool_use") {
-                                const toolNames = firstMessageContent
-                                    .flatMap((b) => (b.toolUse?.name ? [b.toolUse.name] : []))
-                                    .join(", ");
-                                streamSpan.addEvent("stream.tool_use", {
-                                    iteration: 0,
-                                    tool_names: toolNames,
-                                });
-                            }
-                            // Handle the stop reason from the first response
-                            const shouldContinue = await this.handleStreamStopReason(firstStopReason, firstAssistantMessage, controller, options);
-                            if (!shouldContinue) {
-                                streamSpan.setAttribute("gen_ai.response.stop_reason", firstStopReason);
-                                // Close the controller so downstream `for await` exits;
-                                // see the close() comment near the bottom of this start()
-                                // function for the spec rationale.
-                                controller.close();
-                                return;
-                            }
-                        }
-                        // 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, usage } = await this.processStreamResponse(commandInput, controller);
-                            // Accumulate real usage from Bedrock metadata chunks.
-                            if (usage) {
-                                streamTotalInputTokens += usage.input;
-                                streamTotalOutputTokens += usage.output;
-                                streamTotalCacheReadTokens += usage.cacheReadTokens ?? 0;
-                                streamTotalCacheWriteTokens += usage.cacheCreationTokens ?? 0;
-                            }
-                            if (stopReason) {
-                                streamLastStopReason = stopReason;
-                            }
-                            streamSpan.addEvent("stream.turn_complete", {
-                                iteration,
-                                stop_reason: stopReason,
-                            });
-                            if (stopReason === "tool_use") {
-                                const toolNames = assistantMessage.content
-                                    .flatMap((b) => (b.toolUse?.name ? [b.toolUse.name] : []))
-                                    .join(", ");
-                                streamSpan.addEvent("stream.tool_use", {
-                                    iteration,
-                                    tool_names: toolNames,
-                                });
-                            }
-                            const shouldContinue = await this.handleStreamStopReason(stopReason, assistantMessage, controller, options);
-                            if (!shouldContinue) {
-                                streamSpan.setAttribute("gen_ai.response.stop_reason", stopReason);
-                                break;
-                            }
-                        }
-                        if (iteration >= maxIterations) {
-                            streamSpan.setAttribute("gen_ai.response.stop_reason", "max_iterations");
-                            controller.error(new Error("Streaming conversation exceeded maximum iterations"));
-                            return;
-                        }
-                        // CRITICAL: ReadableStream's start() returning does NOT auto-close
-                        // the controller per the WHATWG Streams spec. Without this, the
-                        // downstream `for await (const chunk of stream)` in
-                        // convertToAsyncIterable never sees `done: true` and the
-                        // consumer hangs forever — manifested as a 240s harness
-                        // PER_TEST_TIMEOUT_SKIP for `[bedrock] stream tokens`. The first-
-                        // iteration `return` path and the while-loop natural `break`
-                        // path both reach here, so closing once at the bottom covers
-                        // every non-error exit.
-                        controller.close();
-                    }
-                    catch (error) {
-                        logger.debug("[TRACE] streamingConversationLoop - CATCH block hit in ReadableStream");
-                        controller.error(error);
-                    }
-                },
-            });
-            // Emit generation:end after the stream completes so Pipeline B (Langfuse)
-            // creates a GENERATION observation. Bedrock bypasses the Vercel AI SDK so
-            // experimental_telemetry is never injected; we emit the event manually.
-            const streamEmitter = this.neurolink?.getEventEmitter();
-            const streamAsyncIterable = this.convertToAsyncIterable(stream);
-            const self = this;
-            // Defer analytics resolution until the stream completes so we have
-            // real token counts aggregated from Bedrock metadata chunks.
-            let resolveAnalytics;
-            const analyticsPromise = new Promise((resolve) => {
-                resolveAnalytics = resolve;
-            });
-            const wrappedStreamIterable = {
-                async *[Symbol.asyncIterator]() {
-                    let streamErrored = false;
-                    try {
-                        yield* streamAsyncIterable;
-                    }
-                    catch (error) {
-                        streamErrored = true;
-                        throw error;
-                    }
-                    finally {
-                        const aggregatedUsage = {
-                            input: streamTotalInputTokens,
-                            output: streamTotalOutputTokens,
-                            // Cache reads/writes are billed tokens reported separately
-                            // from inputTokens — the total must include them.
-                            total: streamTotalInputTokens +
-                                streamTotalCacheReadTokens +
-                                streamTotalCacheWriteTokens +
-                                streamTotalOutputTokens,
-                            ...(streamTotalCacheReadTokens > 0 && {
-                                cacheReadTokens: streamTotalCacheReadTokens,
-                            }),
-                            ...(streamTotalCacheWriteTokens > 0 && {
-                                cacheCreationTokens: streamTotalCacheWriteTokens,
-                            }),
-                        };
-                        // Resolve analytics with accumulated token counts from Bedrock
-                        // metadata chunks so Pipeline A also reports real usage.
-                        resolveAnalytics(createAnalytics(self.providerName, self.modelName || self.getDefaultModel(), { usage: aggregatedUsage }, Date.now() - startTime, {
-                            requestId: `bedrock-stream-${Date.now()}`,
-                            streamingMode: true,
-                        }));
-                        if (streamEmitter) {
-                            streamEmitter.emit("generation:end", {
-                                provider: self.providerName,
-                                responseTime: Date.now() - startTime,
-                                timestamp: Date.now(),
-                                result: {
-                                    content: "",
-                                    usage: aggregatedUsage,
-                                    model: self.modelName || self.getDefaultModel(),
-                                    provider: self.providerName,
-                                    finishReason: streamErrored ? "error" : streamLastStopReason,
-                                },
-                                success: !streamErrored,
-                            });
-                        }
-                    }
-                },
-            };
-            return {
-                stream: wrappedStreamIterable,
-                // No usage key here on purpose: the real aggregate resolves through
-                // `analytics` after the stream drains. A literal zero object is
-                // truthy and would block every downstream usage fallback.
-                model: this.modelName || this.getDefaultModel(),
-                provider: this.getProviderName(),
-                analytics: analyticsPromise,
-                metadata: {
-                    startTime,
-                    streamId: `bedrock-${Date.now()}`,
+        const maxSteps = options.maxSteps || DEFAULT_MAX_STEPS;
+        // Resolved once for the whole turn. Bedrock has no mid-turn tool
+        // discovery, so nothing here would need re-resolving per step.
+        const tools = await this.resolveTurnTools(options.tools, options.disableTools);
+        const toolConfig = this.formatToolsForBedrock(tools);
+        const sampling = resolveSamplingParams(this.providerName, this.modelName || this.getDefaultModel(), { temperature: options.temperature ?? 0.7 }, "bedrock.converseStream");
+        const baseAdapter = createBedrockLoopAdapter({
+            client: this.bedrockClient,
+            streaming: true,
+            region: this.region,
+            maxSteps,
+            buildCommandInput: (conversation) => ({
+                modelId: this.modelName || this.getDefaultModel(),
+                messages: this.convertToAWSMessages(conversation),
+                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,
+                    ...(sampling.temperature !== undefined && {
+                        temperature: sampling.temperature,
+                    }),
                 },
+                ...(toolConfig ? { toolConfig } : {}),
+            }),
+        });
+        // executeStream() falls back to non-streaming generate() when the first
+        // call fails on permissions, and that only works if the failure reaches it
+        // synchronously. The engine runs the turn in the background, so the first
+        // successful send reports separately.
+        //
+        // Success is the ONLY thing signalled here. The engine wraps every
+        // executeStep in withProviderRetry, so rejecting on a failed attempt
+        // would settle this promise on attempt one and never un-settle it: a
+        // retryable 429 would be reported as a dead turn even though the engine's
+        // own retry went on to succeed, and this method would throw while that
+        // retried — and billed — turn kept running in the background with its
+        // output discarded, with the fallback generate() billed on top. A
+        // terminal failure is taken from the turn's settled outcome instead,
+        // which by definition is reached only after the engine has stopped
+        // retrying.
+        let firstStepSucceeded = false;
+        let firstStepSent;
+        const firstStep = new Promise((resolve) => {
+            firstStepSent = () => {
+                firstStepSucceeded = true;
+                resolve();
             };
-        }
-        catch (error) {
-            logger.debug("[TRACE] streamingConversationLoop - first streaming call FAILED, throwing");
-            throw error; // This will be caught by executeStream
-        }
-    }
-    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();
-                }
+        });
+        const adapter = {
+            ...baseAdapter,
+            executeStep: async (request, channel, signal) => {
+                const stepResult = await baseAdapter.executeStep(request, channel, signal);
+                firstStepSent();
+                return stepResult;
             },
         };
-    }
-    async prepareStreamCommand(options) {
-        // CRITICAL DEBUG: Log conversation history before conversion
-        if (logger.shouldLog("debug")) {
-            logger.debug(`[AmazonBedrockProvider] BEFORE conversion - conversationHistory length: ${this.conversationHistory.length}`);
-            this.conversationHistory.forEach((msg, index) => {
-                logger.debug(`[AmazonBedrockProvider] Message ${index}: role=${msg.role}, content=${JSON.stringify(msg.content)}`);
-            });
-        }
-        // Get all available tools
-        // BaseProvider.stream() pre-merges base tools + external tools into options.tools
-        const aiTools = options.tools || (await this.getAllTools());
-        const allTools = this.convertAISDKToolsToToolDefinitions(aiTools);
-        const toolConfig = this.formatToolsForBedrock(allTools);
-        const convertedMessages = this.convertToAWSMessages(this.conversationHistory);
-        if (logger.shouldLog("debug")) {
-            logger.debug(`[AmazonBedrockProvider] AFTER conversion - messages length: ${convertedMessages.length}`);
-            convertedMessages.forEach((msg, index) => {
-                logger.debug(`[AmazonBedrockProvider] Converted Message ${index}: role=${msg.role}, content=${JSON.stringify(msg.content)}`);
-            });
+        streamSpan.addEvent("stream.api_call", {
+            "bedrock.tool_count": toolConfig?.tools?.length ?? 0,
+        });
+        const { stream, resultPromise } = runAgenticLoop(adapter, this.conversationHistory, {
+            tools: this.toEngineTools(tools),
+            abortSignal: options.abortSignal,
+        });
+        // The stream surfaces the same failure, so this settled view exists only
+        // so the turn's outcome can be read without a second unhandled rejection.
+        const settled = resultPromise.then((result) => ({ result, error: undefined }), (error) => ({ result: undefined, error }));
+        // A turn that ends without ever completing a step — an abort before the
+        // first request, or a failure the engine gave up retrying — would leave
+        // `firstStep` pending forever, so the settled outcome releases the wait
+        // too.
+        await Promise.race([firstStep, settled]);
+        if (!firstStepSucceeded) {
+            // The turn ended before any send succeeded. Surface its error here so
+            // executeStream's permission fallback still sees it synchronously.
+            const outcome = await settled;
+            if (outcome.error) {
+                throw outcome.error;
+            }
         }
-        // Registry-driven strip: models that reject sampling params (Sonnet 5 /
-        // Opus 4.7+ / Fable 5 Claude families on Bedrock) must not receive the
-        // legacy 0.7 default temperature.
-        const streamSampling = resolveSamplingParams(this.providerName, this.modelName || this.getDefaultModel(), { temperature: options.temperature ?? 0.7 }, "bedrock.converseStream");
-        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, // No default limit - unlimited unless specified
-                ...(streamSampling.temperature !== undefined && {
-                    temperature: streamSampling.temperature,
-                }),
-            },
+        const streamEmitter = this.neurolink?.getEventEmitter();
+        const self = this;
+        const metadata = {
+            startTime,
+            streamId: `bedrock-${Date.now()}`,
         };
-        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);
-        logger.debug("[Observability] Bedrock streaming API request (continuation)", {
-            model: commandInput.modelId,
-            messageCount: commandInput.messages?.length || 0,
+        let resolveAnalytics;
+        const analyticsPromise = new Promise((resolve) => {
+            resolveAnalytics = resolve;
         });
-        const iterationStartTime = Date.now();
-        const response = await withTimeout(this.bedrockClient.send(command), 120_000, new Error("Bedrock streaming API call timed out"));
-        logger.debug("[Observability] Bedrock streaming API connection established (continuation)", {
-            model: commandInput.modelId,
-            durationMs: Date.now() - iterationStartTime,
+        const usageFromOutcome = (usage) => {
+            const input = usage?.inputTokens ?? 0;
+            const output = usage?.outputTokens ?? 0;
+            const cacheRead = usage?.cacheReadTokens ?? 0;
+            const cacheWrite = usage?.cacheWriteTokens ?? 0;
+            return {
+                input,
+                output,
+                // Cache reads/writes are billed tokens reported separately from
+                // inputTokens — the total must include them.
+                total: input + cacheRead + cacheWrite + output,
+                ...(cacheRead > 0 && { cacheReadTokens: cacheRead }),
+                ...(cacheWrite > 0 && { cacheCreationTokens: cacheWrite }),
+            };
+        };
+        // Bind analytics to the turn ending, not to the consumer draining the
+        // stream. A caller that awaits `result.analytics` without iterating
+        // `result.stream` would otherwise wait forever, because the generator
+        // body — and its finally block — never runs. Resolving twice is
+        // harmless; the first call wins.
+        void settled.then((outcome) => {
+            resolveAnalytics(createAnalytics(this.providerName, this.modelName || this.getDefaultModel(), { usage: usageFromOutcome(outcome.result?.usage) }, Date.now() - startTime, {
+                requestId: `bedrock-stream-${Date.now()}`,
+                streamingMode: true,
+            }));
         });
-        if (!response.stream) {
-            throw new Error("No stream returned from Bedrock");
-        }
-        const currentMessageContent = [];
-        let stopReason = "";
-        let currentText = "";
-        let streamUsage;
-        // 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)}`,
-                    };
+        const wrappedStreamIterable = {
+            async *[Symbol.asyncIterator]() {
+                let streamErrored = false;
+                try {
+                    yield* stream;
                 }
-                // Accumulate JSON string fragments into _inputBuffer.
-                // Bedrock sends toolUse.input as incremental JSON string fragments,
-                // not pre-parsed objects. We buffer them and parse at contentBlockStop.
-                if (chunk.contentBlockDelta.delta.toolUse.input) {
-                    const deltaInput = chunk.contentBlockDelta.delta.toolUse.input;
-                    if (typeof deltaInput === "string") {
-                        currentBlock._inputBuffer =
-                            (currentBlock._inputBuffer || "") + deltaInput;
-                    }
-                    else if (deltaInput &&
-                        typeof deltaInput === "object" &&
-                        !Array.isArray(deltaInput)) {
-                        // Some SDK versions may deliver pre-parsed objects; merge directly
-                        const currentInput = currentBlock.toolUse.input || {};
-                        currentBlock.toolUse.input = {
-                            ...currentInput,
-                            ...deltaInput,
-                        };
-                    }
+                catch (error) {
+                    streamErrored = true;
+                    throw error;
                 }
-            }
-            if (chunk.contentBlockStop) {
-                // Content block completed
-                const currentBlock = currentMessageContent[currentMessageContent.length - 1];
-                // Parse accumulated JSON input buffer for tool-use blocks
-                if (currentBlock?.toolUse && currentBlock._inputBuffer) {
-                    try {
-                        currentBlock.toolUse.input = JSON.parse(currentBlock._inputBuffer);
+                finally {
+                    const outcome = await settled;
+                    if (outcome.error) {
+                        streamErrored = true;
                     }
-                    catch {
-                        currentBlock.toolUse.input = {};
+                    const aggregatedUsage = usageFromOutcome(outcome.result?.usage);
+                    if (outcome.result) {
+                        self.conversationHistory = outcome.result.conversation;
+                        metadata.finishReason = outcome.result.finishReason;
+                        metadata.rawFinishReason = outcome.result.rawStopReason;
+                        streamSpan.setAttribute("gen_ai.response.stop_reason", outcome.result.rawStopReason ?? "unknown");
+                    }
+                    // Analytics is resolved off `settled` above, so it lands whether or
+                    // not anyone drains the stream.
+                    // Bedrock bypasses the Vercel AI SDK, so experimental_telemetry is
+                    // never injected and generation:end is emitted by hand for
+                    // Pipeline B (Langfuse).
+                    if (streamEmitter) {
+                        streamEmitter.emit("generation:end", {
+                            provider: self.providerName,
+                            responseTime: Date.now() - startTime,
+                            timestamp: Date.now(),
+                            result: {
+                                content: "",
+                                usage: aggregatedUsage,
+                                model: self.modelName || self.getDefaultModel(),
+                                provider: self.providerName,
+                                finishReason: streamErrored
+                                    ? "error"
+                                    : outcome.result?.rawStopReason,
+                            },
+                            success: !streamErrored,
+                        });
                     }
-                    delete currentBlock._inputBuffer;
-                }
-                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";
-                // Don't break — metadata chunk with usage arrives after messageStop
-                continue;
-            }
-            // Bedrock ConverseStream emits a metadata chunk at the end with
-            // aggregate usage. Capture it for Pipeline B telemetry.
-            if (chunk.metadata?.usage) {
-                const input = chunk.metadata.usage.inputTokens ?? 0;
-                const output = chunk.metadata.usage.outputTokens ?? 0;
-                const cacheRead = chunk.metadata.usage.cacheReadInputTokens ?? 0;
-                const cacheWrite = chunk.metadata.usage.cacheWriteInputTokens ?? 0;
-                streamUsage = {
-                    input,
-                    output,
-                    // Computed rather than trusting totalTokens: inputTokens excludes
-                    // cache reads/writes (additive convention), and the total must
-                    // count every billed component.
-                    total: input + cacheRead + cacheWrite + output,
-                    ...(cacheRead > 0 && { cacheReadTokens: cacheRead }),
-                    ...(cacheWrite > 0 && { cacheCreationTokens: cacheWrite }),
-                };
-                // Stream is effectively complete after metadata chunk
-                break;
-            }
-        }
-        // Add assistant message to conversation history
-        const assistantMessage = {
-            role: "assistant",
-            content: currentMessageContent,
+            },
+        };
+        return {
+            stream: wrappedStreamIterable,
+            // No usage key here on purpose: the real aggregate resolves through
+            // `analytics` after the stream drains. A literal zero object is truthy
+            // and would block every downstream usage fallback.
+            model: this.modelName || this.getDefaultModel(),
+            provider: this.getProviderName(),
+            analytics: analyticsPromise,
+            metadata,
         };
-        this.conversationHistory.push(assistantMessage);
-        return { stopReason, assistantMessage, usage: streamUsage };
-    }
-    async handleStreamStopReason(stopReason, assistantMessage, controller, options) {
-        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, options);
-            return true; // Continue conversation loop
-        }
-        else if (stopReason === "max_tokens") {
-            // Max tokens reached — close the stream rather than continuing,
-            // since the model hit the configured limit.
-            controller.close();
-            return false;
-        }
-        else {
-            // Unknown stop reason - end conversation
-            controller.close();
-            return false;
-        }
-    }
-    async executeStreamTools(messageContent, options) {
-        // Execute all tool uses in the message - ensure 1:1 mapping like Bedrock-MCP-Connector
-        const toolResults = [];
-        let toolUseCount = 0;
-        // Track tool calls and results for storage (similar to Vertex onStepFinish)
-        const toolCalls = [];
-        const toolResultsForStorage = [];
-        // Count toolUse blocks first to ensure 1:1 mapping
-        for (const contentItem of messageContent) {
-            if (contentItem.toolUse) {
-                toolUseCount++;
-            }
-        }
-        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}`);
-                // Track tool call
-                toolCalls.push({
-                    type: "tool-call",
-                    toolCallId: contentItem.toolUse.toolUseId,
-                    toolName: contentItem.toolUse.name,
-                    args: contentItem.toolUse.input || {},
-                });
-                try {
-                    const toolResult = await this.executeSingleTool(contentItem.toolUse.name, contentItem.toolUse.input || {}, contentItem.toolUse.toolUseId);
-                    logger.debug(`[AmazonBedrockProvider] Tool execution successful: ${contentItem.toolUse.name}`);
-                    // Track tool result for storage
-                    toolResultsForStorage.push({
-                        type: "tool-result",
-                        toolCallId: contentItem.toolUse.toolUseId,
-                        toolName: contentItem.toolUse.name,
-                        result: toolResult,
-                    });
-                    // 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);
-                    // Track failed tool result
-                    toolResultsForStorage.push({
-                        type: "tool-result",
-                        toolCallId: contentItem.toolUse.toolUseId,
-                        toolName: contentItem.toolUse.name,
-                        result: { error: errorMessage },
-                    });
-                    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)`);
-            // Emit tool:end for each completed tool result so Pipeline B
-            // captures telemetry for Bedrock-driven tool calls (gap S2).
-            emitToolEndFromStepFinish(this.neurolink?.getEventEmitter(), toolResultsForStorage.map((tr) => {
-                const hasError = tr.result && typeof tr.result === "object" && "error" in tr.result;
-                return {
-                    toolName: tr.toolName,
-                    result: tr.result,
-                    error: hasError
-                        ? String(tr.result.error)
-                        : undefined,
-                };
-            }));
-            // Store tool execution for analytics and debugging (similar to Vertex onStepFinish)
-            this.handleToolExecutionStorage(toolCalls, toolResultsForStorage, options, new Date()).catch((error) => {
-                logger.warn("[AmazonBedrockProvider] Failed to store tool executions", {
-                    provider: this.providerName,
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            });
-        }
     }
     /**
      * Health check for Amazon Bedrock service