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

package/src/{convert-to-bedrock-chat-messages.ts → convert-to-amazon-bedrock-chat-messages.ts}

@@ -1,38 +1,41 @@
 import {
-  JSONObject,
-  LanguageModelV4Message,
-  LanguageModelV4Prompt,
-  SharedV4ProviderMetadata,
   UnsupportedFunctionalityError,
+  type JSONObject,
+  type LanguageModelV4Message,
+  type LanguageModelV4Prompt,
+  type SharedV4ProviderMetadata,
 } from '@ai-sdk/provider';
 import {
   convertToBase64,
-  isProviderReference,
+  getTopLevelMediaType,
+  isFullMediaType,
   parseProviderOptions,
+  resolveFullMediaType,
   stripFileExtension,
 } from '@ai-sdk/provider-utils';
 import {
   BEDROCK_DOCUMENT_MIME_TYPES,
   BEDROCK_IMAGE_MIME_TYPES,
-  BedrockAssistantMessage,
-  BedrockCachePoint,
-  BedrockDocumentFormat,
-  BedrockDocumentMimeType,
-  BedrockImageFormat,
-  BedrockImageMimeType,
-  BedrockMessages,
-  BedrockSystemMessages,
-  BedrockUserMessage,
-} from './bedrock-api-types';
-import { bedrockReasoningMetadataSchema } from './bedrock-chat-language-model';
-import { bedrockFilePartProviderOptions } from './bedrock-chat-options';
+  type AmazonBedrockAssistantMessage,
+  type AmazonBedrockCachePoint,
+  type AmazonBedrockDocumentFormat,
+  type AmazonBedrockDocumentMimeType,
+  type AmazonBedrockImageFormat,
+  type AmazonBedrockImageMimeType,
+  type AmazonBedrockMessages,
+  type AmazonBedrockSystemMessages,
+  type AmazonBedrockUserMessage,
+} from './amazon-bedrock-api-types';
+import { amazonBedrockFilePartProviderOptions } from './amazon-bedrock-chat-language-model-options';
+import { amazonBedrockReasoningMetadataSchema } from './amazon-bedrock-reasoning-metadata';
 import { normalizeToolCallId } from './normalize-tool-call-id';
 
 function getCachePoint(
   providerMetadata: SharedV4ProviderMetadata | undefined,
-): BedrockCachePoint | undefined {
-  const cachePointConfig = providerMetadata?.bedrock?.cachePoint as
-    | BedrockCachePoint['cachePoint']
+): AmazonBedrockCachePoint | undefined {
+  const cachePointConfig = (providerMetadata?.amazonBedrock?.cachePoint ??
+    providerMetadata?.bedrock?.cachePoint) as
+    | AmazonBedrockCachePoint['cachePoint']
     | undefined;
 
   if (!cachePointConfig) {
@@ -45,26 +48,32 @@ function getCachePoint(
 async function shouldEnableCitations(
   providerMetadata: SharedV4ProviderMetadata | undefined,
 ): Promise<boolean> {
-  const bedrockOptions = await parseProviderOptions({
-    provider: 'bedrock',
-    providerOptions: providerMetadata,
-    schema: bedrockFilePartProviderOptions,
-  });
-
-  return bedrockOptions?.citations?.enabled ?? false;
+  const amazonBedrockOptions =
+    (await parseProviderOptions({
+      provider: 'amazonBedrock',
+      providerOptions: providerMetadata,
+      schema: amazonBedrockFilePartProviderOptions,
+    })) ??
+    (await parseProviderOptions({
+      provider: 'bedrock',
+      providerOptions: providerMetadata,
+      schema: amazonBedrockFilePartProviderOptions,
+    }));
+
+  return amazonBedrockOptions?.citations?.enabled ?? false;
 }
 
-export async function convertToBedrockChatMessages(
+export async function convertToAmazonBedrockChatMessages(
   prompt: LanguageModelV4Prompt,
   isMistral: boolean = false,
 ): Promise<{
-  system: BedrockSystemMessages;
-  messages: BedrockMessages;
+  system: AmazonBedrockSystemMessages;
+  messages: AmazonBedrockMessages;
 }> {
   const blocks = groupIntoBlocks(prompt);
 
-  let system: BedrockSystemMessages = [];
-  const messages: BedrockMessages = [];
+  let system: AmazonBedrockSystemMessages = [];
+  const messages: AmazonBedrockMessages = [];
 
   let documentCounter = 0;
   const generateDocumentName = () => `document-${++documentCounter}`;
@@ -95,7 +104,7 @@ export async function convertToBedrockChatMessages(
 
       case 'user': {
         // combines all user and tool messages in this block into a single message:
-        const bedrockContent: BedrockUserMessage['content'] = [];
+        const amazonBedrockContent: AmazonBedrockUserMessage['content'] = [];
 
         for (const message of block.messages) {
           const { role, content, providerOptions } = message;
@@ -106,58 +115,87 @@ export async function convertToBedrockChatMessages(
 
                 switch (part.type) {
                   case 'text': {
-                    bedrockContent.push({
+                    amazonBedrockContent.push({
                       text: part.text,
                     });
                     break;
                   }
 
                   case 'file': {
-                    if (isProviderReference(part.data)) {
-                      throw new UnsupportedFunctionalityError({
-                        functionality: 'file parts with provider references',
-                      });
-                    }
-
-                    if (part.data instanceof URL) {
-                      // The AI SDK automatically downloads files for user file parts with URLs
-                      throw new UnsupportedFunctionalityError({
-                        functionality: 'File URL data',
-                      });
-                    }
-
-                    if (part.mediaType.startsWith('image/')) {
-                      bedrockContent.push({
-                        image: {
-                          format: getBedrockImageFormat(part.mediaType),
-                          source: { bytes: convertToBase64(part.data) },
-                        },
-                      });
-                    } else {
-                      if (!part.mediaType) {
+                    switch (part.data.type) {
+                      case 'reference': {
                         throw new UnsupportedFunctionalityError({
-                          functionality: 'file without mime type',
-                          message:
-                            'File mime type is required in user message part content',
+                          functionality: 'file parts with provider references',
                         });
                       }
+                      case 'url': {
+                        throw new UnsupportedFunctionalityError({
+                          functionality: 'File URL data',
+                        });
+                      }
+                      case 'text': {
+                        const textMediaType = isFullMediaType(part.mediaType)
+                          ? part.mediaType
+                          : 'text/plain';
+                        const enableCitations = await shouldEnableCitations(
+                          part.providerOptions,
+                        );
+
+                        amazonBedrockContent.push({
+                          document: {
+                            format:
+                              getAmazonBedrockDocumentFormat(textMediaType),
+                            name: part.filename
+                              ? stripFileExtension(part.filename)
+                              : generateDocumentName(),
+                            source: {
+                              bytes: convertToBase64(
+                                new TextEncoder().encode(part.data.text),
+                              ),
+                            },
+                            ...(enableCitations && {
+                              citations: { enabled: true },
+                            }),
+                          },
+                        });
+                        break;
+                      }
+                      case 'data': {
+                        const fullMediaType = resolveFullMediaType({ part });
+
+                        if (getTopLevelMediaType(fullMediaType) === 'image') {
+                          amazonBedrockContent.push({
+                            image: {
+                              format:
+                                getAmazonBedrockImageFormat(fullMediaType),
+                              source: {
+                                bytes: convertToBase64(part.data.data),
+                              },
+                            },
+                          });
+                        } else {
+                          const enableCitations = await shouldEnableCitations(
+                            part.providerOptions,
+                          );
 
-                      const enableCitations = await shouldEnableCitations(
-                        part.providerOptions,
-                      );
-
-                      bedrockContent.push({
-                        document: {
-                          format: getBedrockDocumentFormat(part.mediaType),
-                          name: part.filename
-                            ? stripFileExtension(part.filename)
-                            : generateDocumentName(),
-                          source: { bytes: convertToBase64(part.data) },
-                          ...(enableCitations && {
-                            citations: { enabled: true },
-                          }),
-                        },
-                      });
+                          amazonBedrockContent.push({
+                            document: {
+                              format:
+                                getAmazonBedrockDocumentFormat(fullMediaType),
+                              name: part.filename
+                                ? stripFileExtension(part.filename)
+                                : generateDocumentName(),
+                              source: {
+                                bytes: convertToBase64(part.data.data),
+                              },
+                              ...(enableCitations && {
+                                citations: { enabled: true },
+                              }),
+                            },
+                          });
+                        }
+                        break;
+                      }
                     }
 
                     break;
@@ -188,7 +226,7 @@ export async function convertToBedrockChatMessages(
                             });
                           }
 
-                          const format = getBedrockImageFormat(
+                          const format = getAmazonBedrockImageFormat(
                             contentPart.mediaType,
                           );
 
@@ -225,7 +263,7 @@ export async function convertToBedrockChatMessages(
                     break;
                 }
 
-                bedrockContent.push({
+                amazonBedrockContent.push({
                   toolResult: {
                     toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
                     content: toolResultContent,
@@ -243,18 +281,19 @@ export async function convertToBedrockChatMessages(
 
           const cachePoint = getCachePoint(providerOptions);
           if (cachePoint) {
-            bedrockContent.push(cachePoint);
+            amazonBedrockContent.push(cachePoint);
           }
         }
 
-        messages.push({ role: 'user', content: bedrockContent });
+        messages.push({ role: 'user', content: amazonBedrockContent });
 
         break;
       }
 
       case 'assistant': {
         // combines multiple assistant messages in this block into a single message:
-        const bedrockContent: BedrockAssistantMessage['content'] = [];
+        const amazonBedrockContent: AmazonBedrockAssistantMessage['content'] =
+          [];
 
         for (let j = 0; j < block.messages.length; j++) {
           const message = block.messages[j];
@@ -275,7 +314,7 @@ export async function convertToBedrockChatMessages(
                   break;
                 }
 
-                bedrockContent.push({
+                amazonBedrockContent.push({
                   text:
                     // trim the last text part if it's the last message in the block
                     // because Bedrock does not allow trailing whitespace
@@ -291,16 +330,22 @@ export async function convertToBedrockChatMessages(
               }
 
               case 'reasoning': {
-                const reasoningMetadata = await parseProviderOptions({
-                  provider: 'bedrock',
-                  providerOptions: part.providerOptions,
-                  schema: bedrockReasoningMetadataSchema,
-                });
+                const reasoningMetadata =
+                  (await parseProviderOptions({
+                    provider: 'amazonBedrock',
+                    providerOptions: part.providerOptions,
+                    schema: amazonBedrockReasoningMetadataSchema,
+                  })) ??
+                  (await parseProviderOptions({
+                    provider: 'bedrock',
+                    providerOptions: part.providerOptions,
+                    schema: amazonBedrockReasoningMetadataSchema,
+                  }));
 
                 if (reasoningMetadata?.signature != null) {
                   // do not trim reasoning text when a signature is present:
                   // the signature validates the exact original bytes
-                  bedrockContent.push({
+                  amazonBedrockContent.push({
                     reasoningContent: {
                       reasoningText: {
                         text: part.text,
@@ -309,7 +354,7 @@ export async function convertToBedrockChatMessages(
                     },
                   });
                 } else if (reasoningMetadata?.redactedData != null) {
-                  bedrockContent.push({
+                  amazonBedrockContent.push({
                     reasoningContent: {
                       redactedReasoning: {
                         data: reasoningMetadata.redactedData,
@@ -320,7 +365,7 @@ export async function convertToBedrockChatMessages(
                   // trim the last text part if it's the last message in the block
                   // because Bedrock does not allow trailing whitespace
                   // in pre-filled assistant responses
-                  bedrockContent.push({
+                  amazonBedrockContent.push({
                     reasoningContent: {
                       reasoningText: {
                         text: trimIfLast(
@@ -338,7 +383,7 @@ export async function convertToBedrockChatMessages(
               }
 
               case 'tool-call': {
-                bedrockContent.push({
+                amazonBedrockContent.push({
                   toolUse: {
                     toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
                     name: part.toolName,
@@ -351,11 +396,11 @@ export async function convertToBedrockChatMessages(
           }
           const cachePoint = getCachePoint(message.providerOptions);
           if (cachePoint) {
-            bedrockContent.push(cachePoint);
+            amazonBedrockContent.push(cachePoint);
           }
         }
 
-        messages.push({ role: 'assistant', content: bedrockContent });
+        messages.push({ role: 'assistant', content: amazonBedrockContent });
 
         break;
       }
@@ -370,15 +415,11 @@ export async function convertToBedrockChatMessages(
   return { system, messages };
 }
 
-function getBedrockImageFormat(mimeType?: string): BedrockImageFormat {
-  if (!mimeType) {
-    throw new UnsupportedFunctionalityError({
-      functionality: 'image without mime type',
-      message: 'Image mime type is required in user message part content',
-    });
-  }
-
-  const format = BEDROCK_IMAGE_MIME_TYPES[mimeType as BedrockImageMimeType];
+function getAmazonBedrockImageFormat(
+  mimeType: string,
+): AmazonBedrockImageFormat {
+  const format =
+    BEDROCK_IMAGE_MIME_TYPES[mimeType as AmazonBedrockImageMimeType];
   if (!format) {
     throw new UnsupportedFunctionalityError({
       functionality: `image mime type: ${mimeType}`,
@@ -389,9 +430,11 @@ function getBedrockImageFormat(mimeType?: string): BedrockImageFormat {
   return format;
 }
 
-function getBedrockDocumentFormat(mimeType: string): BedrockDocumentFormat {
+function getAmazonBedrockDocumentFormat(
+  mimeType: string,
+): AmazonBedrockDocumentFormat {
   const format =
-    BEDROCK_DOCUMENT_MIME_TYPES[mimeType as BedrockDocumentMimeType];
+    BEDROCK_DOCUMENT_MIME_TYPES[mimeType as AmazonBedrockDocumentMimeType];
   if (!format) {
     throw new UnsupportedFunctionalityError({
       functionality: `file mime type: ${mimeType}`,

package/src/index.ts

@@ -1,19 +1,26 @@
 export type { AnthropicProviderOptions } from '@ai-sdk/anthropic';
 
-export type { AmazonBedrockEmbeddingModelOptions } from './bedrock-embedding-options';
+export type { AmazonBedrockEmbeddingModelOptions } from './amazon-bedrock-embedding-model-options';
 export type {
-  AmazonBedrockLanguageModelOptions,
-  /** @deprecated Use `AmazonBedrockLanguageModelOptions` instead. */
-  AmazonBedrockLanguageModelOptions as BedrockProviderOptions,
-} from './bedrock-chat-options';
-export { bedrock, createAmazonBedrock } from './bedrock-provider';
+  AmazonBedrockLanguageModelChatOptions,
+  /** @deprecated Use `AmazonBedrockLanguageModelChatOptions` instead. */
+  AmazonBedrockLanguageModelChatOptions as AmazonBedrockLanguageModelOptions,
+  /** @deprecated Use `AmazonBedrockLanguageModelChatOptions` instead. */
+  AmazonBedrockLanguageModelChatOptions as BedrockProviderOptions,
+} from './amazon-bedrock-chat-language-model-options';
+export {
+  amazonBedrock,
+  /** @deprecated Use `amazonBedrock` instead. */
+  amazonBedrock as bedrock,
+  createAmazonBedrock,
+} from './amazon-bedrock-provider';
 export type {
   AmazonBedrockProvider,
   AmazonBedrockProviderSettings,
-} from './bedrock-provider';
+} from './amazon-bedrock-provider';
 export type {
   AmazonBedrockRerankingModelOptions,
   /** @deprecated Use `AmazonBedrockRerankingModelOptions` instead. */
   AmazonBedrockRerankingModelOptions as BedrockRerankingOptions,
-} from './reranking/bedrock-reranking-options';
+} from './reranking/amazon-bedrock-reranking-model-options';
 export { VERSION } from './version';

package/src/inject-fetch-headers.ts

@@ -1,8 +1,8 @@
 import {
-  type FetchFunction,
   getRuntimeEnvironmentUserAgent,
   normalizeHeaders,
   withUserAgentSuffix,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { VERSION } from './version';
 

package/src/{map-bedrock-finish-reason.ts → map-amazon-bedrock-finish-reason.ts}

@@ -1,8 +1,8 @@
-import { LanguageModelV4FinishReason } from '@ai-sdk/provider';
-import { BedrockStopReason } from './bedrock-api-types';
+import type { LanguageModelV4FinishReason } from '@ai-sdk/provider';
+import type { AmazonBedrockStopReason } from './amazon-bedrock-api-types';
 
-export function mapBedrockFinishReason(
-  finishReason: BedrockStopReason,
+export function mapAmazonBedrockFinishReason(
+  finishReason: AmazonBedrockStopReason,
   isJsonResponseFromTool?: boolean,
 ): LanguageModelV4FinishReason['unified'] {
   switch (finishReason) {

package/src/reranking/{bedrock-reranking-api.ts → amazon-bedrock-reranking-api.ts}

@@ -2,12 +2,12 @@ import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 // https://docs.aws.amazon.com/bedrock/latest/APIReference/API_agent-runtime_Rerank.html
-export type BedrockRerankingInput = {
+export type AmazonBedrockRerankingInput = {
   nextToken?: string;
   queries: [{ type: 'TEXT'; textQuery: { text: string } }];
   rerankingConfiguration: {
     type: 'BEDROCK_RERANKING_MODEL';
-    bedrockRerankingConfiguration: {
+    amazonBedrockRerankingConfiguration: {
       modelConfiguration: {
         modelArn: string;
         additionalModelRequestFields?: Record<string, unknown>;
@@ -29,7 +29,7 @@ export type BedrockRerankingInput = {
   }[];
 };
 
-export const bedrockRerankingResponseSchema = lazySchema(() =>
+export const amazonBedrockRerankingResponseSchema = lazySchema(() =>
   zodSchema(
     z.object({
       results: z.array(

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

@@ -2,7 +2,7 @@ import { lazySchema, zodSchema } from '@ai-sdk/provider-utils';
 import { z } from 'zod/v4';
 
 // https://docs.aws.amazon.com/bedrock/latest/userguide/rerank-supported.html
-export type BedrockRerankingModelId =
+export type AmazonBedrockRerankingModelId =
   | 'amazon.rerank-v1:0'
   | 'cohere.rerank-v3-5:0'
   | (string & {});

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

@@ -1,25 +1,24 @@
-import { RerankingModelV4 } from '@ai-sdk/provider';
+import type { RerankingModelV4 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
-  Resolvable,
   combineHeaders,
   createJsonErrorResponseHandler,
   createJsonResponseHandler,
   parseProviderOptions,
   postJsonToApi,
   resolve,
+  type FetchFunction,
+  type Resolvable,
 } from '@ai-sdk/provider-utils';
-import { BedrockErrorSchema } from '../bedrock-error';
+import { AmazonBedrockErrorSchema } from '../amazon-bedrock-error';
 import {
-  BedrockRerankingInput,
-  bedrockRerankingResponseSchema,
-} from './bedrock-reranking-api';
+  amazonBedrockRerankingResponseSchema,
+  type AmazonBedrockRerankingInput,
+} from './amazon-bedrock-reranking-api';
 import {
-  BedrockRerankingModelId,
   amazonBedrockRerankingModelOptionsSchema,
-} from './bedrock-reranking-options';
-
-type BedrockRerankingConfig = {
+  type AmazonBedrockRerankingModelId,
+} from './amazon-bedrock-reranking-model-options';
+type AmazonBedrockRerankingConfig = {
   baseUrl: () => string;
   region: string;
   headers: Resolvable<Record<string, string | undefined>>;
@@ -28,13 +27,13 @@ type BedrockRerankingConfig = {
 
 type DoRerankResponse = Awaited<ReturnType<RerankingModelV4['doRerank']>>;
 
-export class BedrockRerankingModel implements RerankingModelV4 {
+export class AmazonBedrockRerankingModel implements RerankingModelV4 {
   readonly specificationVersion = 'v4';
   readonly provider = 'amazon-bedrock';
 
   constructor(
-    readonly modelId: BedrockRerankingModelId,
-    private readonly config: BedrockRerankingConfig,
+    readonly modelId: AmazonBedrockRerankingModelId,
+    private readonly config: AmazonBedrockRerankingConfig,
   ) {}
 
   async doRerank({
@@ -45,11 +44,19 @@ export class BedrockRerankingModel implements RerankingModelV4 {
     abortSignal,
     providerOptions,
   }: Parameters<RerankingModelV4['doRerank']>[0]): Promise<DoRerankResponse> {
-    const bedrockOptions = await parseProviderOptions({
-      provider: 'bedrock',
-      providerOptions,
-      schema: amazonBedrockRerankingModelOptionsSchema,
-    });
+    // Prefer `amazonBedrock`; fall back to legacy `bedrock` for backward
+    // compatibility.
+    const amazonBedrockOptions =
+      (await parseProviderOptions({
+        provider: 'amazonBedrock',
+        providerOptions,
+        schema: amazonBedrockRerankingModelOptionsSchema,
+      })) ??
+      (await parseProviderOptions({
+        provider: 'bedrock',
+        providerOptions,
+        schema: amazonBedrockRerankingModelOptionsSchema,
+      }));
 
     const {
       value: response,
@@ -61,7 +68,7 @@ export class BedrockRerankingModel implements RerankingModelV4 {
         combineHeaders(await resolve(this.config.headers), headers),
       ),
       body: {
-        nextToken: bedrockOptions?.nextToken,
+        nextToken: amazonBedrockOptions?.nextToken,
         queries: [
           {
             textQuery: { text: query },
@@ -69,11 +76,11 @@ export class BedrockRerankingModel implements RerankingModelV4 {
           },
         ],
         rerankingConfiguration: {
-          bedrockRerankingConfiguration: {
+          amazonBedrockRerankingConfiguration: {
             modelConfiguration: {
               modelArn: `arn:aws:bedrock:${this.config.region}::foundation-model/${this.modelId}`,
               additionalModelRequestFields:
-                bedrockOptions?.additionalModelRequestFields,
+                amazonBedrockOptions?.additionalModelRequestFields,
             },
             numberOfResults: topN,
           },
@@ -92,13 +99,13 @@ export class BedrockRerankingModel implements RerankingModelV4 {
                   jsonDocument: value,
                 },
         })),
-      } satisfies BedrockRerankingInput,
+      } satisfies AmazonBedrockRerankingInput,
       failedResponseHandler: createJsonErrorResponseHandler({
-        errorSchema: BedrockErrorSchema,
+        errorSchema: AmazonBedrockErrorSchema,
         errorToMessage: error => `${error.type}: ${error.message}`,
       }),
       successfulResponseHandler: createJsonResponseHandler(
-        bedrockRerankingResponseSchema,
+        amazonBedrockRerankingResponseSchema,
       ),
       fetch: this.config.fetch,
       abortSignal,