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

package/src/{bedrock-embedding-options.ts → amazon-bedrock-embedding-model-options.ts}

@@ -1,6 +1,6 @@
 import { z } from 'zod/v4';
 
-export type BedrockEmbeddingModelId =
+export type AmazonBedrockEmbeddingModelId =
   | 'amazon.titan-embed-text-v1'
   | 'amazon.titan-embed-text-v2:0'
   | 'cohere.embed-english-v3'

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

@@ -1,41 +1,58 @@
 import {
-  EmbeddingModelV4,
   TooManyEmbeddingValuesForCallError,
+  type EmbeddingModelV4,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
-  Resolvable,
   combineHeaders,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
   parseProviderOptions,
   postJsonToApi,
   resolve,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
+  type FetchFunction,
+  type Resolvable,
 } from '@ai-sdk/provider-utils';
 import {
-  BedrockEmbeddingModelId,
   amazonBedrockEmbeddingModelOptionsSchema,
-} from './bedrock-embedding-options';
-import { BedrockErrorSchema } from './bedrock-error';
+  type AmazonBedrockEmbeddingModelId,
+} from './amazon-bedrock-embedding-model-options';
+import { AmazonBedrockErrorSchema } from './amazon-bedrock-error';
 import { z } from 'zod/v4';
 
-type BedrockEmbeddingConfig = {
+type AmazonBedrockEmbeddingConfig = {
   baseUrl: () => string;
-  headers: Resolvable<Record<string, string | undefined>>;
+  headers?: Resolvable<Record<string, string | undefined>>;
   fetch?: FetchFunction;
 };
 
 type DoEmbedResponse = Awaited<ReturnType<EmbeddingModelV4['doEmbed']>>;
 
-export class BedrockEmbeddingModel implements EmbeddingModelV4 {
+export class AmazonBedrockEmbeddingModel implements EmbeddingModelV4 {
   readonly specificationVersion = 'v4';
   readonly provider = 'amazon-bedrock';
   readonly maxEmbeddingsPerCall = 1;
   readonly supportsParallelCalls = true;
 
+  static [WORKFLOW_SERIALIZE](model: AmazonBedrockEmbeddingModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: string;
+    config: AmazonBedrockEmbeddingConfig;
+  }) {
+    return new AmazonBedrockEmbeddingModel(options.modelId, options.config);
+  }
+
   constructor(
-    readonly modelId: BedrockEmbeddingModelId,
-    private readonly config: BedrockEmbeddingConfig,
+    readonly modelId: AmazonBedrockEmbeddingModelId,
+    private readonly config: AmazonBedrockEmbeddingConfig,
   ) {}
 
   private getUrl(modelId: string): string {
@@ -58,13 +75,20 @@ export class BedrockEmbeddingModel implements EmbeddingModelV4 {
       });
     }
 
-    // Parse provider options
-    const bedrockOptions =
+    // Parse provider options. Prefer `amazonBedrock`; fall back to legacy
+    // `bedrock` key for backward compatibility.
+    const amazonBedrockOptions =
+      (await parseProviderOptions({
+        provider: 'amazonBedrock',
+        providerOptions,
+        schema: amazonBedrockEmbeddingModelOptionsSchema,
+      })) ??
       (await parseProviderOptions({
         provider: 'bedrock',
         providerOptions,
         schema: amazonBedrockEmbeddingModelOptionsSchema,
-      })) ?? {};
+      })) ??
+      {};
 
     // https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_InvokeModel.html
     //
