@ai-sdk/amazon-bedrock 5.0.0-beta.44 → 5.0.0-beta.46

package/src/{bedrock-chat-language-model.ts → amazon-bedrock-chat-language-model.ts}

@@ -1,4 +1,4 @@
-import {
+import type {
   JSONObject,
   LanguageModelV4,
   LanguageModelV4CallOptions,
@@ -13,9 +13,6 @@ import {
   SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
-  ParseResult,
-  Resolvable,
   combineHeaders,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
@@ -28,39 +25,46 @@ import {
   serializeModelOptions,
   WORKFLOW_SERIALIZE,
   WORKFLOW_DESERIALIZE,
+  type FetchFunction,
+  type ParseResult,
+  type Resolvable,
 } from '@ai-sdk/provider-utils';
 import { getModelCapabilities } from '@ai-sdk/anthropic/internal';
 import { z } from 'zod/v4';
 import {
   BEDROCK_STOP_REASONS,
-  BedrockConverseInput,
-  BedrockStopReason,
-} from './bedrock-api-types';
+  type AmazonBedrockConverseInput,
+  type AmazonBedrockStopReason,
+} from './amazon-bedrock-api-types';
+import {
+  amazonBedrockLanguageModelChatOptions,
+  type AmazonBedrockLanguageModelChatOptions,
+  type AmazonBedrockChatModelId,
+} from './amazon-bedrock-chat-language-model-options';
+import { AmazonBedrockErrorSchema } from './amazon-bedrock-error';
+import { createAmazonBedrockEventStreamResponseHandler } from './amazon-bedrock-event-stream-response-handler';
+import { prepareTools } from './amazon-bedrock-prepare-tools';
 import {
-  AmazonBedrockLanguageModelOptions,
-  BedrockChatModelId,
-  amazonBedrockLanguageModelOptions,
-} from './bedrock-chat-options';
-import { BedrockErrorSchema } from './bedrock-error';
-import { createBedrockEventStreamResponseHandler } from './bedrock-event-stream-response-handler';
-import { prepareTools } from './bedrock-prepare-tools';
-import { BedrockUsage, convertBedrockUsage } from './convert-bedrock-usage';
-import { convertToBedrockChatMessages } from './convert-to-bedrock-chat-messages';
-import { mapBedrockFinishReason } from './map-bedrock-finish-reason';
+  convertAmazonBedrockUsage,
+  type AmazonBedrockUsage,
+} from './convert-amazon-bedrock-usage';
+import { convertToAmazonBedrockChatMessages } from './convert-to-amazon-bedrock-chat-messages';
+import { mapAmazonBedrockFinishReason } from './map-amazon-bedrock-finish-reason';
 import { isMistralModel, normalizeToolCallId } from './normalize-tool-call-id';
+import type { AmazonBedrockReasoningMetadata } from './amazon-bedrock-reasoning-metadata';
 
-type BedrockChatConfig = {
+type AmazonBedrockChatConfig = {
   baseUrl: () => string;
   headers?: Resolvable<Record<string, string | undefined>>;
   fetch?: FetchFunction;
   generateId: () => string;
 };
 
-export class BedrockChatLanguageModel implements LanguageModelV4 {
+export class AmazonBedrockChatLanguageModel implements LanguageModelV4 {
   readonly specificationVersion = 'v4';
   readonly provider = 'amazon-bedrock';
 
-  static [WORKFLOW_SERIALIZE](model: BedrockChatLanguageModel) {
+  static [WORKFLOW_SERIALIZE](model: AmazonBedrockChatLanguageModel) {
     return serializeModelOptions({
       modelId: model.modelId,
       config: model.config,
@@ -69,14 +73,14 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
 
   static [WORKFLOW_DESERIALIZE](options: {
     modelId: string;
-    config: BedrockChatConfig;
+    config: AmazonBedrockChatConfig;
   }) {
-    return new BedrockChatLanguageModel(options.modelId, options.config);
+    return new AmazonBedrockChatLanguageModel(options.modelId, options.config);
   }
 
   constructor(
-    readonly modelId: BedrockChatModelId,
-    private readonly config: BedrockChatConfig,
+    readonly modelId: AmazonBedrockChatModelId,
+    private readonly config: AmazonBedrockChatConfig,
   ) {}
 
   private async getArgs({
@@ -95,18 +99,25 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     reasoning,
     providerOptions,
   }: LanguageModelV4CallOptions): Promise<{
-    command: BedrockConverseInput;
+    command: AmazonBedrockConverseInput;
     warnings: SharedV4Warning[];
     usesJsonResponseTool: boolean;
     betas: Set<string>;
   }> {
-    // Parse provider options
-    let bedrockOptions =
+    // Parse provider options. Prefer `amazonBedrock`; fall back to legacy
+    // `bedrock` key for backward compatibility.
+    let amazonBedrockOptions =
+      (await parseProviderOptions({
+        provider: 'amazonBedrock',
+        providerOptions,
+        schema: amazonBedrockLanguageModelChatOptions,
+      })) ??
       (await parseProviderOptions({
         provider: 'bedrock',
         providerOptions,
-        schema: amazonBedrockLanguageModelOptions,
-      })) ?? {};
+        schema: amazonBedrockLanguageModelChatOptions,
+      })) ??
+      {};
 
     const warnings: SharedV4Warning[] = [];
 
@@ -162,17 +173,17 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     const isAnthropicModel = this.modelId.includes('anthropic');
     const isOpenAIModel = this.modelId.startsWith('openai.');
 
-    bedrockOptions = resolveBedrockReasoningConfig({
+    amazonBedrockOptions = resolveAmazonBedrockReasoningConfig({
       reasoning,
-      bedrockOptions,
+      amazonBedrockOptions,
       warnings,
       isAnthropicModel,
       modelId: this.modelId,
     });
 
     const isThinkingEnabled =
-      bedrockOptions.reasoningConfig?.type === 'enabled' ||
-      bedrockOptions.reasoningConfig?.type === 'adaptive';
+      amazonBedrockOptions.reasoningConfig?.type === 'enabled' ||
+      amazonBedrockOptions.reasoningConfig?.type === 'adaptive';
 
     const { supportsStructuredOutput: modelSupportsStructuredOutput } =
       getModelCapabilities(this.modelId);
@@ -206,33 +217,33 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     warnings.push(...toolWarnings);
 
     if (additionalTools) {
-      bedrockOptions.additionalModelRequestFields = {
-        ...bedrockOptions.additionalModelRequestFields,
+      amazonBedrockOptions.additionalModelRequestFields = {
+        ...amazonBedrockOptions.additionalModelRequestFields,
         ...additionalTools,
       };
     }
 
-    if (betas.size > 0 || bedrockOptions.anthropicBeta) {
-      const existingBetas = bedrockOptions.anthropicBeta ?? [];
+    if (betas.size > 0 || amazonBedrockOptions.anthropicBeta) {
+      const existingBetas = amazonBedrockOptions.anthropicBeta ?? [];
       const mergedBetas =
         betas.size > 0
           ? [...existingBetas, ...Array.from(betas)]
           : existingBetas;
 
-      bedrockOptions.additionalModelRequestFields = {
-        ...bedrockOptions.additionalModelRequestFields,
+      amazonBedrockOptions.additionalModelRequestFields = {
+        ...amazonBedrockOptions.additionalModelRequestFields,
         anthropic_beta: mergedBetas,
       };
     }
 
-    const thinkingType = bedrockOptions.reasoningConfig?.type;
+    const thinkingType = amazonBedrockOptions.reasoningConfig?.type;
     const thinkingBudget =
       thinkingType === 'enabled'
-        ? bedrockOptions.reasoningConfig?.budgetTokens
+        ? amazonBedrockOptions.reasoningConfig?.budgetTokens
         : undefined;
     const thinkingDisplay =
       thinkingType === 'adaptive'
-        ? bedrockOptions.reasoningConfig?.display
+        ? amazonBedrockOptions.reasoningConfig?.display
         : undefined;
     const isAnthropicThinkingEnabled = isAnthropicModel && isThinkingEnabled;
 
@@ -251,16 +262,16 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
         } else {
           inferenceConfig.maxTokens = thinkingBudget + 4096; // Default + thinking budget maxTokens = 4096, TODO update default in v5
         }
-        bedrockOptions.additionalModelRequestFields = {
-          ...bedrockOptions.additionalModelRequestFields,
+        amazonBedrockOptions.additionalModelRequestFields = {
+          ...amazonBedrockOptions.additionalModelRequestFields,
           thinking: {
             type: 'enabled',
             budget_tokens: thinkingBudget,
           },
         };
       } else if (thinkingType === 'adaptive') {
-        bedrockOptions.additionalModelRequestFields = {
-          ...bedrockOptions.additionalModelRequestFields,
+        amazonBedrockOptions.additionalModelRequestFields = {
+          ...amazonBedrockOptions.additionalModelRequestFields,
           thinking: {
             type: 'adaptive',
             ...(thinkingDisplay != null && { display: thinkingDisplay }),
@@ -268,7 +279,7 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
         };
       }
     } else if (!isAnthropicModel) {
-      if (bedrockOptions.reasoningConfig?.budgetTokens != null) {
+      if (amazonBedrockOptions.reasoningConfig?.budgetTokens != null) {
         warnings.push({
           type: 'unsupported',
           feature: 'budgetTokens',
@@ -287,27 +298,27 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     }
 
     const maxReasoningEffort =
-      bedrockOptions.reasoningConfig?.maxReasoningEffort;
+      amazonBedrockOptions.reasoningConfig?.maxReasoningEffort;
 
     if (maxReasoningEffort != null) {
       if (isAnthropicModel) {
-        bedrockOptions.additionalModelRequestFields = {
-          ...bedrockOptions.additionalModelRequestFields,
+        amazonBedrockOptions.additionalModelRequestFields = {
+          ...amazonBedrockOptions.additionalModelRequestFields,
           output_config: {
-            ...bedrockOptions.additionalModelRequestFields?.output_config,
+            ...amazonBedrockOptions.additionalModelRequestFields?.output_config,
             effort: maxReasoningEffort,
           },
         };
       } else if (isOpenAIModel) {
         // OpenAI models on Bedrock expect `reasoning_effort` as a flat value
-        bedrockOptions.additionalModelRequestFields = {
-          ...bedrockOptions.additionalModelRequestFields,
+        amazonBedrockOptions.additionalModelRequestFields = {
+          ...amazonBedrockOptions.additionalModelRequestFields,
           reasoning_effort: maxReasoningEffort,
         };
       } else {
         // other models (such as Nova 2) use reasoningConfig format
-        bedrockOptions.additionalModelRequestFields = {
-          ...bedrockOptions.additionalModelRequestFields,
+        amazonBedrockOptions.additionalModelRequestFields = {
+          ...amazonBedrockOptions.additionalModelRequestFields,
           reasoningConfig: {
             ...(thinkingType != null &&
               thinkingType !== 'adaptive' && { type: thinkingType }),
@@ -319,10 +330,10 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     }
 
     if (useNativeStructuredOutput) {
-      bedrockOptions.additionalModelRequestFields = {
-        ...bedrockOptions.additionalModelRequestFields,
+      amazonBedrockOptions.additionalModelRequestFields = {
+        ...amazonBedrockOptions.additionalModelRequestFields,
         output_config: {
-          ...bedrockOptions.additionalModelRequestFields?.output_config,
+          ...amazonBedrockOptions.additionalModelRequestFields?.output_config,
           format: {
             type: 'json_schema',
             schema: responseFormat!.schema,
@@ -399,18 +410,18 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     }
 
     const isMistral = isMistralModel(this.modelId);
-    const { system, messages } = await convertToBedrockChatMessages(
+    const { system, messages } = await convertToAmazonBedrockChatMessages(
       filteredPrompt,
       isMistral,
     );
 
-    // Filter out reasoningConfig from providerOptions.bedrock to prevent sending it to Bedrock API
+    // Filter out reasoningConfig from amazonBedrock provider options to prevent sending it to Bedrock API
     const {
       reasoningConfig: _,
       additionalModelRequestFields: __,
       serviceTier: ___,
-      ...filteredBedrockOptions
-    } = providerOptions?.bedrock || {};
+      ...filteredAmazonBedrockOptions
+    } = providerOptions?.amazonBedrock ?? providerOptions?.bedrock ?? {};
 
     const additionalModelResponseFieldPaths = isAnthropicModel
       ? ['/delta/stop_sequence']
@@ -421,19 +432,19 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
         system,
         messages,
         additionalModelRequestFields:
-          bedrockOptions.additionalModelRequestFields,
+          amazonBedrockOptions.additionalModelRequestFields,
         ...(additionalModelResponseFieldPaths && {
           additionalModelResponseFieldPaths,
         }),
         ...(Object.keys(inferenceConfig).length > 0 && {
           inferenceConfig,
         }),
-        ...(bedrockOptions.serviceTier != null && {
+        ...(amazonBedrockOptions.serviceTier != null && {
           serviceTier: {
-            type: bedrockOptions.serviceTier,
+            type: amazonBedrockOptions.serviceTier,
           },
         }),
-        ...filteredBedrockOptions,
+        ...filteredAmazonBedrockOptions,
         ...(toolConfig.tools !== undefined && toolConfig.tools.length > 0
           ? { toolConfig }
           : {}),
@@ -474,11 +485,11 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
       headers: await this.getHeaders({ headers: options.headers }),
       body: args,
       failedResponseHandler: createJsonErrorResponseHandler({
-        errorSchema: BedrockErrorSchema,
+        errorSchema: AmazonBedrockErrorSchema,
         errorToMessage: error => `${error.message ?? 'Unknown error'}`,
       }),
       successfulResponseHandler: createJsonResponseHandler(
-        BedrockResponseSchema,
+        AmazonBedrockResponseSchema,
       ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch,
@@ -503,23 +514,26 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
           };
 
           if (part.reasoningContent.reasoningText.signature) {
+            const reasoningPayload: AmazonBedrockReasoningMetadata = {
+              signature: part.reasoningContent.reasoningText.signature,
+            };
             reasoning.providerMetadata = {
-              bedrock: {
-                signature: part.reasoningContent.reasoningText.signature,
-              } satisfies BedrockReasoningMetadata,
+              amazonBedrock: reasoningPayload,
+              bedrock: reasoningPayload,
             };
           }
 
           content.push(reasoning);
         } else if ('redactedReasoning' in part.reasoningContent) {
+          const redactedPayload: AmazonBedrockReasoningMetadata = {
+            redactedData: part.reasoningContent.redactedReasoning.data ?? '',
+          };
           content.push({
             type: 'reasoning',
             text: '',
             providerMetadata: {
-              bedrock: {
-                redactedData:
-                  part.reasoningContent.redactedReasoning.data ?? '',
-              } satisfies BedrockReasoningMetadata,
+              amazonBedrock: redactedPayload,
+              bedrock: redactedPayload,
             },
           });
         }
@@ -555,7 +569,7 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     const stopSequence =
       response.additionalModelResponseFields?.delta?.stop_sequence ?? null;
 
-    const providerMetadata =
+    const providerMetadataPayload =
       response.trace ||
       response.usage ||
       response.performanceConfig ||
@@ -563,43 +577,48 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
       isJsonResponseFromTool ||
       stopSequence
         ? {
-            bedrock: {
-              ...(response.trace && typeof response.trace === 'object'
-                ? { trace: response.trace as JSONObject }
-                : {}),
-              ...(response.performanceConfig && {
-                performanceConfig: response.performanceConfig,
-              }),
-              ...(response.serviceTier && {
-                serviceTier: response.serviceTier,
-              }),
-              ...((response.usage?.cacheWriteInputTokens != null ||
-                response.usage?.cacheDetails != null) && {
-                usage: {
-                  ...(response.usage.cacheWriteInputTokens != null && {
-                    cacheWriteInputTokens: response.usage.cacheWriteInputTokens,
-                  }),
-                  ...(response.usage.cacheDetails != null && {
-                    cacheDetails: response.usage.cacheDetails,
-                  }),
-                },
-              }),
-              ...(isJsonResponseFromTool && { isJsonResponseFromTool: true }),
-              stopSequence,
-            },
+            ...(response.trace && typeof response.trace === 'object'
+              ? { trace: response.trace as JSONObject }
+              : {}),
+            ...(response.performanceConfig && {
+              performanceConfig: response.performanceConfig,
+            }),
+            ...(response.serviceTier && {
+              serviceTier: response.serviceTier,
+            }),
+            ...((response.usage?.cacheWriteInputTokens != null ||
+              response.usage?.cacheDetails != null) && {
+              usage: {
+                ...(response.usage.cacheWriteInputTokens != null && {
+                  cacheWriteInputTokens: response.usage.cacheWriteInputTokens,
+                }),
+                ...(response.usage.cacheDetails != null && {
+                  cacheDetails: response.usage.cacheDetails,
+                }),
+              },
+            }),
+            ...(isJsonResponseFromTool && { isJsonResponseFromTool: true }),
+            stopSequence,
           }
         : undefined;
 
+    const providerMetadata = providerMetadataPayload
+      ? {
+          amazonBedrock: providerMetadataPayload,
+          bedrock: providerMetadataPayload,
+        }
+      : undefined;
+
     return {
       content,
       finishReason: {
-        unified: mapBedrockFinishReason(
-          response.stopReason as BedrockStopReason,
+        unified: mapAmazonBedrockFinishReason(
+          response.stopReason as AmazonBedrockStopReason,
           isJsonResponseFromTool,
         ),
         raw: response.stopReason ?? undefined,
       },
-      usage: convertBedrockUsage(response.usage),
+      usage: convertAmazonBedrockUsage(response.usage),
       response: {
         id: responseHeaders?.['x-amzn-requestid'] ?? undefined,
         timestamp:
@@ -631,11 +650,12 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
       headers: await this.getHeaders({ headers: options.headers }),
       body: args,
       failedResponseHandler: createJsonErrorResponseHandler({
-        errorSchema: BedrockErrorSchema,
+        errorSchema: AmazonBedrockErrorSchema,
         errorToMessage: error => `${error.type}: ${error.message}`,
       }),
-      successfulResponseHandler:
-        createBedrockEventStreamResponseHandler(BedrockStreamSchema),
+      successfulResponseHandler: createAmazonBedrockEventStreamResponseHandler(
+        AmazonBedrockStreamSchema,
+      ),
       abortSignal: options.abortSignal,
       fetch: this.config.fetch,
     });
@@ -644,7 +664,7 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
       unified: 'other',
       raw: undefined,
     };
-    let usage: BedrockUsage | undefined = undefined;
+    let usage: AmazonBedrockUsage | undefined = undefined;
     let providerMetadata: SharedV4ProviderMetadata | undefined = undefined;
     let isJsonResponseFromTool = false;
     let stopSequence: string | null = null;
@@ -664,7 +684,7 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     return {
       stream: response.pipeThrough(
         new TransformStream<
-          ParseResult<z.infer<typeof BedrockStreamSchema>>,
+          ParseResult<z.infer<typeof AmazonBedrockStreamSchema>>,
           LanguageModelV4StreamPart
         >({
           start(controller) {
@@ -681,9 +701,9 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
           },
 
           transform(chunk, controller) {
-            function enqueueError(bedrockError: Record<string, any>) {
+            function enqueueError(amazonBedrockError: Record<string, any>) {
               finishReason = { unified: 'error', raw: undefined };
-              controller.enqueue({ type: 'error', error: bedrockError });
+              controller.enqueue({ type: 'error', error: amazonBedrockError });
             }
 
             // Emit raw chunk if requested (before anything else)
@@ -719,8 +739,8 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
 
             if (value.messageStop) {
               finishReason = {
-                unified: mapBedrockFinishReason(
-                  value.messageStop.stopReason as BedrockStopReason,
+                unified: mapAmazonBedrockFinishReason(
+                  value.messageStop.stopReason as AmazonBedrockStopReason,
                   isJsonResponseFromTool,
                 ),
                 raw: value.messageStop.stopReason ?? undefined,
@@ -764,17 +784,19 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
                 value.metadata.performanceConfig ||
                 value.metadata.serviceTier
               ) {
+                const metadataPayload = {
+                  ...cacheUsage,
+                  ...trace,
+                  ...(value.metadata.performanceConfig && {
+                    performanceConfig: value.metadata.performanceConfig,
+                  }),
+                  ...(value.metadata.serviceTier && {
+                    serviceTier: value.metadata.serviceTier,
+                  }),
+                };
                 providerMetadata = {
-                  bedrock: {
-                    ...cacheUsage,
-                    ...trace,
-                    ...(value.metadata.performanceConfig && {
-                      performanceConfig: value.metadata.performanceConfig,
-                    }),
-                    ...(value.metadata.serviceTier && {
-                      serviceTier: value.metadata.serviceTier,
-                    }),
-                  },
+                  amazonBedrock: metadataPayload,
+                  bedrock: metadataPayload,
                 };
               }
             }
@@ -901,16 +923,20 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
                     id: String(blockIndex),
                   });
                 }
-                controller.enqueue({
-                  type: 'reasoning-delta',
-                  id: String(blockIndex),
-                  delta: '',
-                  providerMetadata: {
-                    bedrock: {
-                      signature: reasoningContent.signature,
-                    } satisfies BedrockReasoningMetadata,
-                  },
-                });
+                {
+                  const signaturePayload: AmazonBedrockReasoningMetadata = {
+                    signature: reasoningContent.signature,
+                  };
+                  controller.enqueue({
+                    type: 'reasoning-delta',
+                    id: String(blockIndex),
+                    delta: '',
+                    providerMetadata: {
+                      amazonBedrock: signaturePayload,
+                      bedrock: signaturePayload,
+                    },
+                  });
+                }
               } else if ('data' in reasoningContent && reasoningContent.data) {
                 if (contentBlocks[blockIndex] == null) {
                   contentBlocks[blockIndex] = { type: 'reasoning' };
@@ -919,16 +945,20 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
                     id: String(blockIndex),
                   });
                 }
-                controller.enqueue({
-                  type: 'reasoning-delta',
-                  id: String(blockIndex),
-                  delta: '',
-                  providerMetadata: {
-                    bedrock: {
-                      redactedData: reasoningContent.data,
-                    } satisfies BedrockReasoningMetadata,
-                  },
-                });
+                {
+                  const redactedPayload: AmazonBedrockReasoningMetadata = {
+                    redactedData: reasoningContent.data,
+                  };
+                  controller.enqueue({
+                    type: 'reasoning-delta',
+                    id: String(blockIndex),
+                    delta: '',
+                    providerMetadata: {
+                      amazonBedrock: redactedPayload,
+                      bedrock: redactedPayload,
+                    },
+                  });
+                }
               }
             }
 
@@ -989,30 +1019,25 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
           flush(controller) {
             // Update provider metadata with isJsonResponseFromTool and stopSequence if needed
             if (isJsonResponseFromTool || stopSequence != null) {
-              if (providerMetadata) {
-                providerMetadata.bedrock = {
-                  ...providerMetadata.bedrock,
-                  ...(isJsonResponseFromTool && {
-                    isJsonResponseFromTool: true,
-                  }),
-                  stopSequence,
-                };
-              } else {
-                providerMetadata = {
-                  bedrock: {
-                    ...(isJsonResponseFromTool && {
-                      isJsonResponseFromTool: true,
-                    }),
-                    stopSequence,
-                  },
-                };
-              }
+              const updatePayload = {
+                ...(providerMetadata?.amazonBedrock ??
+                  providerMetadata?.bedrock),
+                ...(isJsonResponseFromTool && {
+                  isJsonResponseFromTool: true,
+                }),
+                stopSequence,
+              };
+              providerMetadata = {
+                ...providerMetadata,
+                amazonBedrock: updatePayload,
+                bedrock: updatePayload,
+              };
             }
 
             controller.enqueue({
               type: 'finish',
               finishReason,
-              usage: convertBedrockUsage(usage),
+              usage: convertAmazonBedrockUsage(usage),
               ...(providerMetadata && { providerMetadata }),
             });
           },
@@ -1029,12 +1054,12 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
   }
 }
 
-const BedrockStopReasonSchema = z.union([
+const AmazonBedrockStopReasonSchema = z.union([
   z.enum(BEDROCK_STOP_REASONS),
   z.string(),
 ]);
 
-const BedrockAdditionalModelResponseFieldsSchema = z
+const AmazonBedrockAdditionalModelResponseFieldsSchema = z
   .object({
     delta: z
       .object({
@@ -1044,24 +1069,24 @@ const BedrockAdditionalModelResponseFieldsSchema = z
   })
   .catchall(z.unknown());
 
-const BedrockToolUseSchema = z.object({
+const AmazonBedrockToolUseSchema = z.object({
   toolUseId: z.string(),
   name: z.string(),
   input: z.unknown(),
 });
 
-const BedrockReasoningTextSchema = z.object({
+const AmazonBedrockReasoningTextSchema = z.object({
   signature: z.string().nullish(),
   text: z.string(),
 });
 
-const BedrockRedactedReasoningSchema = z.object({
+const AmazonBedrockRedactedReasoningSchema = z.object({
   data: z.string(),
 });
 
 // limited version of the schema, focused on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-const BedrockResponseSchema = z.object({
+const AmazonBedrockResponseSchema = z.object({
   metrics: z
     .object({
       latencyMs: z.number(),
@@ -1072,14 +1097,14 @@ const BedrockResponseSchema = z.object({
       content: z.array(
         z.object({
           text: z.string().nullish(),
-          toolUse: BedrockToolUseSchema.nullish(),
+          toolUse: AmazonBedrockToolUseSchema.nullish(),
           reasoningContent: z
             .union([
               z.object({
-                reasoningText: BedrockReasoningTextSchema,
+                reasoningText: AmazonBedrockReasoningTextSchema,
               }),
               z.object({
-                redactedReasoning: BedrockRedactedReasoningSchema,
+                redactedReasoning: AmazonBedrockRedactedReasoningSchema,
               }),
             ])
             .nullish(),
@@ -1088,9 +1113,9 @@ const BedrockResponseSchema = z.object({
       role: z.string(),
     }),
   }),
-  stopReason: BedrockStopReasonSchema,
+  stopReason: AmazonBedrockStopReasonSchema,
   additionalModelResponseFields:
-    BedrockAdditionalModelResponseFieldsSchema.nullish(),
+    AmazonBedrockAdditionalModelResponseFieldsSchema.nullish(),
   trace: z.unknown().nullish(),
   performanceConfig: z.object({ latency: z.string() }).nullish(),
   serviceTier: z.object({ type: z.string() }).nullish(),
@@ -1108,7 +1133,7 @@ const BedrockResponseSchema = z.object({
 
 // limited version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-const BedrockStreamSchema = z.object({
+const AmazonBedrockStreamSchema = z.object({
   contentBlockDelta: z
     .object({
       contentBlockIndex: z.number(),
@@ -1136,7 +1161,7 @@ const BedrockStreamSchema = z.object({
       contentBlockIndex: z.number(),
       start: z
         .object({
-          toolUse: BedrockToolUseSchema.nullish(),
+          toolUse: AmazonBedrockToolUseSchema.nullish(),
         })
         .nullish(),
     })
@@ -1150,8 +1175,8 @@ const BedrockStreamSchema = z.object({
   messageStop: z
     .object({
       additionalModelResponseFields:
-        BedrockAdditionalModelResponseFieldsSchema.nullish(),
-      stopReason: BedrockStopReasonSchema,
+        AmazonBedrockAdditionalModelResponseFieldsSchema.nullish(),
+      stopReason: AmazonBedrockStopReasonSchema,
     })
     .nullish(),
   metadata: z
@@ -1177,16 +1202,12 @@ const BedrockStreamSchema = z.object({
   validationException: z.record(z.string(), z.unknown()).nullish(),
 });
 
-export const bedrockReasoningMetadataSchema = z.object({
-  signature: z.string().optional(),
-  redactedData: z.string().optional(),
-});
-
-export type BedrockReasoningMetadata = z.infer<
-  typeof bedrockReasoningMetadataSchema
->;
+export {
+  amazonBedrockReasoningMetadataSchema,
+  type AmazonBedrockReasoningMetadata,
+} from './amazon-bedrock-reasoning-metadata';
 
-const bedrockReasoningEffortMap: Partial<
+const amazonBedrockReasoningEffortMap: Partial<
   Record<string, 'low' | 'medium' | 'high' | 'max'>
 > = {
   minimal: 'low',
@@ -1196,24 +1217,24 @@ const bedrockReasoningEffortMap: Partial<
   xhigh: 'max',
 };
 
-function resolveBedrockReasoningConfig({
+function resolveAmazonBedrockReasoningConfig({
   reasoning,
-  bedrockOptions,
+  amazonBedrockOptions,
   warnings,
   isAnthropicModel,
   modelId,
 }: {
   reasoning: LanguageModelV4CallOptions['reasoning'];
-  bedrockOptions: AmazonBedrockLanguageModelOptions;
+  amazonBedrockOptions: AmazonBedrockLanguageModelChatOptions;
   warnings: SharedV4Warning[];
   isAnthropicModel: boolean;
   modelId: string;
-}): AmazonBedrockLanguageModelOptions {
+}): AmazonBedrockLanguageModelChatOptions {
   if (!isCustomReasoning(reasoning)) {
-    return bedrockOptions;
+    return amazonBedrockOptions;
   }
 
-  const result = { ...bedrockOptions };
+  const result = { ...amazonBedrockOptions };
 
   if (isAnthropicModel) {
     const capabilities = getModelCapabilities(modelId);
@@ -1223,13 +1244,13 @@ function resolveBedrockReasoningConfig({
     } else if (capabilities.supportsAdaptiveThinking) {
       const effort = mapReasoningToProviderEffort({
         reasoning,
-        effortMap: bedrockReasoningEffortMap,
+        effortMap: amazonBedrockReasoningEffortMap,
         warnings,
       });
       result.reasoningConfig = {
         type: 'adaptive',
         maxReasoningEffort: effort,
-        ...bedrockOptions.reasoningConfig,
+        ...amazonBedrockOptions.reasoningConfig,
       };
     } else {
       const budgetTokens = mapReasoningToProviderBudget({
@@ -1242,19 +1263,19 @@ function resolveBedrockReasoningConfig({
         result.reasoningConfig = {
           type: 'enabled',
           budgetTokens,
-          ...bedrockOptions.reasoningConfig,
+          ...amazonBedrockOptions.reasoningConfig,
         };
       }
     }
   } else if (reasoning !== 'none') {
     const effort = mapReasoningToProviderEffort({
       reasoning,
-      effortMap: bedrockReasoningEffortMap,
+      effortMap: amazonBedrockReasoningEffortMap,
       warnings,
     });
     result.reasoningConfig = {
       maxReasoningEffort: effort,
-      ...bedrockOptions.reasoningConfig,
+      ...amazonBedrockOptions.reasoningConfig,
     };
   }