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

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

@@ -1,5 +1,5 @@
 import { anthropicTools } from '@ai-sdk/anthropic/internal';
-import {
+import type {
   EmbeddingModelV4,
   ImageModelV4,
   LanguageModelV4,
@@ -7,26 +7,26 @@ import {
   RerankingModelV4,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
   generateId,
   loadOptionalSetting,
   loadSetting,
   withoutTrailingSlash,
   withUserAgentSuffix,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
-import { BedrockChatLanguageModel } from './bedrock-chat-language-model';
-import { BedrockChatModelId } from './bedrock-chat-options';
-import { BedrockEmbeddingModel } from './bedrock-embedding-model';
-import { BedrockEmbeddingModelId } from './bedrock-embedding-options';
-import { BedrockImageModel } from './bedrock-image-model';
-import { BedrockImageModelId } from './bedrock-image-settings';
+import { AmazonBedrockChatLanguageModel } from './amazon-bedrock-chat-language-model';
+import type { AmazonBedrockChatModelId } from './amazon-bedrock-chat-language-model-options';
+import { AmazonBedrockEmbeddingModel } from './amazon-bedrock-embedding-model';
+import type { AmazonBedrockEmbeddingModelId } from './amazon-bedrock-embedding-model-options';
+import { AmazonBedrockImageModel } from './amazon-bedrock-image-model';
+import type { AmazonBedrockImageModelId } from './amazon-bedrock-image-settings';
 import {
-  BedrockCredentials,
   createApiKeyFetchFunction,
   createSigV4FetchFunction,
-} from './bedrock-sigv4-fetch';
-import { BedrockRerankingModel } from './reranking/bedrock-reranking-model';
-import { BedrockRerankingModelId } from './reranking/bedrock-reranking-options';
+  type AmazonBedrockCredentials,
+} from './amazon-bedrock-sigv4-fetch';
+import { AmazonBedrockRerankingModel } from './reranking/amazon-bedrock-reranking-model';
+import type { AmazonBedrockRerankingModelId } from './reranking/amazon-bedrock-reranking-model-options';
 import { VERSION } from './version';
 
 export interface AmazonBedrockProviderSettings {
@@ -74,8 +74,10 @@ export interface AmazonBedrockProviderSettings {
   secretAccessKey?: string;
 
   /**
-   * The AWS session token to use for the Bedrock provider. Defaults to the value of the
-   * `AWS_SESSION_TOKEN` environment variable.
+   * The AWS session token to use for the Bedrock provider. When `accessKeyId` and
+   * `secretAccessKey` are both passed explicitly as options, only this field is used
+   * If either access key field is omitted and resolved from the environment, the
+   * session token also falls back to `AWS_SESSION_TOKEN` when not set here.
    */
   sessionToken?: string;
 
@@ -101,56 +103,58 @@ export interface AmazonBedrockProviderSettings {
    * credential values to be used instead of the `accessKeyId`, `secretAccessKey`,
    * and `sessionToken` settings.
    */
-  credentialProvider?: () => PromiseLike<Omit<BedrockCredentials, 'region'>>;
+  credentialProvider?: () => PromiseLike<
+    Omit<AmazonBedrockCredentials, 'region'>
+  >;
 
   // for testing
   generateId?: () => string;
 }
 
 export interface AmazonBedrockProvider extends ProviderV4 {
-  (modelId: BedrockChatModelId): LanguageModelV4;
+  (modelId: AmazonBedrockChatModelId): LanguageModelV4;
 
-  languageModel(modelId: BedrockChatModelId): LanguageModelV4;
+  languageModel(modelId: AmazonBedrockChatModelId): LanguageModelV4;
 
   /**
    * Creates a model for text embeddings.
    */
-  embedding(modelId: BedrockEmbeddingModelId): EmbeddingModelV4;
+  embedding(modelId: AmazonBedrockEmbeddingModelId): EmbeddingModelV4;
 
   /**
    * Creates a model for text embeddings.
    */
-  embeddingModel(modelId: BedrockEmbeddingModelId): EmbeddingModelV4;
+  embeddingModel(modelId: AmazonBedrockEmbeddingModelId): EmbeddingModelV4;
 
   /**
    * @deprecated Use `embedding` instead.
    */
-  textEmbedding(modelId: BedrockEmbeddingModelId): EmbeddingModelV4;
+  textEmbedding(modelId: AmazonBedrockEmbeddingModelId): EmbeddingModelV4;
 
   /**
    * @deprecated Use `embeddingModel` instead.
    */
-  textEmbeddingModel(modelId: BedrockEmbeddingModelId): EmbeddingModelV4;
+  textEmbeddingModel(modelId: AmazonBedrockEmbeddingModelId): EmbeddingModelV4;
 
   /**
    * Creates a model for image generation.
    */
-  image(modelId: BedrockImageModelId): ImageModelV4;
+  image(modelId: AmazonBedrockImageModelId): ImageModelV4;
 
   /**
    * Creates a model for image generation.
    */
-  imageModel(modelId: BedrockImageModelId): ImageModelV4;
+  imageModel(modelId: AmazonBedrockImageModelId): ImageModelV4;
 
   /**
    * Creates a model for reranking documents.
    */
-  reranking(modelId: BedrockRerankingModelId): RerankingModelV4;
+  reranking(modelId: AmazonBedrockRerankingModelId): RerankingModelV4;
 
   /**
    * Creates a model for reranking documents.
    */
-  rerankingModel(modelId: BedrockRerankingModelId): RerankingModelV4;
+  rerankingModel(modelId: AmazonBedrockRerankingModelId): RerankingModelV4;
 
   /**
    * Anthropic-specific tools that can be used with Anthropic models on Bedrock.
@@ -221,10 +225,13 @@ export function createAmazonBedrock(
               environmentVariableName: 'AWS_SECRET_ACCESS_KEY',
               description: 'AWS secret access key',
             }),
-            sessionToken: loadOptionalSetting({
-              settingValue: options.sessionToken,
-              environmentVariableName: 'AWS_SESSION_TOKEN',
-            }),
+            sessionToken:
+              options.accessKeyId != null && options.secretAccessKey != null
+                ? options.sessionToken
+                : loadOptionalSetting({
+                    settingValue: options.sessionToken,
+                    environmentVariableName: 'AWS_SESSION_TOKEN',
+                  }),
           };
         } catch (error) {
           // Provide helpful error message for missing AWS credentials
@@ -263,7 +270,7 @@ export function createAmazonBedrock(
     return withUserAgentSuffix(baseHeaders, `ai-sdk/amazon-bedrock/${VERSION}`);
   };
 
-  const getBedrockRuntimeBaseUrl = (): string =>
+  const getAmazonBedrockRuntimeBaseUrl = (): string =>
     withoutTrailingSlash(
       options.baseURL ??
         `https://bedrock-runtime.${loadSetting({
@@ -274,7 +281,7 @@ export function createAmazonBedrock(
         })}.amazonaws.com`,
     ) ?? `https://bedrock-runtime.us-east-1.amazonaws.com`;
 
-  const getBedrockAgentRuntimeBaseUrl = (): string =>
+  const getAmazonBedrockAgentRuntimeBaseUrl = (): string =>
     withoutTrailingSlash(
       options.baseURL ??
         `https://bedrock-agent-runtime.${loadSetting({
@@ -285,15 +292,15 @@ export function createAmazonBedrock(
         })}.amazonaws.com`,
     ) ?? `https://bedrock-agent-runtime.us-west-2.amazonaws.com`;
 
-  const createChatModel = (modelId: BedrockChatModelId) =>
-    new BedrockChatLanguageModel(modelId, {
-      baseUrl: getBedrockRuntimeBaseUrl,
+  const createChatModel = (modelId: AmazonBedrockChatModelId) =>
+    new AmazonBedrockChatLanguageModel(modelId, {
+      baseUrl: getAmazonBedrockRuntimeBaseUrl,
       headers: getHeaders,
       fetch: fetchFunction,
       generateId,
     });
 
-  const provider = function (modelId: BedrockChatModelId) {
+  const provider = function (modelId: AmazonBedrockChatModelId) {
     if (new.target) {
       throw new Error(
         'The Amazon Bedrock model function cannot be called with the new keyword.',
@@ -303,23 +310,23 @@ export function createAmazonBedrock(
     return createChatModel(modelId);
   };
 
-  const createEmbeddingModel = (modelId: BedrockEmbeddingModelId) =>
-    new BedrockEmbeddingModel(modelId, {
-      baseUrl: getBedrockRuntimeBaseUrl,
+  const createEmbeddingModel = (modelId: AmazonBedrockEmbeddingModelId) =>
+    new AmazonBedrockEmbeddingModel(modelId, {
+      baseUrl: getAmazonBedrockRuntimeBaseUrl,
       headers: getHeaders,
       fetch: fetchFunction,
     });
 
-  const createImageModel = (modelId: BedrockImageModelId) =>
-    new BedrockImageModel(modelId, {
-      baseUrl: getBedrockRuntimeBaseUrl,
+  const createImageModel = (modelId: AmazonBedrockImageModelId) =>
+    new AmazonBedrockImageModel(modelId, {
+      baseUrl: getAmazonBedrockRuntimeBaseUrl,
       headers: getHeaders,
       fetch: fetchFunction,
     });
 
-  const createRerankingModel = (modelId: BedrockRerankingModelId) =>
-    new BedrockRerankingModel(modelId, {
-      baseUrl: getBedrockAgentRuntimeBaseUrl,
+  const createRerankingModel = (modelId: AmazonBedrockRerankingModelId) =>
+    new AmazonBedrockRerankingModel(modelId, {
+      baseUrl: getAmazonBedrockAgentRuntimeBaseUrl,
       region: loadSetting({
         settingValue: options.region,
         settingName: 'region',
@@ -346,6 +353,6 @@ export function createAmazonBedrock(
 }
 
 /**
- * Default Bedrock provider instance.
+ * Default Amazon Bedrock provider instance.
  */
-export const bedrock = createAmazonBedrock();
+export const amazonBedrock = createAmazonBedrock();

package/src/amazon-bedrock-reasoning-metadata.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod/v4';
+
+export const amazonBedrockReasoningMetadataSchema = z.object({
+  signature: z.string().optional(),
+  redactedData: z.string().optional(),
+});
+
+export type AmazonBedrockReasoningMetadata = z.infer<
+  typeof amazonBedrockReasoningMetadataSchema
+>;

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

@@ -1,14 +1,14 @@
 import {
-  FetchFunction,
   combineHeaders,
   normalizeHeaders,
   withUserAgentSuffix,
   getRuntimeEnvironmentUserAgent,
+  type FetchFunction,
 } from '@ai-sdk/provider-utils';
 import { AwsV4Signer } from 'aws4fetch';
 import { VERSION } from './version';
 
-export interface BedrockCredentials {
+export interface AmazonBedrockCredentials {
   region: string;
   accessKeyId: string;
   secretAccessKey: string;
@@ -23,7 +23,9 @@ export interface BedrockCredentials {
  * @returns A FetchFunction that signs requests before passing them to the underlying fetch.
  */
 export function createSigV4FetchFunction(
-  getCredentials: () => BedrockCredentials | PromiseLike<BedrockCredentials>,
+  getCredentials: () =>
+    | AmazonBedrockCredentials
+    | PromiseLike<AmazonBedrockCredentials>,
   fetch: FetchFunction = globalThis.fetch,
 ): FetchFunction {
   return async (

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}

@@ -1,28 +1,28 @@
 import {
-  LanguageModelV4,
   NoSuchModelError,
-  ProviderV4,
+  type LanguageModelV4,
+  type ProviderV4,
 } from '@ai-sdk/provider';
 import {
-  FetchFunction,
   loadOptionalSetting,
   loadSetting,
-  Resolvable,
   resolve,
   withoutTrailingSlash,
   withUserAgentSuffix,
+  type FetchFunction,
+  type Resolvable,
 } from '@ai-sdk/provider-utils';
 import {
   anthropicTools,
   AnthropicLanguageModel,
 } from '@ai-sdk/anthropic/internal';
 import {
-  BedrockCredentials,
   createApiKeyFetchFunction,
   createSigV4FetchFunction,
-} from '../bedrock-sigv4-fetch';
-import { createBedrockAnthropicFetch } from './bedrock-anthropic-fetch';
-import { 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 { LanguageModelV4Usage } from '@ai-sdk/provider';
+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 {