@ai-sdk/amazon-bedrock 5.0.0-beta.8 → 5.0.0-beta.85

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

@@ -1,4 +1,4 @@
-import {
+import type {
   JSONObject,
   LanguageModelV4,
   LanguageModelV4CallOptions,
@@ -13,48 +13,74 @@ import {
   SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
-  ParseResult,
-  Resolvable,
   combineHeaders,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
+  isCustomReasoning,
+  mapReasoningToProviderBudget,
+  mapReasoningToProviderEffort,
   parseProviderOptions,
   postJsonToApi,
   resolve,
+  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 {
-  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>>;
+  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: AmazonBedrockChatLanguageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: string;
+    config: AmazonBedrockChatConfig;
+  }) {
+    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({
@@ -70,20 +96,28 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     seed,
     tools,
     toolChoice,
+    reasoning,
     providerOptions,
   }: LanguageModelV4CallOptions): Promise<{
-    command: BedrockConverseInput;
+    command: AmazonBedrockConverseInput;
     warnings: SharedV4Warning[];
     usesJsonResponseTool: boolean;
     betas: Set<string>;
   }> {
-    // Parse provider options
-    const 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[] = [];
 
@@ -137,13 +171,26 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     }
 
     const isAnthropicModel = this.modelId.includes('anthropic');
+    const isOpenAIModel = this.modelId.startsWith('openai.');
+
+    amazonBedrockOptions = resolveAmazonBedrockReasoningConfig({
+      reasoning,
+      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);
 
     const useNativeStructuredOutput =
       isAnthropicModel &&
-      isThinkingEnabled &&
+      (modelSupportsStructuredOutput || isThinkingEnabled) &&
       responseFormat?.type === 'json' &&
       responseFormat.schema != null;
 
@@ -170,29 +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'
+        ? amazonBedrockOptions.reasoningConfig?.display
         : undefined;
     const isAnthropicThinkingEnabled = isAnthropicModel && isThinkingEnabled;
 
@@ -211,23 +262,24 @@ 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 }),
           },
         };
       }
     } else if (!isAnthropicModel) {
-      if (bedrockOptions.reasoningConfig?.budgetTokens != null) {
+      if (amazonBedrockOptions.reasoningConfig?.budgetTokens != null) {
         warnings.push({
           type: 'unsupported',
           feature: 'budgetTokens',
@@ -246,28 +298,27 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     }
 
     const maxReasoningEffort =
-      bedrockOptions.reasoningConfig?.maxReasoningEffort;
-    const isOpenAIModel = this.modelId.startsWith('openai.');
+      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 }),
@@ -279,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,
@@ -359,17 +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: __,
-      ...filteredBedrockOptions
-    } = providerOptions?.bedrock || {};
+      serviceTier: ___,
+      ...filteredAmazonBedrockOptions
+    } = providerOptions?.amazonBedrock ?? providerOptions?.bedrock ?? {};
 
     const additionalModelResponseFieldPaths = isAnthropicModel
       ? ['/delta/stop_sequence']
@@ -380,14 +432,19 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
         system,
         messages,
         additionalModelRequestFields:
-          bedrockOptions.additionalModelRequestFields,
+          amazonBedrockOptions.additionalModelRequestFields,
         ...(additionalModelResponseFieldPaths && {
           additionalModelResponseFieldPaths,
         }),
         ...(Object.keys(inferenceConfig).length > 0 && {
           inferenceConfig,
         }),
-        ...filteredBedrockOptions,
+        ...(amazonBedrockOptions.serviceTier != null && {
+          serviceTier: {
+            type: amazonBedrockOptions.serviceTier,
+          },
+        }),
+        ...filteredAmazonBedrockOptions,
         ...(toolConfig.tools !== undefined && toolConfig.tools.length > 0
           ? { toolConfig }
           : {}),
@@ -407,7 +464,10 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
   }: {
     headers: Record<string, string | undefined> | undefined;
   }) {
-    return combineHeaders(await resolve(this.config.headers), headers);
+    return combineHeaders(
+      this.config.headers ? await resolve(this.config.headers) : undefined,
+      headers,
+    );
   }
 
   async doGenerate(
@@ -425,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,
@@ -441,7 +501,7 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
     // map response content to content array
     for (const part of response.output.message.content) {
       // text
-      if (part.text) {
+      if (part.text != null) {
         content.push({ type: 'text', text: part.text });
       }
 
@@ -454,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,
             },
           });
         }
@@ -506,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 ||
@@ -514,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:
@@ -582,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,
     });
@@ -595,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;
@@ -615,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) {
@@ -632,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)
@@ -670,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,
@@ -715,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,
                 };
               }
             }
