@llumiverse/drivers 1.3.0 → 1.4.0

package/lib/{esm/bedrock → bedrock}/index.js

@@ -1,15 +1,19 @@
-import { Bedrock, CreateModelCustomizationJobCommand, GetModelCustomizationJobCommand, ModelCustomizationJobStatus, ModelModality, StopModelCustomizationJobCommand } from "@aws-sdk/client-bedrock";
-import { BedrockRuntime } from "@aws-sdk/client-bedrock-runtime";
-import { S3Client } from "@aws-sdk/client-s3";
-import { AbstractDriver, deserializeBinaryFromStorage, getConversationMeta, getMaxTokensLimitBedrock, getModelCapabilities, incrementConversationTurn, isClaudeVersionGTE, LlumiverseError, modelModalitiesToArray, stripBinaryFromConversation, stripHeartbeatsFromConversation, TrainingJobStatus, truncateLargeTextInConversation } from "@llumiverse/core";
-import { transformAsyncIterator } from "@llumiverse/core/async";
-import { formatNovaPrompt } from "@llumiverse/core/formatters";
-import { LRUCache } from "mnemonist";
-import { resolveClaudeThinking } from "../shared/claude-thinking.js";
-import { converseConcatMessages, converseJSONprefill, converseSystemToMessages, formatConversePrompt } from "./converse.js";
-import { formatNovaImageGenerationPayload, NovaImageGenerationTaskType } from "./nova-image-payload.js";
-import { forceUploadFile } from "./s3.js";
-import { formatTwelvelabsPegasusPrompt } from "./twelvelabs.js";
+import { Bedrock, CreateModelCustomizationJobCommand, GetModelCustomizationJobCommand, ModelCustomizationJobStatus, ModelModality, StopModelCustomizationJobCommand, } from '@aws-sdk/client-bedrock';
+import { BedrockRuntime, } from '@aws-sdk/client-bedrock-runtime';
+import { S3Client } from '@aws-sdk/client-s3';
+import { deserializeBinaryFromStorage, getConversationMeta, getMaxTokensLimitBedrock, getModelCapabilities, incrementConversationTurn, isClaudeVersionGTE, LlumiverseError, modelModalitiesToArray, stripBinaryFromConversation, stripHeartbeatsFromConversation, TrainingJobStatus, truncateLargeTextInConversation, } from '@llumiverse/core';
+import { transformAsyncIterator } from '@llumiverse/core/async';
+import { AbstractDriver } from '@llumiverse/core/driver';
+import { formatNovaPrompt } from '@llumiverse/core/formatters';
+import { mergeDriverHttpTimeoutOptions, resolveDriverHttpTimeouts } from '@llumiverse/core/http-agent';
+import { LRUCache } from 'mnemonist';
+import { resolveClaudeThinking } from '../shared/claude-thinking.js';
+import { truncateBinaryForDebug, uint8ArrayToBase64ForDebug } from '../shared/debug-prompt.js';
+import { converseConcatMessages, converseJSONprefill, converseSystemToMessages, formatConversePrompt, } from './converse.js';
+import { generateBedrockEmbeddings } from './embeddings.js';
+import { formatNovaImageGenerationPayload, NovaImageGenerationTaskType } from './nova-image-payload.js';
+import { forceUploadFile } from './s3.js';
+import { formatTwelvelabsPegasusPrompt } from './twelvelabs.js';
 const supportStreamingCache = new LRUCache(4096);
 var BedrockModelType;
 (function (BedrockModelType) {
@@ -18,22 +22,36 @@ var BedrockModelType;
     BedrockModelType["CustomModel"] = "custom-model";
     BedrockModelType["Unknown"] = "unknown";
 })(BedrockModelType || (BedrockModelType = {}));
-;
 function converseFinishReason(reason) {
     //Possible values:
     //end_turn | tool_use | max_tokens | stop_sequence | guardrail_intervened | content_filtered
     if (!reason)
         return undefined;
     switch (reason) {
-        case 'end_turn': return "stop";
-        case 'max_tokens': return "length";
-        default: return reason;
+        case 'end_turn':
+            return 'stop';
+        case 'max_tokens':
+            return 'length';
+        default:
+            return reason;
     }
 }