@@ -73,17 +97,19 @@ export class BedrockEmbeddingModel implements EmbeddingModelV4 {
     // adapt here based on the modelId.
     const isNovaModel =
       this.modelId.startsWith('amazon.nova-') && this.modelId.includes('embed');
-    const isCohereModel = this.modelId.startsWith('cohere.embed-');
+    // Use `includes` so cross-region inference profile ids (e.g.
+    // `us.cohere.embed-v4:0`, `global.cohere.embed-v4:0`) are detected too.
+    const isCohereModel = this.modelId.includes('cohere.embed-');
 
     const args = isNovaModel
       ? {
           taskType: 'SINGLE_EMBEDDING',
           singleEmbeddingParams: {
             embeddingPurpose:
-              bedrockOptions.embeddingPurpose ?? 'GENERIC_INDEX',
-            embeddingDimension: bedrockOptions.embeddingDimension ?? 1024,
+              amazonBedrockOptions.embeddingPurpose ?? 'GENERIC_INDEX',
+            embeddingDimension: amazonBedrockOptions.embeddingDimension ?? 1024,
             text: {
-              truncationMode: bedrockOptions.truncate ?? 'END',
+              truncationMode: amazonBedrockOptions.truncate ?? 'END',
               value: values[0],
             },
           },
@@ -92,30 +118,33 @@ export class BedrockEmbeddingModel implements EmbeddingModelV4 {
         ? {
             // Cohere embedding models on Bedrock require `input_type`.
             // Without it, the service attempts other schema branches and rejects the request.
-            input_type: bedrockOptions.inputType ?? 'search_query',
+            input_type: amazonBedrockOptions.inputType ?? 'search_query',
             texts: [values[0]],
-            truncate: bedrockOptions.truncate,
-            output_dimension: bedrockOptions.outputDimension,
+            truncate: amazonBedrockOptions.truncate,
+            output_dimension: amazonBedrockOptions.outputDimension,
           }
         : {
             inputText: values[0],
-            dimensions: bedrockOptions.dimensions,
-            normalize: bedrockOptions.normalize,
+            dimensions: amazonBedrockOptions.dimensions,
+            normalize: amazonBedrockOptions.normalize,
           };
 
     const url = this.getUrl(this.modelId);
-    const { value: response } = await postJsonToApi({
+    const { value: response, responseHeaders } = await postJsonToApi({
       url,
       headers: await resolve(
-        combineHeaders(await resolve(this.config.headers), headers),
+        combineHeaders(
+          this.config.headers ? await resolve(this.config.headers) : undefined,
+          headers,
+        ),
       ),
       body: args,
       failedResponseHandler: createJsonErrorResponseHandler({
-        errorSchema: BedrockErrorSchema,
+        errorSchema: AmazonBedrockErrorSchema,
         errorToMessage: error => `${error.type}: ${error.message}`,
       }),
       successfulResponseHandler: createJsonResponseHandler(
-        BedrockEmbeddingResponseSchema,
+        AmazonBedrockEmbeddingResponseSchema,
       ),
       fetch: this.config.fetch,
       abortSignal,
@@ -145,12 +174,15 @@ export class BedrockEmbeddingModel implements EmbeddingModelV4 {
     }
 
     // Extract token count based on response format
+    const headerTokenCount = Number(
+      responseHeaders?.['x-amzn-bedrock-input-token-count'],
+    );
     const tokens =
       'inputTextTokenCount' in response
         ? response.inputTextTokenCount // Titan response
         : 'inputTokenCount' in response
           ? (response.inputTokenCount ?? 0) // Nova response
-          : NaN; // Cohere doesn't return token count
+          : headerTokenCount;
 
     return {
       embeddings: [embedding],
@@ -160,7 +192,7 @@ export class BedrockEmbeddingModel implements EmbeddingModelV4 {
   }
 }
 
-const BedrockEmbeddingResponseSchema = z.union([
+const AmazonBedrockEmbeddingResponseSchema = z.union([
   // Titan-style response
   z.object({
     embedding: z.array(z.number()),

package/src/{bedrock-error.ts → amazon-bedrock-error.ts}

@@ -1,6 +1,6 @@
 import { z } from 'zod/v4';
 
-export const BedrockErrorSchema = z.object({
+export const AmazonBedrockErrorSchema = z.object({
   message: z.string(),
   type: z.string().nullish(),
 });

package/src/{bedrock-event-stream-decoder.ts → amazon-bedrock-event-stream-decoder.ts}

@@ -7,7 +7,7 @@ export interface DecodedEvent {
   data: string;
 }
 
-export function createBedrockEventStreamDecoder<T>(
+export function createAmazonBedrockEventStreamDecoder<T>(
   body: ReadableStream<Uint8Array>,
   processEvent: (
     event: DecodedEvent,

package/src/{bedrock-event-stream-response-handler.ts → amazon-bedrock-event-stream-response-handler.ts}

@@ -1,15 +1,15 @@
 import { EmptyResponseBodyError } from '@ai-sdk/provider';
 import {
-  ParseResult,
   safeParseJSON,
   extractResponseHeaders,
-  ResponseHandler,
   safeValidateTypes,
+  type ParseResult,
+  type ResponseHandler,
 } from '@ai-sdk/provider-utils';
-import { ZodType } from 'zod/v4';
-import { createBedrockEventStreamDecoder } from './bedrock-event-stream-decoder';
+import type { ZodType } from 'zod/v4';
+import { createAmazonBedrockEventStreamDecoder } from './amazon-bedrock-event-stream-decoder';
 
-export const createBedrockEventStreamResponseHandler =
+export const createAmazonBedrockEventStreamResponseHandler =
   <T>(
     chunkSchema: ZodType<T, any>,
   ): ResponseHandler<ReadableStream<ParseResult<T>>> =>
@@ -22,7 +22,7 @@ export const createBedrockEventStreamResponseHandler =
 
     return {
       responseHeaders,
-      value: createBedrockEventStreamDecoder<ParseResult<T>>(
+      value: createAmazonBedrockEventStreamDecoder<ParseResult<T>>(
         response.body,
         async (event, controller) => {
           if (event.messageType === 'event') {

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

@@ -1,38 +1,55 @@
-import {
+import type {
   ImageModelV4,
   ImageModelV4File,
   SharedV4Warning,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
-  Resolvable,
   combineHeaders,
   convertUint8ArrayToBase64,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
   postJsonToApi,
   resolve,
+  serializeModelOptions,
+  WORKFLOW_SERIALIZE,
+  WORKFLOW_DESERIALIZE,
+  type FetchFunction,
+  type Resolvable,
 } from '@ai-sdk/provider-utils';
 import {
-  BedrockImageModelId,
   modelMaxImagesPerCall,
-} from './bedrock-image-settings';
-import { BedrockErrorSchema } from './bedrock-error';
+  type AmazonBedrockImageModelId,
+} from './amazon-bedrock-image-settings';
+import { AmazonBedrockErrorSchema } from './amazon-bedrock-error';
 import { z } from 'zod/v4';
 
-type BedrockImageModelConfig = {
+type AmazonBedrockImageModelConfig = {
   baseUrl: () => string;
-  headers: Resolvable<Record<string, string | undefined>>;
+  headers?: Resolvable<Record<string, string | undefined>>;
   fetch?: FetchFunction;
   _internal?: {
     currentDate?: () => Date;
   };
 };
 
-export class BedrockImageModel implements ImageModelV4 {
+export class AmazonBedrockImageModel implements ImageModelV4 {
   readonly specificationVersion = 'v4';
   readonly provider = 'amazon-bedrock';
 
+  static [WORKFLOW_SERIALIZE](model: AmazonBedrockImageModel) {
+    return serializeModelOptions({
+      modelId: model.modelId,
+      config: model.config,
+    });
+  }
+
+  static [WORKFLOW_DESERIALIZE](options: {
+    modelId: string;
+    config: AmazonBedrockImageModelConfig;
+  }) {
+    return new AmazonBedrockImageModel(options.modelId, options.config);
+  }
+
   get maxImagesPerCall(): number {
     return modelMaxImagesPerCall[this.modelId] ?? 1;
   }
@@ -43,8 +60,8 @@ export class BedrockImageModel implements ImageModelV4 {
   }
 
   constructor(
-    readonly modelId: BedrockImageModelId,
-    private readonly config: BedrockImageModelConfig,
+    readonly modelId: AmazonBedrockImageModelId,
+    private readonly config: AmazonBedrockImageModelConfig,
   ) {}
 
   async doGenerate({
@@ -66,17 +83,22 @@ export class BedrockImageModel implements ImageModelV4 {
 
     const hasFiles = files != null && files.length > 0;
 
+    // Prefer the new `amazonBedrock` providerOptions key; fall back to the
+    // legacy `bedrock` key for backward compatibility.
+    const amazonBedrockOptions = (providerOptions?.amazonBedrock ??
+      providerOptions?.bedrock) as Record<string, any> | undefined;
+
     // Build image generation config (common to most modes)
     const imageGenerationConfig = {
       ...(width ? { width } : {}),
       ...(height ? { height } : {}),
       ...(seed ? { seed } : {}),
       ...(n ? { numberOfImages: n } : {}),
-      ...(providerOptions?.bedrock?.quality
-        ? { quality: providerOptions.bedrock.quality }
+      ...(amazonBedrockOptions?.quality
+        ? { quality: amazonBedrockOptions.quality }
         : {}),
-      ...(providerOptions?.bedrock?.cfgScale
-        ? { cfgScale: providerOptions.bedrock.cfgScale }
+      ...(amazonBedrockOptions?.cfgScale
+        ? { cfgScale: amazonBedrockOptions.cfgScale }
         : {}),
     };
 
@@ -85,11 +107,11 @@ export class BedrockImageModel implements ImageModelV4 {
     if (hasFiles) {
       // Check if mask is actually provided (has valid data, not just an empty object)
       const hasMask = mask?.type != null;
-      const hasMaskPrompt = providerOptions?.bedrock?.maskPrompt != null;
+      const hasMaskPrompt = amazonBedrockOptions?.maskPrompt != null;
 
       // Determine task type from provider options, or infer from mask presence
       const taskType =
-        providerOptions?.bedrock?.taskType ??
+        amazonBedrockOptions?.taskType ??
         (hasMask || hasMaskPrompt ? 'INPAINTING' : 'IMAGE_VARIATION');
 
       const sourceImageBase64 = getBase64Data(files[0]);
@@ -99,8 +121,8 @@ export class BedrockImageModel implements ImageModelV4 {
           const inPaintingParams: Record<string, unknown> = {
             image: sourceImageBase64,
             ...(prompt ? { text: prompt } : {}),
-            ...(providerOptions?.bedrock?.negativeText
-              ? { negativeText: providerOptions.bedrock.negativeText }
+            ...(amazonBedrockOptions?.negativeText
+              ? { negativeText: amazonBedrockOptions.negativeText }
               : {}),
           };
 
@@ -108,7 +130,7 @@ export class BedrockImageModel implements ImageModelV4 {
           if (hasMask) {
             inPaintingParams.maskImage = getBase64Data(mask);
           } else if (hasMaskPrompt) {
-            inPaintingParams.maskPrompt = providerOptions.bedrock.maskPrompt;
+            inPaintingParams.maskPrompt = amazonBedrockOptions.maskPrompt;
           }
 
           args = {
@@ -123,11 +145,11 @@ export class BedrockImageModel implements ImageModelV4 {
           const outPaintingParams: Record<string, unknown> = {
             image: sourceImageBase64,
             ...(prompt ? { text: prompt } : {}),
-            ...(providerOptions?.bedrock?.negativeText
-              ? { negativeText: providerOptions.bedrock.negativeText }
+            ...(amazonBedrockOptions?.negativeText
+              ? { negativeText: amazonBedrockOptions.negativeText }
               : {}),
-            ...(providerOptions?.bedrock?.outPaintingMode
-              ? { outPaintingMode: providerOptions.bedrock.outPaintingMode }
+            ...(amazonBedrockOptions?.outPaintingMode
+              ? { outPaintingMode: amazonBedrockOptions.outPaintingMode }
               : {}),
           };
 
@@ -135,7 +157,7 @@ export class BedrockImageModel implements ImageModelV4 {
           if (hasMask) {
             outPaintingParams.maskImage = getBase64Data(mask);
           } else if (hasMaskPrompt) {
-            outPaintingParams.maskPrompt = providerOptions.bedrock.maskPrompt;
+            outPaintingParams.maskPrompt = amazonBedrockOptions.maskPrompt;
           }
 
           args = {
@@ -164,13 +186,12 @@ export class BedrockImageModel implements ImageModelV4 {
           const imageVariationParams: Record<string, unknown> = {
             images,
             ...(prompt ? { text: prompt } : {}),
-            ...(providerOptions?.bedrock?.negativeText
-              ? { negativeText: providerOptions.bedrock.negativeText }
+            ...(amazonBedrockOptions?.negativeText
+              ? { negativeText: amazonBedrockOptions.negativeText }
               : {}),
-            ...(providerOptions?.bedrock?.similarityStrength != null
+            ...(amazonBedrockOptions?.similarityStrength != null
               ? {
-                  similarityStrength:
-                    providerOptions.bedrock.similarityStrength,
+                  similarityStrength: amazonBedrockOptions.similarityStrength,
                 }
               : {}),
           };
@@ -192,14 +213,14 @@ export class BedrockImageModel implements ImageModelV4 {
         taskType: 'TEXT_IMAGE',
         textToImageParams: {
           text: prompt,
-          ...(providerOptions?.bedrock?.negativeText
+          ...(amazonBedrockOptions?.negativeText
             ? {
-                negativeText: providerOptions.bedrock.negativeText,
+                negativeText: amazonBedrockOptions.negativeText,
               }
             : {}),
-          ...(providerOptions?.bedrock?.style
+          ...(amazonBedrockOptions?.style
             ? {
-                style: providerOptions.bedrock.style,
+                style: amazonBedrockOptions.style,
               }
             : {}),
         },
@@ -220,15 +241,18 @@ export class BedrockImageModel implements ImageModelV4 {
     const { value: response, responseHeaders } = await postJsonToApi({
       url: this.getUrl(this.modelId),
       headers: await resolve(
-        combineHeaders(await resolve(this.config.headers), headers),
+        combineHeaders(
+          this.config.headers ? await resolve(this.config.headers) : undefined,
+          headers,
+        ),
       ),
       body: args,
       failedResponseHandler: createJsonErrorResponseHandler({
-        errorSchema: BedrockErrorSchema,
+        errorSchema: AmazonBedrockErrorSchema,
         errorToMessage: error => `${error.type}: ${error.message}`,
       }),
       successfulResponseHandler: createJsonResponseHandler(
-        bedrockImageResponseSchema,
+        amazonBedrockImageResponseSchema,
       ),
       abortSignal,
       fetch: this.config.fetch,
@@ -283,7 +307,7 @@ function getBase64Data(file: ImageModelV4File): string {
 
 // minimal version of the schema, focussed on what is needed for the implementation
 // this approach limits breakages when the API changes and increases efficiency
-const bedrockImageResponseSchema = z.object({
+const amazonBedrockImageResponseSchema = z.object({
   // Normal successful response
   images: z.array(z.string()).optional(),
 

package/src/amazon-bedrock-image-settings.ts

@@ -0,0 +1,9 @@
+export type AmazonBedrockImageModelId =
+  | 'amazon.nova-canvas-v1:0'
+  | (string & {});
+
+// https://docs.aws.amazon.com/nova/latest/userguide/image-gen-req-resp-structure.html
+export const modelMaxImagesPerCall: Record<AmazonBedrockImageModelId, number> =
+  {
+    'amazon.nova-canvas-v1:0': 5,
+  };

package/src/{bedrock-prepare-tools.ts → amazon-bedrock-prepare-tools.ts}

@@ -1,15 +1,18 @@
 import {
-  JSONObject,
-  LanguageModelV4CallOptions,
-  SharedV4Warning,
   UnsupportedFunctionalityError,
+  type JSONObject,
+  type LanguageModelV4CallOptions,
+  type SharedV4Warning,
 } from '@ai-sdk/provider';
 import { asSchema } from '@ai-sdk/provider-utils';
 import {
   anthropicTools,
   prepareTools as prepareAnthropicTools,
 } from '@ai-sdk/anthropic/internal';
-import { BedrockTool, BedrockToolConfiguration } from './bedrock-api-types';
+import type {
+  AmazonBedrockTool,
+  AmazonBedrockToolConfiguration,
+} from './amazon-bedrock-api-types';
 
 export async function prepareTools({
   tools,
@@ -20,7 +23,7 @@ export async function prepareTools({
   toolChoice?: LanguageModelV4CallOptions['toolChoice'];
   modelId: string;
 }): Promise<{
-  toolConfig: BedrockToolConfiguration;
+  toolConfig: AmazonBedrockToolConfiguration;
   additionalTools: Record<string, unknown> | undefined;
   betas: Set<string>;
   toolWarnings: SharedV4Warning[];
@@ -68,7 +71,7 @@ export async function prepareTools({
   const functionTools = supportedTools.filter(t => t.type === 'function');
 
   let additionalTools: Record<string, unknown> | undefined = undefined;
-  const bedrockTools: BedrockTool[] = [];
+  const amazonBedrockTools: AmazonBedrockTool[] = [];
 
   const usingAnthropicTools = isAnthropicModel && ProviderTools.length > 0;
 
@@ -105,7 +108,7 @@ export async function prepareTools({
 
       if (toolFactory != null) {
         const fullToolDefinition = (toolFactory as (args: any) => any)({});
-        bedrockTools.push({
+        amazonBedrockTools.push({
           toolSpec: {
             name: tool.name,
             inputSchema: {
@@ -131,7 +134,7 @@ export async function prepareTools({
       : functionTools;
 
   for (const tool of filteredFunctionTools) {
-    bedrockTools.push({
+    amazonBedrockTools.push({
       toolSpec: {
         name: tool.name,
         ...(tool.description?.trim() !== ''
@@ -146,22 +149,23 @@ export async function prepareTools({
   }
 
   // Handle toolChoice for standard Bedrock tools, but NOT for Anthropic provider-defined tools
-  let bedrockToolChoice: BedrockToolConfiguration['toolChoice'] = undefined;
-  if (!usingAnthropicTools && bedrockTools.length > 0 && toolChoice) {
+  let amazonBedrockToolChoice: AmazonBedrockToolConfiguration['toolChoice'] =
+    undefined;
+  if (!usingAnthropicTools && amazonBedrockTools.length > 0 && toolChoice) {
     const type = toolChoice.type;
     switch (type) {
       case 'auto':
-        bedrockToolChoice = { auto: {} };
+        amazonBedrockToolChoice = { auto: {} };
         break;
       case 'required':
-        bedrockToolChoice = { any: {} };
+        amazonBedrockToolChoice = { any: {} };
         break;
       case 'none':
-        bedrockTools.length = 0;
-        bedrockToolChoice = undefined;
+        amazonBedrockTools.length = 0;
+        amazonBedrockToolChoice = undefined;
         break;
       case 'tool':
-        bedrockToolChoice = { tool: { name: toolChoice.toolName } };
+        amazonBedrockToolChoice = { tool: { name: toolChoice.toolName } };
         break;
       default: {
         const _exhaustiveCheck: never = type;
@@ -172,9 +176,9 @@ export async function prepareTools({
     }
   }
 
-  const toolConfig: BedrockToolConfiguration =
-    bedrockTools.length > 0
-      ? { tools: bedrockTools, toolChoice: bedrockToolChoice }
+  const toolConfig: AmazonBedrockToolConfiguration =
+    amazonBedrockTools.length > 0
+      ? { tools: amazonBedrockTools, toolChoice: amazonBedrockToolChoice }
       : {};
 
   return {