@ai-sdk/amazon-bedrock 5.0.0-beta.45 → 5.0.0-beta.47

package/src/{bedrock-sigv4-fetch.ts → amazon-bedrock-sigv4-fetch.ts}

@@ -8,7 +8,7 @@ import {
 import { AwsV4Signer } from 'aws4fetch';
 import { VERSION } from './version';
 
-export interface BedrockCredentials {
+export interface AmazonBedrockCredentials {
   region: string;
   accessKeyId: string;
   secretAccessKey: string;
@@ -23,13 +23,17 @@ export interface BedrockCredentials {
  * @returns A FetchFunction that signs requests before passing them to the underlying fetch.
  */
 export function createSigV4FetchFunction(
-  getCredentials: () => BedrockCredentials | PromiseLike<BedrockCredentials>,
-  fetch: FetchFunction = globalThis.fetch,
+  getCredentials: () =>
+    | AmazonBedrockCredentials
+    | PromiseLike<AmazonBedrockCredentials>,
+  fetch?: FetchFunction,
 ): FetchFunction {
   return async (
     input: RequestInfo | URL,
     init?: RequestInit,
   ): Promise<Response> => {
+    // avoid caching globalThis.fetch in case it is patched by other libraries
+    const effectiveFetch = fetch ?? globalThis.fetch;
     const request = input instanceof Request ? input : undefined;
     const originalHeaders = combineHeaders(
       normalizeHeaders(request?.headers),
@@ -51,7 +55,7 @@ export function createSigV4FetchFunction(
     const effectiveMethod = init?.method ?? request?.method;
 
     if (effectiveMethod?.toUpperCase() !== 'POST' || !effectiveBody) {
-      return fetch(input, {
+      return effectiveFetch(input, {
         ...init,
         headers: headersWithUserAgent as HeadersInit,
       });
@@ -84,7 +88,7 @@ export function createSigV4FetchFunction(
     // Use the combined headers directly as HeadersInit
     const combinedHeaders = combineHeaders(headersWithUserAgent, signedHeaders);
 
-    return fetch(input, {
+    return effectiveFetch(input, {
       ...init,
       body,
       headers: combinedHeaders as HeadersInit,
@@ -113,12 +117,14 @@ function prepareBodyString(body: BodyInit | undefined): string {
  */
 export function createApiKeyFetchFunction(
   apiKey: string,
-  fetch: FetchFunction = globalThis.fetch,
+  fetch?: FetchFunction,
 ): FetchFunction {
   return async (
     input: RequestInfo | URL,
     init?: RequestInit,
   ): Promise<Response> => {
+    // avoid caching globalThis.fetch in case it is patched by other libraries
+    const effectiveFetch = fetch ?? globalThis.fetch;
     const originalHeaders = normalizeHeaders(init?.headers);
     const headersWithUserAgent = withUserAgentSuffix(
       originalHeaders,
@@ -130,7 +136,7 @@ export function createApiKeyFetchFunction(
       Authorization: `Bearer ${apiKey}`,
     });
 
-    return fetch(input, {
+    return effectiveFetch(input, {
       ...init,
       headers: finalHeaders as HeadersInit,
     });

package/src/anthropic/amazon-bedrock-anthropic-fetch.ts

@@ -0,0 +1,104 @@
+import {
+  convertBase64ToUint8Array,
+  safeParseJSON,
+  type FetchFunction,
+} from '@ai-sdk/provider-utils';
+import { z } from 'zod/v4';
+import { createAmazonBedrockEventStreamDecoder } from '../amazon-bedrock-event-stream-decoder';
+
+const amazonBedrockErrorSchema = z.looseObject({
+  message: z.string().optional(),
+});
+
+export function createAmazonBedrockAnthropicFetch(
+  baseFetch: FetchFunction,
+): FetchFunction {
+  return async (url, options) => {
+    const response = await baseFetch(url, options);
+
+    // Transform Bedrock error responses into Anthropic error format
+    // so that anthropicFailedResponseHandler can extract the message.
+    if (!response.ok) {
+      const text = await response.text();
+      const parsed = await safeParseJSON({
+        text,
+        schema: amazonBedrockErrorSchema,
+      });
+
+      const message =
+        parsed.success && parsed.value.message ? parsed.value.message : text;
+
+      const anthropicError = JSON.stringify({
+        type: 'error',
+        error: { type: 'error', message },
+      });
+
+      return new Response(anthropicError, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      });
+    }
+
+    const contentType = response.headers.get('content-type');
+    if (
+      contentType?.includes('application/vnd.amazon.eventstream') &&
+      response.body != null
+    ) {
+      const transformedBody = transformAmazonBedrockEventStreamToSSE(
+        response.body,
+      );
+
+      return new Response(transformedBody, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: new Headers({
+          ...Object.fromEntries(response.headers.entries()),
+          'content-type': 'text/event-stream',
+        }),
+      });
+    }
+
+    return response;
+  };
+}
+
+function transformAmazonBedrockEventStreamToSSE(
+  body: ReadableStream<Uint8Array>,
+): ReadableStream<Uint8Array> {
+  const textEncoder = new TextEncoder();
+
+  return createAmazonBedrockEventStreamDecoder(
+    body,
+    async (event, controller) => {
+      if (event.messageType === 'event') {
+        if (event.eventType === 'chunk') {
+          const parsed = await safeParseJSON({ text: event.data });
+          if (!parsed.success) {
+            controller.enqueue(textEncoder.encode(`data: ${event.data}\n\n`));
+            return;
+          }
+          const bytes = (parsed.value as { bytes?: string }).bytes;
+          if (bytes) {
+            const anthropicEvent = new TextDecoder().decode(
+              convertBase64ToUint8Array(bytes),
+            );
+            controller.enqueue(
+              textEncoder.encode(`data: ${anthropicEvent}\n\n`),
+            );
+          } else {
+            controller.enqueue(textEncoder.encode(`data: ${event.data}\n\n`));
+          }
+        } else if (event.eventType === 'messageStop') {
+          controller.enqueue(textEncoder.encode('data: [DONE]\n\n'));
+        }
+      } else if (event.messageType === 'exception') {
+        controller.enqueue(
+          textEncoder.encode(
+            `data: ${JSON.stringify({ type: 'error', error: event.data })}\n\n`,
+          ),
+        );
+      }
+    },
+  );
+}

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

@@ -1,4 +1,4 @@
-export type BedrockAnthropicModelId =
+export type AmazonBedrockAnthropicModelId =
   | 'anthropic.claude-opus-4-7'
   | 'anthropic.claude-opus-4-6-v1'
   | 'anthropic.claude-sonnet-4-6-v1'

package/src/anthropic/{bedrock-anthropic-provider.ts → amazon-bedrock-anthropic-provider.ts}

@@ -19,10 +19,10 @@ import {
 import {
   createApiKeyFetchFunction,
   createSigV4FetchFunction,
-  type BedrockCredentials,
-} from '../bedrock-sigv4-fetch';
-import { createBedrockAnthropicFetch } from './bedrock-anthropic-fetch';
-import type { BedrockAnthropicModelId } from './bedrock-anthropic-options';
+  type AmazonBedrockCredentials,
+} from '../amazon-bedrock-sigv4-fetch';
+import { createAmazonBedrockAnthropicFetch } from './amazon-bedrock-anthropic-fetch';
+import type { AmazonBedrockAnthropicModelId } from './amazon-bedrock-anthropic-options';
 import { VERSION } from '../version';
 
 // Bedrock requires newer tool versions than the default Anthropic SDK versions
@@ -53,16 +53,16 @@ const BEDROCK_TOOL_BETA_MAP: Record<string, string> = {
   tool_search_tool_bm25_20251119: 'tool-search-tool-2025-10-19',
 };
 
-export interface BedrockAnthropicProvider extends ProviderV4 {
+export interface AmazonBedrockAnthropicProvider extends ProviderV4 {
   /**
    * Creates a model for text generation.
    */
-  (modelId: BedrockAnthropicModelId): LanguageModelV4;
+  (modelId: AmazonBedrockAnthropicModelId): LanguageModelV4;
 
   /**
    * Creates a model for text generation.
    */
-  languageModel(modelId: BedrockAnthropicModelId): LanguageModelV4;
+  languageModel(modelId: AmazonBedrockAnthropicModelId): LanguageModelV4;
 
   /**
    * Anthropic-specific computer use tool.
@@ -75,7 +75,7 @@ export interface BedrockAnthropicProvider extends ProviderV4 {
   textEmbeddingModel(modelId: string): never;
 }
 
-export interface BedrockAnthropicProviderSettings {
+export interface AmazonBedrockAnthropicProviderSettings {
   /**
    * The AWS region to use for the Bedrock provider. Defaults to the value of the
    * `AWS_REGION` environment variable.
@@ -129,7 +129,9 @@ export interface BedrockAnthropicProviderSettings {
    * credential values to be used instead of the `accessKeyId`, `secretAccessKey`,
    * and `sessionToken` settings.
    */
-  credentialProvider?: () => PromiseLike<Omit<BedrockCredentials, 'region'>>;
+  credentialProvider?: () => PromiseLike<
+    Omit<AmazonBedrockCredentials, 'region'>
+  >;
 }
 
 /**
@@ -137,9 +139,9 @@ export interface BedrockAnthropicProviderSettings {
  * This provider uses the native Anthropic API through Bedrock's InvokeModel endpoint,
  * bypassing the Converse API for better feature compatibility.
  */
-export function createBedrockAnthropic(
-  options: BedrockAnthropicProviderSettings = {},
-): BedrockAnthropicProvider {
+export function createAmazonBedrockAnthropic(
+  options: AmazonBedrockAnthropicProviderSettings = {},
+): AmazonBedrockAnthropicProvider {
   // Check for API key authentication first
   const rawApiKey = loadOptionalSetting({
     settingValue: options.apiKey,
@@ -230,7 +232,7 @@ export function createBedrockAnthropic(
       }, options.fetch);
 
   // Wrap with Bedrock event stream to SSE transformer for streaming support
-  const fetchFunction = createBedrockAnthropicFetch(baseFetchFunction);
+  const fetchFunction = createAmazonBedrockAnthropicFetch(baseFetchFunction);
 
   const getBaseURL = (): string =>
     withoutTrailingSlash(
@@ -248,7 +250,7 @@ export function createBedrockAnthropic(
     return withUserAgentSuffix(baseHeaders, `ai-sdk/amazon-bedrock/${VERSION}`);
   };
 
-  const createChatModel = (modelId: BedrockAnthropicModelId) =>
+  const createChatModel = (modelId: AmazonBedrockAnthropicModelId) =>
     new AnthropicLanguageModel(modelId, {
       provider: 'bedrock.anthropic.messages',
       baseURL: getBaseURL(),
@@ -333,7 +335,7 @@ export function createBedrockAnthropic(
       supportsNativeStructuredOutput: true,
     });
 
-  const provider = function (modelId: BedrockAnthropicModelId) {
+  const provider = function (modelId: AmazonBedrockAnthropicModelId) {
     if (new.target) {
       throw new Error(
         'The Bedrock Anthropic model function cannot be called with the new keyword.',
@@ -364,4 +366,4 @@ export function createBedrockAnthropic(
 /**
  * Default Bedrock Anthropic provider instance.
  */
-export const bedrockAnthropic = createBedrockAnthropic();
+export const amazonBedrockAnthropic = createAmazonBedrockAnthropic();

package/src/anthropic/index.ts

@@ -1,9 +1,21 @@
 export {
-  bedrockAnthropic,
-  createBedrockAnthropic,
-} from './bedrock-anthropic-provider';
+  amazonBedrockAnthropic,
+  /** @deprecated Use `amazonBedrockAnthropic` instead. */
+  amazonBedrockAnthropic as bedrockAnthropic,
+  createAmazonBedrockAnthropic,
+  /** @deprecated Use `createAmazonBedrockAnthropic` instead. */
+  createAmazonBedrockAnthropic as createBedrockAnthropic,
+} from './amazon-bedrock-anthropic-provider';
 export type {
-  BedrockAnthropicProvider,
-  BedrockAnthropicProviderSettings,
-} from './bedrock-anthropic-provider';
-export type { BedrockAnthropicModelId } from './bedrock-anthropic-options';
+  AmazonBedrockAnthropicProvider,
+  /** @deprecated Use `AmazonBedrockAnthropicProvider` instead. */
+  AmazonBedrockAnthropicProvider as BedrockAnthropicProvider,
+  AmazonBedrockAnthropicProviderSettings,
+  /** @deprecated Use `AmazonBedrockAnthropicProviderSettings` instead. */
+  AmazonBedrockAnthropicProviderSettings as BedrockAnthropicProviderSettings,
+} from './amazon-bedrock-anthropic-provider';
+export type {
+  AmazonBedrockAnthropicModelId,
+  /** @deprecated Use `AmazonBedrockAnthropicModelId` instead. */
+  AmazonBedrockAnthropicModelId as BedrockAnthropicModelId,
+} from './amazon-bedrock-anthropic-options';

package/src/{convert-bedrock-usage.ts → convert-amazon-bedrock-usage.ts}

@@ -1,6 +1,6 @@
 import type { LanguageModelV4Usage } from '@ai-sdk/provider';
 
-export type BedrockUsage = {
+export type AmazonBedrockUsage = {
   inputTokens: number;
   outputTokens: number;
   totalTokens?: number;
@@ -8,8 +8,8 @@ export type BedrockUsage = {
   cacheWriteInputTokens?: number | null;
 };
 
-export function convertBedrockUsage(
-  usage: BedrockUsage | undefined | null,
+export function convertAmazonBedrockUsage(
+  usage: AmazonBedrockUsage | undefined | null,
 ): LanguageModelV4Usage {
   if (usage == null) {
     return {

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

@@ -16,25 +16,26 @@ import {
 import {
   BEDROCK_DOCUMENT_MIME_TYPES,
   BEDROCK_IMAGE_MIME_TYPES,
-  type BedrockAssistantMessage,
-  type BedrockCachePoint,
-  type BedrockDocumentFormat,
-  type BedrockDocumentMimeType,
-  type BedrockImageFormat,
-  type BedrockImageMimeType,
-  type BedrockMessages,
-  type BedrockSystemMessages,
-  type BedrockUserMessage,
-} from './bedrock-api-types';
-import { bedrockFilePartProviderOptions } from './bedrock-chat-options';
-import { bedrockReasoningMetadataSchema } from './bedrock-reasoning-metadata';
+  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) {
@@ -47,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}`;
@@ -97,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;
@@ -108,7 +115,7 @@ export async function convertToBedrockChatMessages(
 
                 switch (part.type) {
                   case 'text': {
-                    bedrockContent.push({
+                    amazonBedrockContent.push({
                       text: part.text,
                     });
                     break;
@@ -134,9 +141,10 @@ export async function convertToBedrockChatMessages(
                           part.providerOptions,
                         );
 
-                        bedrockContent.push({
+                        amazonBedrockContent.push({
                           document: {
-                            format: getBedrockDocumentFormat(textMediaType),
+                            format:
+                              getAmazonBedrockDocumentFormat(textMediaType),
                             name: part.filename
                               ? stripFileExtension(part.filename)
                               : generateDocumentName(),
@@ -156,9 +164,10 @@ export async function convertToBedrockChatMessages(
                         const fullMediaType = resolveFullMediaType({ part });
 
                         if (getTopLevelMediaType(fullMediaType) === 'image') {
-                          bedrockContent.push({
+                          amazonBedrockContent.push({
                             image: {
-                              format: getBedrockImageFormat(fullMediaType),
+                              format:
+                                getAmazonBedrockImageFormat(fullMediaType),
                               source: {
                                 bytes: convertToBase64(part.data.data),
                               },
@@ -169,9 +178,10 @@ export async function convertToBedrockChatMessages(
                             part.providerOptions,
                           );
 
-                          bedrockContent.push({
+                          amazonBedrockContent.push({
                             document: {
-                              format: getBedrockDocumentFormat(fullMediaType),
+                              format:
+                                getAmazonBedrockDocumentFormat(fullMediaType),
                               name: part.filename
                                 ? stripFileExtension(part.filename)
                                 : generateDocumentName(),
@@ -216,7 +226,7 @@ export async function convertToBedrockChatMessages(
                             });
                           }
 
-                          const format = getBedrockImageFormat(
+                          const format = getAmazonBedrockImageFormat(
                             contentPart.mediaType,
                           );
 
@@ -253,7 +263,7 @@ export async function convertToBedrockChatMessages(
                     break;
                 }
 
-                bedrockContent.push({
+                amazonBedrockContent.push({
                   toolResult: {
                     toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
                     content: toolResultContent,
@@ -271,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];
@@ -303,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
@@ -319,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,
@@ -337,18 +354,29 @@ export async function convertToBedrockChatMessages(
                     },
                   });
                 } else if (reasoningMetadata?.redactedData != null) {
-                  bedrockContent.push({
+                  amazonBedrockContent.push({
                     reasoningContent: {
                       redactedReasoning: {
                         data: reasoningMetadata.redactedData,
                       },
                     },
                   });
-                } else {
-                  // trim the last text part if it's the last message in the block
-                  // because Bedrock does not allow trailing whitespace
+                } else if (
+                  part.providerOptions == null ||
+                  Object.keys(part.providerOptions).every(
+                    k => k === 'bedrock' || k === 'amazonBedrock',
+                  )
+                ) {
+                  // No foreign-provider metadata — preserve text. This covers
+                  // the prefill case where the caller hand-crafts a reasoning
+                  // block without a signature. Forwarding reasoning that was
+                  // signed by a different provider (e.g. anthropic) would
+                  // cause Bedrock to reject with
+                  // `thinking.signature: Field required`, so we drop those.
+                  // 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(
@@ -366,7 +394,7 @@ export async function convertToBedrockChatMessages(
               }
 
               case 'tool-call': {
-                bedrockContent.push({
+                amazonBedrockContent.push({
                   toolUse: {
                     toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
                     name: part.toolName,
@@ -379,11 +407,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;
       }
@@ -398,8 +426,11 @@ export async function convertToBedrockChatMessages(
   return { system, messages };
 }
 
-function getBedrockImageFormat(mimeType: string): BedrockImageFormat {
-  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}`,
@@ -410,9 +441,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';