+function withBedrockRuntimeScope(iterable, scope) {
+    return {
+        async *[Symbol.asyncIterator]() {
+            try {
+                yield* iterable;
+            }
+            finally {
+                scope.close();
+            }
+        },
+    };
+}
 //Used to get a max_token value when not specified in the model options. Claude requires it to be set.
 function maxTokenFallbackClaude(option) {
     const modelOptions = option.model_options;
-    if (modelOptions && typeof modelOptions.max_tokens === "number") {
+    if (modelOptions && typeof modelOptions.max_tokens === 'number') {
         return modelOptions.max_tokens;
     }
     else {
@@ -45,8 +63,166 @@ function maxTokenFallbackClaude(option) {
         return maxSupportedTokens;
     }
 }
+function formatBedrockBytes(bytes) {
+    if (bytes instanceof Uint8Array) {
+        return truncateBinaryForDebug(uint8ArrayToBase64ForDebug(bytes));
+    }
+    if (typeof bytes === 'string') {
+        return truncateBinaryForDebug(bytes);
+    }
+    return bytes;
+}
+function formatBedrockBytesForDebug(bytes) {
+    // AWS SDK prompt types require Uint8Array here, but the debug prompt returned to
+    // Studio must be JSON-safe. Keep the mismatch contained to this conversion.
+    return formatBedrockBytes(bytes);
+}
+function formatBedrockContentBlockForDebug(block) {
+    if (block.image?.source?.bytes) {
+        return {
+            ...block,
+            image: {
+                ...block.image,
+                source: {
+                    ...block.image.source,
+                    bytes: formatBedrockBytesForDebug(block.image.source.bytes),
+                },
+            },
+        };
+    }
+    if (block.document?.source?.bytes) {
+        return {
+            ...block,
+            document: {
+                ...block.document,
+                source: {
+                    ...block.document.source,
+                    bytes: formatBedrockBytesForDebug(block.document.source.bytes),
+                },
+            },
+        };
+    }
+    if (block.video?.source?.bytes) {
+        return {
+            ...block,
+            video: {
+                ...block.video,
+                source: {
+                    ...block.video.source,
+                    bytes: formatBedrockBytesForDebug(block.video.source.bytes),
+                },
+            },
+        };
+    }
+    if (block.toolResult?.content) {
+        return {
+            ...block,
+            toolResult: {
+                ...block.toolResult,
+                content: block.toolResult.content.map(formatBedrockToolResultContentBlockForDebug),
+            },
+        };
+    }
+    return block;
+}
+function formatBedrockToolResultContentBlockForDebug(block) {
+    if (block.image?.source?.bytes) {
+        return {
+            ...block,
+            image: {
+                ...block.image,
+                source: {
+                    ...block.image.source,
+                    bytes: formatBedrockBytesForDebug(block.image.source.bytes),
+                },
+            },
+        };
+    }
+    if (block.document?.source?.bytes) {
+        return {
+            ...block,
+            document: {
+                ...block.document,
+                source: {
+                    ...block.document.source,
+                    bytes: formatBedrockBytesForDebug(block.document.source.bytes),
+                },
+            },
+        };
+    }
+    if (block.video?.source?.bytes) {
+        return {
+            ...block,
+            video: {
+                ...block.video,
+                source: {
+                    ...block.video.source,
+                    bytes: formatBedrockBytesForDebug(block.video.source.bytes),
+                },
+            },
+        };
+    }
+    return block;
+}
+function formatConversePromptForDebug(prompt) {
+    return {
+        ...prompt,
+        messages: prompt.messages?.map((message) => ({
+            ...message,
+            content: message.content?.map(formatBedrockContentBlockForDebug),
+        })),
+    };
+}
+function formatNovaPromptForDebug(prompt) {
+    return {
+        ...prompt,
+        messages: prompt.messages.map((message) => ({
+            ...message,
+            content: message.content.map((part) => {
+                if (!part.image?.source.bytes && !part.video?.source.bytes) {
+                    return part;
+                }
+                return {
+                    ...part,
+                    image: part.image
+                        ? {
+                            ...part.image,
+                            source: {
+                                ...part.image.source,
+                                bytes: truncateBinaryForDebug(part.image.source.bytes),
+                            },
+                        }
+                        : undefined,
+                    video: part.video
+                        ? {
+                            ...part.video,
+                            source: {
+                                ...part.video.source,
+                                bytes: part.video.source.bytes
+                                    ? truncateBinaryForDebug(part.video.source.bytes)
+                                    : undefined,
+                            },
+                        }
+                        : undefined,
+                };
+            }),
+        })),
+    };
+}
+function formatTwelvelabsPromptForDebug(prompt) {
+    if (!prompt.mediaSource.base64String) {
+        return prompt;
+    }
+    return {
+        ...prompt,
+        mediaSource: {
+            ...prompt.mediaSource,
+            base64String: truncateBinaryForDebug(prompt.mediaSource.base64String),
+        },
+    };
+}
 export class BedrockDriver extends AbstractDriver {
-    static PROVIDER = "bedrock";
+    static PROVIDER = 'bedrock';
     provider = BedrockDriver.PROVIDER;
     _executor;
     _service;
@@ -57,34 +233,79 @@ export class BedrockDriver extends AbstractDriver {
             throw new Error("No region found. Set the region in the environment's endpoint URL.");
         }
     }
-    getExecutor() {
+    /**
+     * Build a Smithy `requestHandler` config from the driver's
+     * `httpTimeout` so AWS SDK calls fail fast on hung upstream Bedrock
+     * endpoints instead of using the AWS default (no request timeout).
+     * Returns a partial config the SDK merges into its default handler.
+     */
+    getBedrockRequestHandlerConfig(httpTimeout) {
+        const timeouts = resolveDriverHttpTimeouts(mergeDriverHttpTimeoutOptions(this.options.httpTimeout, httpTimeout));
+        return {
+            requestTimeout: timeouts.headersTimeout,
+            throwOnRequestTimeout: true,
+            connectionTimeout: timeouts.connectTimeout,
+            socketTimeout: timeouts.bodyTimeout,
+        };
+    }
+    createExecutor(httpTimeout) {
+        return new BedrockRuntime({
+            region: this.options.region,
+            credentials: this.options.credentials,
+            requestHandler: this.getBedrockRequestHandlerConfig(httpTimeout),
+        });
+    }
+    getExecutor(httpTimeout) {
+        if (httpTimeout) {
+            return this.createExecutor(httpTimeout);
+        }
         if (!this._executor) {
-            this._executor = new BedrockRuntime({
-                region: this.options.region,
-                credentials: this.options.credentials,
-            });
+            this._executor = this.createExecutor();
         }
         return this._executor;
     }
+    getScopedExecutor(options) {
+        if (!options.httpTimeout) {
+            return {
+                executor: this.getExecutor(),
+                close: () => undefined,
+            };
+        }
+        const executor = this.getExecutor(options.httpTimeout);
+        return {
+            executor,
+            close: () => executor.destroy(),
+        };
+    }
     getService(region = this.options.region) {
         if (!this._service || this._service_region !== region) {
             this._service = new Bedrock({
                 region: region,
                 credentials: this.options.credentials,
+                requestHandler: this.getBedrockRequestHandlerConfig(),
             });
             this._service_region = region;
         }
         return this._service;
     }
     async formatPrompt(segments, opts) {
-        if (opts.model.includes("canvas")) {
+        if (opts.model.includes('canvas')) {
             return await formatNovaPrompt(segments, opts.result_schema);
         }
-        if (opts.model.includes("twelvelabs.pegasus")) {
+        if (opts.model.includes('twelvelabs.pegasus')) {
             return await formatTwelvelabsPegasusPrompt(segments, opts);
         }
         return await formatConversePrompt(segments, opts);
     }
+    formatDebugPrompt(prompt) {
+        if ('mediaSource' in prompt) {
+            return formatTwelvelabsPromptForDebug(prompt);
+        }
+        if ('modelId' in prompt) {
+            return formatConversePromptForDebug(prompt);
+        }
+        return formatNovaPromptForDebug(prompt);
+    }
     /**
      * Format AWS Bedrock errors into LlumiverseError with proper status codes and retryability.
      *
@@ -139,8 +360,7 @@ export class BedrockDriver extends AbstractDriver {
         // Determine retryability based on AWS error types
         const retryable = this.isBedrockErrorRetryable(errorName, httpStatusCode, fault);
         return new LlumiverseError(`[${this.provider}] ${userMessage}`, retryable, context, error, httpStatusCode, // Only set code if we have numeric status code
-        errorName // Preserve AWS error name
-        );
+        errorName);
     }
     /**
      * Determine if a Bedrock error is retryable based on error type and status.
@@ -204,8 +424,8 @@ export class BedrockDriver extends AbstractDriver {
         return undefined;
     }
     getExtractedExecution(result, _prompt, options) {
-        let resultText = "";
-        let reasoning = "";
+        let resultText = '';
+        let reasoning = '';
         if (result.output?.message?.content) {
             for (const content of result.output.message.content) {
                 // Get text output
@@ -228,13 +448,13 @@ export class BedrockDriver extends AbstractDriver {
                         }
                     }
                     else {
-                        this.logger.info("[Bedrock] Not outputting reasoning content as include_thoughts is false");
+                        this.logger.info('[Bedrock] Not outputting reasoning content as include_thoughts is false');
                     }
                 }
                 else {
                     // Get content block type
-                    const type = Object.keys(content).find(key => key !== '$unknown' && content[key] !== undefined);
-                    this.logger.info({ type }, "[Bedrock] Unsupported content response type:");
+                    const type = Object.keys(content).find((key) => key !== '$unknown' && content[key] !== undefined);
+                    this.logger.info({ type }, '[Bedrock] Unsupported content response type:');
                 }
             }
             // Add spacing if we have reasoning content
@@ -243,14 +463,18 @@ export class BedrockDriver extends AbstractDriver {
             }
         }
         const completionResult = {
-            result: reasoning + resultText ? [{ type: "text", value: reasoning + resultText }] : [],
+            result: reasoning + resultText ? [{ type: 'text', value: reasoning + resultText }] : [],
             token_usage: {
                 // Bedrock's inputTokens already excludes cache-read tokens,
                 // so prompt_new is inputTokens directly (no subtraction needed).
                 // prompt is the total including cached + cache_write for consistency
                 // with the Vertex Claude driver.
                 prompt_new: result.usage?.inputTokens,
-                prompt: result.usage ? (result.usage.inputTokens ?? 0) + (result.usage.cacheReadInputTokens ?? 0) + (result.usage.cacheWriteInputTokens ?? 0) : undefined,
+                prompt: result.usage
+                    ? (result.usage.inputTokens ?? 0) +
+                        (result.usage.cacheReadInputTokens ?? 0) +
+                        (result.usage.cacheWriteInputTokens ?? 0)
+                    : undefined,
                 result: result.usage?.outputTokens,
                 total: result.usage?.totalTokens,
                 prompt_cached: result.usage?.cacheReadInputTokens ?? undefined,
@@ -260,11 +484,10 @@ export class BedrockDriver extends AbstractDriver {
         };
         return completionResult;
     }
-    ;
     getExtractedStream(result, _prompt, options, streamingToolBlocks) {
-        let output = "";
-        let reasoning = "";
-        let stop_reason = "";
+        let output = '';
+        let reasoning = '';
+        let stop_reason = '';
         let token_usage;
         let tool_use;
         // Check if we should include thoughts (always true for reasoning-only models like DeepSeek R1)
@@ -272,7 +495,9 @@ export class BedrockDriver extends AbstractDriver {
         const shouldIncludeThoughts = isReasoningModel || (options && options.model_options?.include_thoughts);
         // Handle content block start events (for reasoning blocks and tool use)
         if (result.contentBlockStart) {
-            if (result.contentBlockStart.start && 'toolUse' in result.contentBlockStart.start && result.contentBlockStart.start.toolUse) {
+            if (result.contentBlockStart.start &&
+                'toolUse' in result.contentBlockStart.start &&
+                result.contentBlockStart.start.toolUse) {
                 // Register new tool call block and emit an initial chunk so the accumulator can track it by id
                 const toolUseStart = result.contentBlockStart.start.toolUse;
                 const blockIndex = result.contentBlockStart.contentBlockIndex ?? -1;
@@ -281,7 +506,9 @@ export class BedrockDriver extends AbstractDriver {
                 streamingToolBlocks?.set(blockIndex, { id, name });
                 tool_use = [{ id, tool_name: name, tool_input: '' }];
             }
-            else if (result.contentBlockStart.start && 'reasoningContent' in result.contentBlockStart.start && shouldIncludeThoughts) {
+            else if (result.contentBlockStart.start &&
+                'reasoningContent' in result.contentBlockStart.start &&
+                shouldIncludeThoughts) {
                 // Handle redacted content at block start
                 const reasoningStart = result.contentBlockStart.start;
                 if (reasoningStart.reasoningContent?.redactedContent) {
@@ -314,15 +541,15 @@ export class BedrockDriver extends AbstractDriver {
                 }
                 else if (delta.reasoningContent.signature) {
                     // Handle signature updates for reasoning content - end of thinking
-                    reasoning = "\n\n";
+                    reasoning = '\n\n';
                     // Putting logging here so it only triggers once.
-                    this.logger.info("[Bedrock] Not outputting reasoning content as include_thoughts is false");
+                    this.logger.info('[Bedrock] Not outputting reasoning content as include_thoughts is false');
                 }
             }
             else if (delta) {
                 // Get content block type
-                const type = Object.keys(delta).find(key => key !== '$unknown' && delta[key] !== undefined);
-                this.logger.info({ type }, "[Bedrock] Unsupported content response type:");
+                const type = Object.keys(delta).find((key) => key !== '$unknown' && delta[key] !== undefined);
+                this.logger.info({ type }, '[Bedrock] Unsupported content response type:');
             }
         }
         // Handle content block stop events
@@ -336,12 +563,16 @@ export class BedrockDriver extends AbstractDriver {
             }
         }
         if (result.messageStop) {
-            stop_reason = result.messageStop.stopReason ?? "";
+            stop_reason = result.messageStop.stopReason ?? '';
         }
         if (result.metadata) {
             token_usage = {
                 prompt_new: result.metadata.usage?.inputTokens,
-                prompt: result.metadata.usage ? (result.metadata.usage.inputTokens ?? 0) + (result.metadata.usage.cacheReadInputTokens ?? 0) + (result.metadata.usage.cacheWriteInputTokens ?? 0) : undefined,
+                prompt: result.metadata.usage
+                    ? (result.metadata.usage.inputTokens ?? 0) +
+                        (result.metadata.usage.cacheReadInputTokens ?? 0) +
+                        (result.metadata.usage.cacheWriteInputTokens ?? 0)
+                    : undefined,
                 result: result.metadata.usage?.outputTokens,
                 total: result.metadata.usage?.totalTokens,
                 prompt_cached: result.metadata.usage?.cacheReadInputTokens ?? undefined,
@@ -349,14 +580,13 @@ export class BedrockDriver extends AbstractDriver {
             };
         }
         const completionResult = {
-            result: reasoning + output ? [{ type: "text", value: reasoning + output }] : [],
+            result: reasoning + output ? [{ type: 'text', value: reasoning + output }] : [],
             token_usage: token_usage,
             finish_reason: converseFinishReason(stop_reason),
             tool_use,
         };
         return completionResult;
     }
-    ;
     extractRegion(modelString, defaultRegion) {
         // Match region in full ARN pattern
         const arnMatch = modelString.match(/arn:aws[^:]*:bedrock:([^:]+):/);
@@ -377,7 +607,7 @@ export class BedrockDriver extends AbstractDriver {
         if (type === BedrockModelType.FoundationModel || type === BedrockModelType.Unknown) {
             try {
                 const response = await this.getService(region).getFoundationModel({
-                    modelIdentifier: model
+                    modelIdentifier: model,
                 });
                 canStream = response.modelDetails?.responseStreamingSupported ?? false;
                 return canStream;
@@ -389,9 +619,9 @@ export class BedrockDriver extends AbstractDriver {
         if (type === BedrockModelType.InferenceProfile || type === BedrockModelType.Unknown) {
             try {
                 const response = await this.getService(region).getInferenceProfile({
-                    inferenceProfileIdentifier: model
+                    inferenceProfileIdentifier: model,
                 });
-                canStream = await this.getCanStream(response.models?.[0].modelArn ?? "", BedrockModelType.FoundationModel);
+                canStream = await this.getCanStream(response.models?.[0].modelArn ?? '', BedrockModelType.FoundationModel);
                 return canStream;
             }
             catch (e) {
@@ -401,9 +631,9 @@ export class BedrockDriver extends AbstractDriver {
         if (type === BedrockModelType.CustomModel || type === BedrockModelType.Unknown) {
             try {
                 const response = await this.getService(region).getCustomModel({
-                    modelIdentifier: model
+                    modelIdentifier: model,
                 });
-                canStream = await this.getCanStream(response.baseModelArn ?? "", BedrockModelType.FoundationModel);
+                canStream = await this.getCanStream(response.baseModelArn ?? '', BedrockModelType.FoundationModel);
                 return canStream;
             }
             catch (e) {
@@ -411,7 +641,7 @@ export class BedrockDriver extends AbstractDriver {
             }
         }
         if (error) {
-            console.warn("Error on canStream check for model: " + model + " region detected: " + region, error);
+            console.warn(`Error on canStream check for model: ${model} region detected: ${region}`, error);
         }
         return canStream;
     }
@@ -423,13 +653,13 @@ export class BedrockDriver extends AbstractDriver {
         let canStream = supportStreamingCache.get(options.model);
         if (canStream == null) {
             let type = BedrockModelType.Unknown;
-            if (options.model.includes("foundation-model")) {
+            if (options.model.includes('foundation-model')) {
                 type = BedrockModelType.FoundationModel;
             }
-            else if (options.model.includes("inference-profile")) {
+            else if (options.model.includes('inference-profile')) {
                 type = BedrockModelType.InferenceProfile;
             }
-            else if (options.model.includes("custom-model")) {
+            else if (options.model.includes('custom-model')) {
                 type = BedrockModelType.CustomModel;
             }
             canStream = await this.getCanStream(options.model, type);
@@ -443,14 +673,14 @@ export class BedrockDriver extends AbstractDriver {
      */
     buildStreamingConversation(prompt, result, toolUse, options) {
         // Only handle ConverseRequest prompts (not NovaMessagesPrompt or TwelvelabsPegasusRequest)
-        if (options.model.includes("canvas") || options.model.includes("twelvelabs.pegasus")) {
+        if (options.model.includes('canvas') || options.model.includes('twelvelabs.pegasus')) {
             return undefined;
         }
         const conversePrompt = prompt;
         const completionResults = result;
         // Convert accumulated results to text content for assistant message
         const textContent = completionResults
-            .map(r => {
+            .map((r) => {
             switch (r.type) {
                 case 'text':
                     return r.value;
@@ -459,8 +689,10 @@ export class BedrockDriver extends AbstractDriver {
                 case 'image':
                     // Skip images in conversation - they're in the result
                     return '';
-                default:
-                    return String(r.value || '');
+                default: {
+                    const _exhaustive = r;
+                    return String(_exhaustive);
+                }
             }
         })
             .join('');
@@ -481,16 +713,18 @@ export class BedrockDriver extends AbstractDriver {
                         toolUseId: tool.id,
                         name: tool.tool_name,
                         input: tool.tool_input,
-                    }
+                    },
                 });
             }
         }
         // Add assistant message
         const assistantMessage = {
-            messages: [{
+            messages: [
+                {
                     content: messageContent.length > 0 ? messageContent : [{ text: '' }],
-                    role: "assistant"
-                }],
+                    role: 'assistant',
+                },
+            ],
             modelId: conversePrompt.modelId,
         };
         conversation = updateConversation(conversation, assistantMessage);
@@ -501,7 +735,7 @@ export class BedrockDriver extends AbstractDriver {
         const stripOptions = {
             keepForTurns: options.stripImagesAfterTurns ?? Infinity,
             currentTurn,
-            textMaxTokens: options.stripTextMaxTokens
+            textMaxTokens: options.stripTextMaxTokens,
         };
         let processedConversation = stripBinaryFromConversation(conversation, stripOptions);
         processedConversation = truncateLargeTextInConversation(processedConversation, stripOptions);
@@ -513,7 +747,7 @@ export class BedrockDriver extends AbstractDriver {
     }
     async requestTextCompletion(prompt, options) {
         // Handle Twelvelabs Pegasus models
-        if (options.model.includes("twelvelabs.pegasus")) {
+        if (options.model.includes('twelvelabs.pegasus')) {
             return this.requestTwelvelabsPegasusCompletion(prompt, options);
         }
         // Handle other Bedrock models that use Converse API
@@ -522,15 +756,21 @@ export class BedrockDriver extends AbstractDriver {
         const incomingConversation = deserializeBinaryFromStorage(options.conversation);
         let conversation = updateConversation(incomingConversation, conversePrompt);
         const payload = this.preparePayload(conversation, options);
-        const executor = this.getExecutor();
-        const res = await executor.converse({
-            ...payload,
-        });
+        const executorScope = this.getScopedExecutor(options);
+        let res;
+        try {
+            res = await executorScope.executor.converse({
+                ...payload,
+            });
+        }
+        finally {
+            executorScope.close();
+        }
         // Strip reasoningContent from assistant messages before storing in conversation
         // (DeepSeek R1 returns reasoning blocks but rejects them in subsequent user turns)
-        const assistantMsg = res.output?.message ?? { content: [{ text: "" }], role: "assistant" };
+        const assistantMsg = res.output?.message ?? { content: [{ text: '' }], role: 'assistant' };
         if (assistantMsg.content) {
-            assistantMsg.content = assistantMsg.content.filter((c) => !c.reasoningContent);
+            assistantMsg.content = assistantMsg.content.filter((c) => !('reasoningContent' in c));
         }
         conversation = updateConversation(conversation, {
             messages: [assistantMsg],
@@ -538,14 +778,14 @@ export class BedrockDriver extends AbstractDriver {
         });
         // Increment turn counter for deferred stripping
         conversation = incrementConversationTurn(conversation);
-        let tool_use = undefined;
+        let tool_use;
         //Get tool requests, we check tool use regardless of finish reason, as you can hit length and still get a valid response.
         tool_use = res.output?.message?.content?.reduce((tools, c) => {
             if (c.toolUse) {
                 tools.push({
-                    tool_name: c.toolUse.name ?? "",
+                    tool_name: c.toolUse.name ?? '',
                     tool_input: c.toolUse.input,
-                    id: c.toolUse.toolUseId ?? "",
+                    id: c.toolUse.toolUseId ?? '',
                 });
             }
             return tools;
@@ -559,7 +799,7 @@ export class BedrockDriver extends AbstractDriver {
         const stripOptions = {
             keepForTurns: options.stripImagesAfterTurns ?? Infinity,
             currentTurn,
-            textMaxTokens: options.stripTextMaxTokens
+            textMaxTokens: options.stripTextMaxTokens,
         };
         let processedConversation = stripBinaryFromConversation(conversation, stripOptions);
         // Truncate large text content if configured
@@ -578,85 +818,100 @@ export class BedrockDriver extends AbstractDriver {
         return completion;
     }
     async requestTwelvelabsPegasusCompletion(prompt, options) {
-        const executor = this.getExecutor();
-        const res = await executor.invokeModel({
-            modelId: options.model,
-            contentType: "application/json",
-            accept: "application/json",
-            body: JSON.stringify(prompt),
-        });
+        const executorScope = this.getScopedExecutor(options);
+        let res;
+        try {
+            res = await executorScope.executor.invokeModel({
+                modelId: options.model,
+                contentType: 'application/json',
+                accept: 'application/json',
+                body: JSON.stringify(prompt),
+            });
+        }
+        finally {
+            executorScope.close();
+        }
         const decoder = new TextDecoder();
         const body = decoder.decode(res.body);
         const result = JSON.parse(body);
         // Extract the response according to TwelveLabs Pegasus format
         let finishReason;
         switch (result.finishReason) {
-            case "stop":
-                finishReason = "stop";
+            case 'stop':
+                finishReason = 'stop';
                 break;
-            case "length":
-                finishReason = "length";
+            case 'length':
+                finishReason = 'length';
                 break;
             default:
                 finishReason = result.finishReason;
         }
         return {
-            result: result.message ? [{ type: "text", value: result.message }] : [],
+            result: result.message ? [{ type: 'text', value: result.message }] : [],
             finish_reason: finishReason,
             original_response: options.include_original_response ? result : undefined,
         };
     }
     async requestTwelvelabsPegasusCompletionStream(prompt, options) {
-        const executor = this.getExecutor();
-        const res = await executor.invokeModelWithResponseStream({
-            modelId: options.model,
-            contentType: "application/json",
-            accept: "application/json",
-            body: JSON.stringify(prompt),
-        });
-        if (!res.body) {
-            throw new Error("[Bedrock] Stream not found in response");
-        }
-        return transformAsyncIterator(res.body, (chunk) => {
-            if (chunk.chunk?.bytes) {
-                const decoder = new TextDecoder();
-                const body = decoder.decode(chunk.chunk.bytes);
-                try {
-                    const result = JSON.parse(body);
-                    // Extract streaming response according to TwelveLabs Pegasus format
-                    let finishReason;
-                    if (result.finishReason) {
-                        switch (result.finishReason) {
-                            case "stop":
-                                finishReason = "stop";
-                                break;
-                            case "length":
-                                finishReason = "length";
-                                break;
-                            default:
-                                finishReason = result.finishReason;
+        const executorScope = this.getScopedExecutor(options);
+        try {
+            const res = await executorScope.executor.invokeModelWithResponseStream({
+                modelId: options.model,
+                contentType: 'application/json',
+                accept: 'application/json',
+                body: JSON.stringify(prompt),
+            });
+            if (!res.body) {
+                throw new Error('[Bedrock] Stream not found in response');
+            }
+            const stream = transformAsyncIterator(res.body, (chunk) => {
+                if (chunk.chunk?.bytes) {
+                    const decoder = new TextDecoder();
+                    const body = decoder.decode(chunk.chunk.bytes);
+                    try {
+                        const result = JSON.parse(body);
+                        // Extract streaming response according to TwelveLabs Pegasus format
+                        let finishReason;
+                        if (result.finishReason) {
+                            switch (result.finishReason) {
+                                case 'stop':
+                                    finishReason = 'stop';
+                                    break;
+                                case 'length':
+                                    finishReason = 'length';
+                                    break;
+                                default:
+                                    finishReason = result.finishReason;
+                            }
                         }
+                        return {
+                            result: result.delta || result.message
+                                ? [{ type: 'text', value: result.delta || result.message || '' }]
+                                : [],
+                            finish_reason: finishReason,
+                        };
+                    }
+                    catch {
+                        // If JSON parsing fails, return empty chunk
+                        return {
+                            result: [],
+                        };
                     }
-                    return {
-                        result: result.delta || result.message ? [{ type: "text", value: result.delta || result.message || "" }] : [],
-                        finish_reason: finishReason,
-                    };
-                }
-                catch (error) {
-                    // If JSON parsing fails, return empty chunk
-                    return {
-                        result: [],
-                    };
                 }
-            }
-            return {
-                result: [],
-            };
-        });
+                return {
+                    result: [],
+                };
+            });
+            return withBedrockRuntimeScope(stream, executorScope);
+        }
+        catch (err) {
+            executorScope.close();
+            throw err;
+        }
     }
     async requestTextCompletionStream(prompt, options) {
         // Handle Twelvelabs Pegasus models
-        if (options.model.includes("twelvelabs.pegasus")) {
+        if (options.model.includes('twelvelabs.pegasus')) {
             return this.requestTwelvelabsPegasusCompletionStream(prompt, options);
         }
         // Handle other Bedrock models that use Converse API
@@ -666,42 +921,49 @@ export class BedrockDriver extends AbstractDriver {
         const incomingConversation = deserializeBinaryFromStorage(options.conversation);
         const conversation = updateConversation(incomingConversation, conversePrompt);
         const payload = this.preparePayload(conversation, options);
-        const executor = this.getExecutor();
-        return executor.converseStream({
+        const executorScope = this.getScopedExecutor(options);
+        return executorScope.executor
+            .converseStream({
             ...payload,
-        }).then((res) => {
+        })
+            .then((res) => {
             const stream = res.stream;
             if (!stream) {
-                throw new Error("[Bedrock] Stream not found in response");
+                throw new Error('[Bedrock] Stream not found in response');
             }
             const streamingToolBlocks = new Map();
-            return transformAsyncIterator(stream, (streamSegment) => {
+            const transformedStream = transformAsyncIterator(stream, (streamSegment) => {
                 return this.getExtractedStream(streamSegment, conversePrompt, options, streamingToolBlocks);
             });
-        }).catch((err) => {
-            this.logger.error({ error: err }, "[Bedrock] Failed to stream");
+            return withBedrockRuntimeScope(transformedStream, executorScope);
+        })
+            .catch((err) => {
+            executorScope.close();
+            this.logger.error({ error: err }, '[Bedrock] Failed to stream');
             throw err;
         });
     }
     preparePayload(prompt, options) {
-        const model_options = options.model_options ?? { _option_id: "text-fallback" };
+        const model_options = options.model_options ?? {
+            _option_id: 'text-fallback',
+        };
         let additionalField = {};
         let supportsJSONPrefill = false;
         // Resolve thinking, effort, and sampling restrictions using shared Claude helper
         const claudeThinking = resolveClaudeThinking(options.model, options.model_options);
         const hasSamplingRestriction = claudeThinking.hasSamplingRestriction;
-        if (options.model.includes("amazon")) {
+        if (options.model.includes('amazon')) {
             supportsJSONPrefill = true;
             //Titan models also exists but does not support any additional options
-            if (options.model.includes("nova")) {
+            if (options.model.includes('nova')) {
                 additionalField = { inferenceConfig: { topK: model_options.top_k } };
             }
         }
-        else if (options.model.includes("claude")) {
+        else if (options.model.includes('claude')) {
             const claude_options = model_options;
             // Thinking is active when extended (budget set) or adaptive (effort set) thinking is enabled.
             // JSON prefill is incompatible with active thinking.
-            const thinkingActive = claudeThinking.thinking != null && claudeThinking.thinking.type !== "disabled";
+            const thinkingActive = claudeThinking.thinking != null && claudeThinking.thinking.type !== 'disabled';
             supportsJSONPrefill = !thinkingActive;
             // Claude 3.7+ supports thinking — use shared helper for reasoning_config
             if (claudeThinking.supportsThinking) {
@@ -712,12 +974,12 @@ export class BedrockDriver extends AbstractDriver {
                     };
                 }
                 // For Claude 3.7 with extended thinking + high output, add beta header
-                if (claudeThinking.thinking?.type === "enabled" &&
-                    options.model.includes("claude-3-7-sonnet") &&
+                if (claudeThinking.thinking?.type === 'enabled' &&
+                    options.model.includes('claude-3-7-sonnet') &&
                     ((claude_options.max_tokens ?? 0) > 64000 || (claude_options.thinking_budget_tokens ?? 0) > 64000)) {
                     additionalField = {
                         ...additionalField,
-                        anthropic_beta: ["output-128k-2025-02-19"]
+                        anthropic_beta: ['output-128k-2025-02-19'],
                     };
                 }
             }
@@ -725,7 +987,7 @@ export class BedrockDriver extends AbstractDriver {
             if (claudeThinking.outputConfig) {
                 additionalField = {
                     ...additionalField,
-                    output_config: claudeThinking.outputConfig
+                    output_config: claudeThinking.outputConfig,
                 };
             }
             // Claude 4.6 and later versions don't support JSON prefill
@@ -741,12 +1003,12 @@ export class BedrockDriver extends AbstractDriver {
                 additionalField = { ...additionalField, top_k: model_options.top_k };
             }
         }
-        else if (options.model.includes("meta")) {
+        else if (options.model.includes('meta')) {
             //LLaMA models support no additional options
         }
-        else if (options.model.includes("mistral")) {
+        else if (options.model.includes('mistral')) {
             //7B instruct and 8x7B instruct
-            if (options.model.includes("7b")) {
+            if (options.model.includes('7b')) {
                 additionalField = { top_k: model_options.top_k };
                 //Does not support system messages
                 if (prompt.system && prompt.system?.length !== 0) {
@@ -760,10 +1022,10 @@ export class BedrockDriver extends AbstractDriver {
                 //Support no additional fields.
             }
         }
-        else if (options.model.includes("ai21")) {
+        else if (options.model.includes('ai21')) {
             //Jamba models support no additional options
             //Jurassic 2 models do.
-            if (options.model.includes("j2")) {
+            if (options.model.includes('j2')) {
                 additionalField = {
                     presencePenalty: { scale: model_options.presence_penalty },
                     frequencyPenalty: { scale: model_options.frequency_penalty },
@@ -776,10 +1038,10 @@ export class BedrockDriver extends AbstractDriver {
                 }
             }
         }
-        else if (options.model.includes("cohere.command")) {
+        else if (options.model.includes('cohere.command')) {
             // If last message is "```json", remove it.
             //Command R and R plus
-            if (options.model.includes("cohere.command-r")) {
+            if (options.model.includes('cohere.command-r')) {
                 additionalField = {
                     k: model_options.top_k,
                     frequency_penalty: model_options.frequency_penalty,
@@ -797,7 +1059,7 @@ export class BedrockDriver extends AbstractDriver {
                 }
             }
         }
-        else if (options.model.includes("palmyra")) {
+        else if (options.model.includes('palmyra')) {
             const palmyraOptions = model_options;
             additionalField = {
                 seed: palmyraOptions?.seed,
@@ -806,12 +1068,12 @@ export class BedrockDriver extends AbstractDriver {
                 min_tokens: palmyraOptions?.min_tokens,
             };
         }
-        else if (options.model.includes("deepseek")) {
+        else if (options.model.includes('deepseek')) {
             // DeepSeek models: no additional options, no stopSequences, only one of temperature/top_p
             model_options.stop_sequence = undefined;
             model_options.top_p = undefined;
         }
-        else if (options.model.includes("gpt-oss")) {
+        else if (options.model.includes('gpt-oss')) {
             const gptOssOptions = model_options;
             additionalField = {
                 reasoning_effort: gptOssOptions?.reasoning_effort,
@@ -819,13 +1081,13 @@ export class BedrockDriver extends AbstractDriver {
         }
         //If last message is "```json", add corresponding ``` as a stop sequence.
         if (prompt.messages && prompt.messages.length > 0) {
-            if (prompt.messages[prompt.messages.length - 1].content?.[0].text === "```json") {
+            if (prompt.messages[prompt.messages.length - 1].content?.[0].text === '```json') {
                 const stopSeq = model_options.stop_sequence;
                 if (!stopSeq) {
-                    model_options.stop_sequence = ["```"];
+                    model_options.stop_sequence = ['```'];
                 }
-                else if (!stopSeq.includes("```")) {
-                    stopSeq.push("```");
+                else if (!stopSeq.includes('```')) {
+                    stopSeq.push('```');
                     model_options.stop_sequence = stopSeq;
                 }
             }
@@ -841,10 +1103,12 @@ export class BedrockDriver extends AbstractDriver {
         // Models with sampling parameter restrictions don't support temperature/top_p - exclude them from inference config
         const cleanedModelOptions = removeUndefinedValues({
             maxTokens: model_options.max_tokens,
-            ...(hasSamplingRestriction ? {} : {
-                temperature: model_options.temperature,
-                topP: model_options.temperature != null ? undefined : model_options.top_p,
-            }),
+            ...(hasSamplingRestriction
+                ? {}
+                : {
+                    temperature: model_options.temperature,
+                    topP: model_options.temperature != null ? undefined : model_options.top_p,
+                }),
             stopSequences: model_options.stop_sequence,
         });
         //Construct the final request payload
@@ -862,7 +1126,8 @@ export class BedrockDriver extends AbstractDriver {
             request.inferenceConfig = cleanedModelOptions;
         }
         if (Object.keys(cleanedAdditionalFields).length > 0) {
-            request.additionalModelRequestFields = cleanedAdditionalFields;
+            request.additionalModelRequestFields =
+                cleanedAdditionalFields;
         }
         if (tool_defs?.length) {
             request.toolConfig = {
@@ -915,37 +1180,47 @@ export class BedrockDriver extends AbstractDriver {
         return request;
     }
     isImageModel(model) {
-        return model.includes("titan-image") || model.includes("stable-diffusion") || model.includes("nova-canvas");
+        return model.includes('titan-image') || model.includes('stable-diffusion') || model.includes('nova-canvas');
     }
     async requestImageGeneration(prompt, options) {
-        if (options.model_options?._option_id !== undefined && options.model_options?._option_id !== "bedrock-nova-canvas") {
-            this.logger.debug({ options: options.model_options }, "Unexpected option id");
+        if (options.model_options?._option_id !== undefined &&
+            options.model_options?._option_id !== 'bedrock-nova-canvas') {
+            this.logger.debug({ options: options.model_options }, 'Unexpected option id');
         }
         const model_options = options.model_options;
-        const executor = this.getExecutor();
         const taskType = model_options.taskType ?? NovaImageGenerationTaskType.TEXT_IMAGE;
-        this.logger.info("Task type: " + taskType);
-        if (typeof prompt === "string") {
-            throw new Error("Bad prompt format");
+        this.logger.info(`Task type: ${taskType}`);
+        if (typeof prompt === 'string') {
+            throw new Error('Bad prompt format');
         }
         const payload = await formatNovaImageGenerationPayload(taskType, prompt, options);
-        const res = await executor.invokeModel({
-            modelId: options.model,
-            contentType: "application/json",
-            accept: "application/json",
-            body: JSON.stringify(payload),
-        }, {
-            requestTimeout: 60000 * 5
-        });
+        const executorScope = this.getScopedExecutor(options);
+        let res;
+        try {
+            const requestTimeout = options.httpTimeout
+                ? resolveDriverHttpTimeouts(mergeDriverHttpTimeoutOptions(this.options.httpTimeout, options.httpTimeout)).headersTimeout
+                : (this.options.httpTimeout?.headersTimeout ?? 60_000 * 5);
+            res = await executorScope.executor.invokeModel({
+                modelId: options.model,
+                contentType: 'application/json',
+                accept: 'application/json',
+                body: JSON.stringify(payload),
+            }, {
+                requestTimeout,
+            });
+        }
+        finally {
+            executorScope.close();
+        }
         const decoder = new TextDecoder();
         const body = decoder.decode(res.body);
         const bedrockResult = JSON.parse(body);
         return {
             error: bedrockResult.error,
             result: bedrockResult.images.map((image) => ({
-                type: "image",
-                value: image
-            }))
+                type: 'image',
+                value: image,
+            })),
         };
     }
     async startTraining(dataset, options) {
@@ -962,11 +1237,11 @@ export class BedrockDriver extends AbstractDriver {
         const upload = await forceUploadFile(s3, stream, this.options.training_bucket, dataset.name);
         const service = this.getService();
         const response = await service.send(new CreateModelCustomizationJobCommand({
-            jobName: options.name + "-job",
+            jobName: `${options.name}-job`,
             customModelName: options.name,
             roleArn: this.options.training_role_arn || undefined,
             baseModelIdentifier: options.model,
-            clientRequestToken: "llumiverse-" + Date.now(),
+            clientRequestToken: `llumiverse-${Date.now()}`,
             trainingDataConfig: {
                 s3Uri: `s3://${upload.Bucket}/${upload.Key}`,
             },
@@ -976,43 +1251,44 @@ export class BedrockDriver extends AbstractDriver {
             //customizationType: "FINE_TUNING",
         }));
         const job = await service.send(new GetModelCustomizationJobCommand({
-            jobIdentifier: response.jobArn
+            jobIdentifier: response.jobArn,
         }));
+        // biome-ignore lint/style/noNonNullAssertion: intentional non-null assertion; TS can't prove narrowing here
         return jobInfo(job, response.jobArn);
     }
     async cancelTraining(jobId) {
         const service = this.getService();
         await service.send(new StopModelCustomizationJobCommand({
-            jobIdentifier: jobId
+            jobIdentifier: jobId,
         }));
         const job = await service.send(new GetModelCustomizationJobCommand({
-            jobIdentifier: jobId
+            jobIdentifier: jobId,
         }));
         return jobInfo(job, jobId);
     }
     async getTrainingJob(jobId) {
         const service = this.getService();
         const job = await service.send(new GetModelCustomizationJobCommand({
-            jobIdentifier: jobId
+            jobIdentifier: jobId,
         }));
         return jobInfo(job, jobId);
     }
     // ===================== management API ==================
     async validateConnection() {
         const service = this.getService();
-        this.logger.debug("[Bedrock] validating connection", service.config.credentials.name);
+        this.logger.debug('[Bedrock] validating connection', service.config.credentials.name);
         //return true as if the client has been initialized, it means the connection is valid
         return true;
     }
     async listTrainableModels() {
-        this.logger.debug("[Bedrock] listing trainable models");
-        return this._listModels(m => m.customizationsSupported ? m.customizationsSupported.includes("FINE_TUNING") : false);
+        this.logger.debug('[Bedrock] listing trainable models');
+        return this._listModels((m) => m.customizationsSupported ? m.customizationsSupported.includes('FINE_TUNING') : false);
     }
     async listModels() {
-        this.logger.debug("[Bedrock] listing models");
+        this.logger.debug('[Bedrock] listing models');
         // exclude trainable models since they are not executable
         // exclude embedding models, not to be used for typical completions.
-        const filter = (m) => (m.inferenceTypesSupported?.includes("ON_DEMAND") && !m.outputModalities?.includes("EMBEDDING")) ?? false;
+        const filter = (m) => (m.inferenceTypesSupported?.includes('ON_DEMAND') && !m.outputModalities?.includes('EMBEDDING')) ?? false;
         return this._listModels(filter);
     }
     async _listModels(foundationFilter) {
@@ -1032,26 +1308,36 @@ export class BedrockDriver extends AbstractDriver {
             }),
         ]);
         if (!foundationModelsList?.modelSummaries) {
-            throw new Error("Foundation models not found");
+            throw new Error('Foundation models not found');
         }
         let foundationModels = foundationModelsList.modelSummaries || [];
         if (foundationFilter) {
             foundationModels = foundationModels.filter(foundationFilter);
         }
-        const supportedPublishers = ["amazon", "anthropic", "cohere", "ai21",
-            "mistral", "meta", "deepseek", "writer",
-            "openai", "twelvelabs", "qwen"];
+        const supportedPublishers = [
+            'amazon',
+            'anthropic',
+            'cohere',
+            'ai21',
+            'mistral',
+            'meta',
+            'deepseek',
+            'writer',
+            'openai',
+            'twelvelabs',
+            'qwen',
+        ];
         const unsupportedModelsByPublisher = {
-            amazon: ["titan-image-generator", "nova-reel", "nova-sonic", "rerank"],
+            amazon: ['titan-image-generator', 'nova-reel', 'nova-sonic', 'rerank'],
             anthropic: [],
-            cohere: ["rerank", "embed"],
+            cohere: ['rerank', 'embed'],
             ai21: [],
             mistral: [],
             meta: [],
             deepseek: [],
             writer: [],
             openai: [],
-            twelvelabs: ["marengo"],
+            twelvelabs: ['marengo'],
             qwen: [],
         };
         // Helper function to check if model should be filtered out
@@ -1060,22 +1346,22 @@ export class BedrockDriver extends AbstractDriver {
                 return false;
             const normalizedProvider = providerName.toLowerCase();
             // Check if provider is supported
-            const isProviderSupported = supportedPublishers.some(provider => normalizedProvider.includes(provider));
+            const isProviderSupported = supportedPublishers.some((provider) => normalizedProvider.includes(provider));
             if (!isProviderSupported)
                 return false;
             // Check if model is in the unsupported list for its provider
             for (const provider of supportedPublishers) {
                 if (normalizedProvider.includes(provider)) {
                     const unsupportedModels = unsupportedModelsByPublisher[provider] || [];
-                    return !unsupportedModels.some(unsupported => modelId.toLowerCase().includes(unsupported));
+                    return !unsupportedModels.some((unsupported) => modelId.toLowerCase().includes(unsupported));
                 }
             }
             return true;
         };
-        foundationModels = foundationModels.filter(m => shouldIncludeModel(m.modelId, m.providerName));
+        foundationModels = foundationModels.filter((m) => shouldIncludeModel(m.modelId, m.providerName));
         const aiModels = foundationModels.map((m) => {
             if (!m.modelId) {
-                throw new Error("modelId not found");
+                throw new Error('modelId not found');
             }
             const modelCapability = getModelCapabilities(m.modelArn ?? m.modelId, this.provider);
             const model = {
@@ -1084,8 +1370,12 @@ export class BedrockDriver extends AbstractDriver {
                 provider: this.provider,
                 owner: m.providerName,
                 can_stream: m.responseStreamingSupported ?? false,
-                input_modalities: m.inputModalities ? formatAmazonModalities(m.inputModalities) : modelModalitiesToArray(modelCapability.input),
-                output_modalities: m.outputModalities ? formatAmazonModalities(m.outputModalities) : modelModalitiesToArray(modelCapability.input),
+                input_modalities: m.inputModalities
+                    ? formatAmazonModalities(m.inputModalities)
+                    : modelModalitiesToArray(modelCapability.input),
+                output_modalities: m.outputModalities
+                    ? formatAmazonModalities(m.outputModalities)
+                    : modelModalitiesToArray(modelCapability.input),
                 tool_support: modelCapability.tool_support,
             };
             return model;
@@ -1094,14 +1384,14 @@ export class BedrockDriver extends AbstractDriver {
         if (customModelsList?.modelSummaries) {
             customModelsList.modelSummaries.forEach((m) => {
                 if (!m.modelArn) {
-                    throw new Error("Model ID not found");
+                    throw new Error('Model ID not found');
                 }
                 const modelCapability = getModelCapabilities(m.modelArn, this.provider);
                 const model = {
                     id: m.modelArn,
                     name: m.modelName ?? m.modelArn,
                     provider: this.provider,
-                    owner: "custom",
+                    owner: 'custom',
                     description: `Custom model from ${m.baseModelName}`,
                     is_custom: true,
                     input_modalities: modelModalitiesToArray(modelCapability.input),
@@ -1109,20 +1399,19 @@ export class BedrockDriver extends AbstractDriver {
                     tool_support: modelCapability.tool_support,
                 };
                 aiModels.push(model);
-                this.validateConnection;
             });
         }
         //add inference profiles
         if (inferenceProfilesList?.inferenceProfileSummaries) {
             inferenceProfilesList.inferenceProfileSummaries.forEach((p) => {
                 if (!p.inferenceProfileArn) {
-                    throw new Error("Profile ARN not found");
+                    throw new Error('Profile ARN not found');
                 }
                 // Apply the same filtering logic to inference profiles based on their name
-                const profileId = p.inferenceProfileId || "";
-                const profileName = p.inferenceProfileName || "";
+                const profileId = p.inferenceProfileId || '';
+                const profileName = p.inferenceProfileName || '';
                 // Extract provider name from profile name or ID
-                let providerName = "";
+                let providerName = '';
                 for (const provider of supportedPublishers) {
                     if (profileName.toLowerCase().includes(provider) || profileId.toLowerCase().includes(provider)) {
                         providerName = provider;
@@ -1146,73 +1435,8 @@ export class BedrockDriver extends AbstractDriver {
         }
         return aiModels;
     }
-    async generateEmbeddings({ text, image, model }) {
-        this.logger.info("[Bedrock] Generating embeddings with model " + model);
-        // Handle TwelveLabs Marengo models
-        if (model?.includes("twelvelabs.marengo")) {
-            return this.generateTwelvelabsMarengoEmbeddings({ text, image, model });
-        }
-        // Handle other Bedrock embedding models
-        const defaultModel = image ? "amazon.titan-embed-image-v1" : "amazon.titan-embed-text-v2:0";
-        const modelID = model ?? defaultModel;
-        const invokeBody = {
-            inputText: text,
-            inputImage: image
-        };
-        const executor = this.getExecutor();
-        const res = await executor.invokeModel({
-            modelId: modelID,
-            contentType: "application/json",
-            body: JSON.stringify(invokeBody),
-        });
-        const decoder = new TextDecoder();
-        const body = decoder.decode(res.body);
-        const result = JSON.parse(body);
-        if (!result.embedding) {
-            throw new Error("Embeddings not found");
-        }
-        return {
-            values: result.embedding,
-            model: modelID,
-            token_count: result.inputTextTokenCount
-        };
-    }
-    async generateTwelvelabsMarengoEmbeddings({ text, image, model }) {
-        const executor = this.getExecutor();
-        // Prepare the request payload for TwelveLabs Marengo
-        const invokeBody = {
-            inputType: "text"
-        };
-        if (text) {
-            invokeBody.inputText = text;
-            invokeBody.inputType = "text";
-        }
-        if (image) {
-            // For the embeddings interface, image is expected to be base64
-            invokeBody.mediaSource = {
-                base64String: image
-            };
-            invokeBody.inputType = "image";
-        }
-        const res = await executor.invokeModel({
-            modelId: model,
-            contentType: "application/json",
-            accept: "application/json",
-            body: JSON.stringify(invokeBody),
-        });
-        const decoder = new TextDecoder();
-        const body = decoder.decode(res.body);
-        const result = JSON.parse(body);
-        // TwelveLabs Marengo returns embedding data
-        if (!result.embedding) {
-            throw new Error("Embeddings not found in TwelveLabs Marengo response");
-        }
-        return {
-            values: result.embedding,
-            model: model,
-            // TwelveLabs Marengo doesn't return token count in the same way
-            token_count: undefined
-        };
+    async generateEmbeddings(options) {
+        return generateBedrockEmbeddings(this, options);
     }
     /**
      * Cleanup AWS SDK clients when the driver is evicted from the cache.
@@ -1220,6 +1444,9 @@ export class BedrockDriver extends AbstractDriver {
     destroy() {
         this._executor?.destroy();
         this._service?.destroy();
+        this._executor = undefined;
+        this._service = undefined;
+        super.destroy();
     }
 }
 function jobInfo(job, jobId) {
@@ -1231,7 +1458,7 @@ function jobInfo(job, jobId) {
     }
     else if (jobStatus === ModelCustomizationJobStatus.FAILED) {
         status = TrainingJobStatus.failed;
-        details = job.failureMessage || "error";
+        details = job.failureMessage || 'error';
     }
     else if (jobStatus === ModelCustomizationJobStatus.STOPPED) {
         status = TrainingJobStatus.cancelled;
@@ -1240,12 +1467,11 @@ function jobInfo(job, jobId) {
         status = TrainingJobStatus.running;
         details = jobStatus;
     }
-    job.baseModelArn;
     return {
         id: jobId,
         model: job.outputModelArn,
         status,
-        details
+        details,
     };
 }
 function getToolDefinitions(tools) {
@@ -1258,8 +1484,8 @@ function getToolDefinition(tool) {
             description: tool.description,
             inputSchema: {
                 json: tool.input_schema,
-            }
-        }
+            },
+        },
     };
 }
 /**
@@ -1270,8 +1496,7 @@ export function messagesContainToolBlocks(messages) {
         if (!msg.content)
             continue;
         for (const block of msg.content) {
-            if (block.toolUse ||
-                block.toolResult) {
+            if (block.toolUse || block.toolResult) {
                 return true;
             }
         }
@@ -1287,13 +1512,12 @@ export function messagesContainToolBlocks(messages) {
  * conversation history contains tool interactions from prior turns.
  */
 export function convertToolBlocksToText(messages) {
-    return messages.map(msg => {
+    return messages.map((msg) => {
         if (!msg.content)
             return msg;
         let hasToolBlocks = false;
         for (const block of msg.content) {
-            if (block.toolUse ||
-                block.toolResult) {
+            if (block.toolUse || block.toolResult) {
                 hasToolBlocks = true;
                 break;
             }
@@ -1306,7 +1530,7 @@ export function convertToolBlocksToText(messages) {
             const toolResult = block.toolResult;
             if (toolUse) {
                 const inputStr = toolUse.input ? JSON.stringify(toolUse.input) : '';
-                const truncatedInput = inputStr.length > 500 ? inputStr.substring(0, 500) + '...' : inputStr;
+                const truncatedInput = inputStr.length > 500 ? `${inputStr.substring(0, 500)}...` : inputStr;
                 newContent.push({
                     text: `[Tool call: ${toolUse.name}(${truncatedInput})]`,
                 });
@@ -1315,9 +1539,9 @@ export function convertToolBlocksToText(messages) {
                 const resultTexts = [];
                 if (toolResult.content) {
                     for (const c of toolResult.content) {
-                        if (c.text) {
+                        if ('text' in c && typeof c.text === 'string') {
                             const text = c.text;
-                            resultTexts.push(text.length > 500 ? text.substring(0, 500) + '...' : text);
+                            resultTexts.push(text.length > 500 ? `${text.substring(0, 500)}...` : text);
                         }
                     }
                 }
@@ -1368,8 +1592,11 @@ function removeUndefinedValues(obj) {
 function updateConversation(conversation, prompt) {
     const combinedMessages = [...(conversation?.messages || []), ...(prompt.messages || [])];
     const combinedSystem = prompt.system || conversation?.system;
-    // Fix orphaned toolUse blocks before returning
-    const fixedMessages = fixOrphanedToolUse(combinedMessages);
+    // Fix both orphan directions before returning: a toolUse with no result
+    // (interrupted run) gets a synthetic result; a toolResult with no matching
+    // toolUse in the previous message (e.g. compaction-trimmed) is dropped. Either
+    // would otherwise trip the Converse API's toolUse/toolResult pairing check.
+    const fixedMessages = fixOrphanedToolResults(fixOrphanedToolUse(combinedMessages));
     return {
         modelId: prompt?.modelId || conversation?.modelId,
         messages: fixedMessages.length > 0 ? fixedMessages : [],
@@ -1377,16 +1604,16 @@ function updateConversation(conversation, prompt) {
     };
 }
 function stripClaudeCachePoints(messages) {
-    return messages.map(message => ({
+    return messages.map((message) => ({
         ...message,
-        content: message.content?.filter(block => !('cachePoint' in block)),
+        content: message.content?.filter((block) => !('cachePoint' in block)),
     }));
 }
 function stripClaudeCachePointsFromSystem(system) {
-    return (system?.filter(block => !('cachePoint' in block)) ?? undefined);
+    return (system?.filter((block) => !('cachePoint' in block)) ?? undefined);
 }
 function stripClaudeCachePointsFromTools(tools) {
-    return (tools?.filter(tool => !('cachePoint' in tool)) ?? undefined);
+    return (tools?.filter((tool) => !('cachePoint' in tool)) ?? undefined);
 }
 /**
  * Fix orphaned toolUse blocks in the conversation.
@@ -1413,7 +1640,7 @@ export function fixOrphanedToolUse(messages) {
                 if (block.toolUse?.toolUseId) {
                     toolUseBlocks.push({
                         toolUseId: block.toolUse.toolUseId,
-                        name: block.toolUse.name ?? 'unknown'
+                        name: block.toolUse.name ?? 'unknown',
                     });
                 }
             }
@@ -1429,21 +1656,23 @@ export function fixOrphanedToolUse(messages) {
                         }
                     }
                     // Find orphaned toolUse blocks (no matching toolResult)
-                    const orphanedToolUse = toolUseBlocks.filter(tu => !toolResultIds.has(tu.toolUseId));
+                    const orphanedToolUse = toolUseBlocks.filter((tu) => !toolResultIds.has(tu.toolUseId));
                     if (orphanedToolUse.length > 0) {
                         // Inject synthetic toolResults for orphaned toolUse
-                        const syntheticResults = orphanedToolUse.map(tu => ({
+                        const syntheticResults = orphanedToolUse.map((tu) => ({
                             toolResult: {
                                 toolUseId: tu.toolUseId,
-                                content: [{
-                                        text: `[Tool interrupted: The user stopped the operation before "${tu.name}" could execute.]`
-                                    }]
-                            }
+                                content: [
+                                    {
+                                        text: `[Tool interrupted: The user stopped the operation before "${tu.name}" could execute.]`,
+                                    },
+                                ],
+                            },
                         }));
                         // Prepend synthetic results to the next user message
                         const updatedNextMessage = {
                             ...nextMessage,
-                            content: [...syntheticResults, ...nextMessage.content]
+                            content: [...syntheticResults, ...nextMessage.content],
                         };
                         // Replace the next message in our iteration
                         messages[i + 1] = updatedNextMessage;
@@ -1452,17 +1681,19 @@ export function fixOrphanedToolUse(messages) {
                 else if (nextMessage && nextMessage.role === 'user' && !nextMessage.content) {
                     // Next message is a user message but has no content
                     // We need to add toolResults
-                    const syntheticResults = toolUseBlocks.map(tu => ({
+                    const syntheticResults = toolUseBlocks.map((tu) => ({
                         toolResult: {
                             toolUseId: tu.toolUseId,
-                            content: [{
-                                    text: `[Tool interrupted: The user stopped the operation before "${tu.name}" could execute.]`
-                                }]
-                        }
+                            content: [
+                                {
+                                    text: `[Tool interrupted: The user stopped the operation before "${tu.name}" could execute.]`,
+                                },
+                            ],
+                        },
                     }));
                     const updatedNextMessage = {
                         role: 'user',
-                        content: syntheticResults
+                        content: syntheticResults,
                     };
                     messages[i + 1] = updatedNextMessage;
                 }
@@ -1473,23 +1704,67 @@ export function fixOrphanedToolUse(messages) {
     }
     return result;
 }
+/**
+ * Drop toolResult blocks whose toolUseId has no matching toolUse in the
+ * immediately-preceding assistant message. Mirror of {@link fixOrphanedToolUse}:
+ * that function synthesizes results for an unanswered toolUse (e.g. a cancelled
+ * run); this one removes results left dangling after their toolUse was dropped
+ * (e.g. by conversation compaction/trimming).
+ *
+ * Without this, the AWS Converse API rejects the request because every
+ * toolResult must correspond to a toolUse in the previous message. Bedrock
+ * conversations are already role-alternating, so a compaction that drops an
+ * assistant toolUse turn leaves an orphaned toolResult (and a user/user
+ * adjacency); dropping the orphan — and the now-empty message — repairs both.
+ */
+export function fixOrphanedToolResults(messages) {
+    if (messages.length === 0)
+        return messages;
+    const result = [];
+    for (let i = 0; i < messages.length; i++) {
+        const message = messages[i];
+        if (message.role !== 'user' || !message.content) {
+            result.push(message);
+            continue;
+        }
+        const hasToolResult = message.content.some((block) => block.toolResult);
+        if (!hasToolResult) {
+            result.push(message);
+            continue;
+        }
+        const prev = messages[i - 1];
+        const allowedIds = new Set();
+        if (prev && prev.role === 'assistant' && prev.content) {
+            for (const block of prev.content) {
+                if (block.toolUse?.toolUseId)
+                    allowedIds.add(block.toolUse.toolUseId);
+            }
+        }
+        const filtered = message.content.filter((block) => block.toolResult ? allowedIds.has(block.toolResult.toolUseId ?? '') : true);
+        // Drop the message if every block was an orphaned toolResult.
+        if (filtered.length === 0)
+            continue;
+        result.push(filtered.length === message.content.length ? message : { ...message, content: filtered });
+    }
+    return result;
+}
 function formatAmazonModalities(modalities) {
     const standardizedModalities = [];
     for (const modality of modalities) {
         if (modality === ModelModality.TEXT) {
-            standardizedModalities.push("text");
+            standardizedModalities.push('text');
         }
         else if (modality === ModelModality.IMAGE) {
-            standardizedModalities.push("image");
+            standardizedModalities.push('image');
         }
         else if (modality === ModelModality.EMBEDDING) {
-            standardizedModalities.push("embedding");
+            standardizedModalities.push('embedding');
         }
-        else if (modality === "SPEECH") {
-            standardizedModalities.push("audio");
+        else if (modality === 'SPEECH') {
+            standardizedModalities.push('audio');
         }
-        else if (modality === "VIDEO") {
-            standardizedModalities.push("video");
+        else if (modality === 'VIDEO') {
+            standardizedModalities.push('video');
         }
         else {
             // Handle other modalities as needed