@@ -845,27 +916,49 @@ export class BedrockChatLanguageModel implements LanguageModelV4 {
                 'signature' in reasoningContent &&
                 reasoningContent.signature
               ) {
-                controller.enqueue({
-                  type: 'reasoning-delta',
-                  id: String(blockIndex),
-                  delta: '',
-                  providerMetadata: {
-                    bedrock: {
-                      signature: reasoningContent.signature,
-                    } satisfies BedrockReasoningMetadata,
-                  },
-                });
+                if (contentBlocks[blockIndex] == null) {
+                  contentBlocks[blockIndex] = { type: 'reasoning' };
+                  controller.enqueue({
+                    type: 'reasoning-start',
+                    id: String(blockIndex),
+                  });
+                }
+                {
+                  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) {
-                controller.enqueue({
-                  type: 'reasoning-delta',
-                  id: String(blockIndex),
-                  delta: '',
-                  providerMetadata: {
-                    bedrock: {
-                      redactedData: reasoningContent.data,
-                    } satisfies BedrockReasoningMetadata,
-                  },
-                });
+                if (contentBlocks[blockIndex] == null) {
+                  contentBlocks[blockIndex] = { type: 'reasoning' };
+                  controller.enqueue({
+                    type: 'reasoning-start',
+                    id: String(blockIndex),
+                  });
+                }
+                {
+                  const redactedPayload: AmazonBedrockReasoningMetadata = {
+                    redactedData: reasoningContent.data,
+                  };
+                  controller.enqueue({
+                    type: 'reasoning-delta',
+                    id: String(blockIndex),
+                    delta: '',
+                    providerMetadata: {
+                      amazonBedrock: redactedPayload,
+                      bedrock: redactedPayload,
+                    },
+                  });
+                }
               }
             }
 
@@ -926,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 }),
             });
           },
@@ -966,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({
@@ -981,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(),
+  input: z.unknown().optional(),
 });
 
-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(),
@@ -1009,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(),
@@ -1025,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(),
@@ -1045,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(),
@@ -1073,7 +1161,7 @@ const BedrockStreamSchema = z.object({
       contentBlockIndex: z.number(),
       start: z
         .object({
-          toolUse: BedrockToolUseSchema.nullish(),
+          toolUse: AmazonBedrockToolUseSchema.nullish(),
         })
         .nullish(),
     })
@@ -1087,8 +1175,8 @@ const BedrockStreamSchema = z.object({
   messageStop: z
     .object({
       additionalModelResponseFields:
-        BedrockAdditionalModelResponseFieldsSchema.nullish(),
-      stopReason: BedrockStopReasonSchema,
+        AmazonBedrockAdditionalModelResponseFieldsSchema.nullish(),
+      stopReason: AmazonBedrockStopReasonSchema,
     })
     .nullish(),
   metadata: z
@@ -1114,11 +1202,93 @@ 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 {
+  amazonBedrockReasoningMetadataSchema,
+  type AmazonBedrockReasoningMetadata,
+} from './amazon-bedrock-reasoning-metadata';
+
+const amazonBedrockReasoningEffortMap: Partial<
+  Record<string, 'low' | 'medium' | 'high' | 'max'>
+> = {
+  minimal: 'low',
+  low: 'low',
+  medium: 'medium',
+  high: 'high',
+  xhigh: 'max',
+};
+
+function resolveAmazonBedrockReasoningConfig({
+  reasoning,
+  amazonBedrockOptions,
+  warnings,
+  isAnthropicModel,
+  modelId,
+}: {
+  reasoning: LanguageModelV4CallOptions['reasoning'];
+  amazonBedrockOptions: AmazonBedrockLanguageModelChatOptions;
+  warnings: SharedV4Warning[];
+  isAnthropicModel: boolean;
+  modelId: string;
+}): AmazonBedrockLanguageModelChatOptions {
+  if (!isCustomReasoning(reasoning)) {
+    return amazonBedrockOptions;
+  }
+
+  const result = { ...amazonBedrockOptions };
+
+  if (isAnthropicModel) {
+    const capabilities = getModelCapabilities(modelId);
+
+    if (reasoning === 'none') {
+      result.reasoningConfig = { type: 'disabled' };
+    } else if (capabilities.supportsAdaptiveThinking) {
+      const effort = mapReasoningToProviderEffort({
+        reasoning,
+        effortMap: amazonBedrockReasoningEffortMap,
+        warnings,
+      });
+      result.reasoningConfig = {
+        type: 'adaptive',
+        maxReasoningEffort: effort,
+        ...amazonBedrockOptions.reasoningConfig,
+      };
+    } else {
+      const budgetTokens = mapReasoningToProviderBudget({
+        reasoning,
+        maxOutputTokens: capabilities.maxOutputTokens,
+        maxReasoningBudget: capabilities.maxOutputTokens,
+        warnings,
+      });
+      if (budgetTokens != null) {
+        result.reasoningConfig = {
+          type: 'enabled',
+          budgetTokens,
+          ...amazonBedrockOptions.reasoningConfig,
+        };
+      }
+    }
+  } else if (reasoning !== 'none') {
+    const effort = mapReasoningToProviderEffort({
+      reasoning,
+      effortMap: amazonBedrockReasoningEffortMap,
+      warnings,
+    });
+    result.reasoningConfig = {
+      maxReasoningEffort: effort,
+      ...amazonBedrockOptions.reasoningConfig,
+    };
+  }
 
-export type BedrockReasoningMetadata = z.infer<
-  typeof bedrockReasoningMetadataSchema
->;
+  /*
+   * Mirror anthropic-messages-language-model.ts: when the merged type ends up
+   * 'disabled' (user override combined with a non-none reasoning), strip
+   * derived effort/budget so downstream does not emit output_config.effort
+   * alongside disabled thinking.
+   */
+  if (result.reasoningConfig?.type === 'disabled') {
+    delete result.reasoningConfig.maxReasoningEffort;
+    delete result.reasoningConfig.budgetTokens;
+  }
+
+  return result;
+}