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

package/dist/index.js

@@ -24,7 +24,7 @@ import {
   WORKFLOW_DESERIALIZE
 } from "@ai-sdk/provider-utils";
 import { getModelCapabilities } from "@ai-sdk/anthropic/internal";
-import { z as z3 } from "zod/v4";
+import { z as z4 } from "zod/v4";
 
 // src/bedrock-api-types.ts
 var BEDROCK_STOP_REASONS = [
@@ -384,11 +384,20 @@ import {
 } from "@ai-sdk/provider";
 import {
   convertToBase64,
-  isProviderReference,
+  getTopLevelMediaType,
+  isFullMediaType,
   parseProviderOptions,
+  resolveFullMediaType,
   stripFileExtension
 } from "@ai-sdk/provider-utils";
 
+// src/bedrock-reasoning-metadata.ts
+import { z as z3 } from "zod/v4";
+var bedrockReasoningMetadataSchema = z3.object({
+  signature: z3.string().optional(),
+  redactedData: z3.string().optional()
+});
+
 // src/normalize-tool-call-id.ts
 function isMistralModel(modelId) {
   return modelId.includes("mistral.");
@@ -462,43 +471,68 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
                     break;
                   }
                   case "file": {
-                    if (isProviderReference(part.data)) {
-                      throw new UnsupportedFunctionalityError2({
-                        functionality: "file parts with provider references"
-                      });
-                    }
-                    if (part.data instanceof URL) {
-                      throw new UnsupportedFunctionalityError2({
-                        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 UnsupportedFunctionalityError2({
-                          functionality: "file without mime type",
-                          message: "File mime type is required in user message part content"
+                          functionality: "file parts with provider references"
                         });
                       }
-                      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 }
+                      case "url": {
+                        throw new UnsupportedFunctionalityError2({
+                          functionality: "File URL data"
+                        });
+                      }
+                      case "text": {
+                        const textMediaType = isFullMediaType(part.mediaType) ? part.mediaType : "text/plain";
+                        const enableCitations = await shouldEnableCitations(
+                          part.providerOptions
+                        );
+                        bedrockContent.push({
+                          document: {
+                            format: getBedrockDocumentFormat(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") {
+                          bedrockContent.push({
+                            image: {
+                              format: getBedrockImageFormat(fullMediaType),
+                              source: {
+                                bytes: convertToBase64(part.data.data)
+                              }
+                            }
+                          });
+                        } else {
+                          const enableCitations = await shouldEnableCitations(
+                            part.providerOptions
+                          );
+                          bedrockContent.push({
+                            document: {
+                              format: getBedrockDocumentFormat(fullMediaType),
+                              name: part.filename ? stripFileExtension(part.filename) : generateDocumentName(),
+                              source: {
+                                bytes: convertToBase64(part.data.data)
+                              },
+                              ...enableCitations && {
+                                citations: { enabled: true }
+                              }
+                            }
+                          });
                         }
-                      });
+                        break;
+                      }
                     }
                     break;
                   }
@@ -682,12 +716,6 @@ async function convertToBedrockChatMessages(prompt, isMistral = false) {
   return { system, messages };
 }
 function getBedrockImageFormat(mimeType) {
-  if (!mimeType) {
-    throw new UnsupportedFunctionalityError2({
-      functionality: "image without mime type",
-      message: "Image mime type is required in user message part content"
-    });
-  }
   const format = BEDROCK_IMAGE_MIME_TYPES[mimeType];
   if (!format) {
     throw new UnsupportedFunctionalityError2({
@@ -1517,116 +1545,112 @@ var BedrockChatLanguageModel = class _BedrockChatLanguageModel {
     return `${this.config.baseUrl()}/model/${encodedModelId}`;
   }
 };
-var BedrockStopReasonSchema = z3.union([
-  z3.enum(BEDROCK_STOP_REASONS),
-  z3.string()
+var BedrockStopReasonSchema = z4.union([
+  z4.enum(BEDROCK_STOP_REASONS),
+  z4.string()
 ]);
-var BedrockAdditionalModelResponseFieldsSchema = z3.object({
-  delta: z3.object({
-    stop_sequence: z3.string().nullish()
+var BedrockAdditionalModelResponseFieldsSchema = z4.object({
+  delta: z4.object({
+    stop_sequence: z4.string().nullish()
   }).nullish()
-}).catchall(z3.unknown());
-var BedrockToolUseSchema = z3.object({
-  toolUseId: z3.string(),
-  name: z3.string(),
-  input: z3.unknown()
+}).catchall(z4.unknown());
+var BedrockToolUseSchema = z4.object({
+  toolUseId: z4.string(),
+  name: z4.string(),
+  input: z4.unknown()
 });
-var BedrockReasoningTextSchema = z3.object({
-  signature: z3.string().nullish(),
-  text: z3.string()
+var BedrockReasoningTextSchema = z4.object({
+  signature: z4.string().nullish(),
+  text: z4.string()
 });
-var BedrockRedactedReasoningSchema = z3.object({
-  data: z3.string()
+var BedrockRedactedReasoningSchema = z4.object({
+  data: z4.string()
 });
-var BedrockResponseSchema = z3.object({
-  metrics: z3.object({
-    latencyMs: z3.number()
+var BedrockResponseSchema = z4.object({
+  metrics: z4.object({
+    latencyMs: z4.number()
   }).nullish(),
-  output: z3.object({
-    message: z3.object({
-      content: z3.array(
-        z3.object({
-          text: z3.string().nullish(),
+  output: z4.object({
+    message: z4.object({
+      content: z4.array(
+        z4.object({
+          text: z4.string().nullish(),
           toolUse: BedrockToolUseSchema.nullish(),
-          reasoningContent: z3.union([
-            z3.object({
+          reasoningContent: z4.union([
+            z4.object({
               reasoningText: BedrockReasoningTextSchema
             }),
-            z3.object({
+            z4.object({
               redactedReasoning: BedrockRedactedReasoningSchema
             })
           ]).nullish()
         })
       ),
-      role: z3.string()
+      role: z4.string()
     })
   }),
   stopReason: BedrockStopReasonSchema,
   additionalModelResponseFields: BedrockAdditionalModelResponseFieldsSchema.nullish(),
-  trace: z3.unknown().nullish(),
-  performanceConfig: z3.object({ latency: z3.string() }).nullish(),
-  serviceTier: z3.object({ type: z3.string() }).nullish(),
-  usage: z3.object({
-    inputTokens: z3.number(),
-    outputTokens: z3.number(),
-    totalTokens: z3.number(),
-    cacheReadInputTokens: z3.number().nullish(),
-    cacheWriteInputTokens: z3.number().nullish(),
-    cacheDetails: z3.array(z3.object({ inputTokens: z3.number(), ttl: z3.string() })).nullish()
+  trace: z4.unknown().nullish(),
+  performanceConfig: z4.object({ latency: z4.string() }).nullish(),
+  serviceTier: z4.object({ type: z4.string() }).nullish(),
+  usage: z4.object({
+    inputTokens: z4.number(),
+    outputTokens: z4.number(),
+    totalTokens: z4.number(),
+    cacheReadInputTokens: z4.number().nullish(),
+    cacheWriteInputTokens: z4.number().nullish(),
+    cacheDetails: z4.array(z4.object({ inputTokens: z4.number(), ttl: z4.string() })).nullish()
   })
 });
-var BedrockStreamSchema = z3.object({
-  contentBlockDelta: z3.object({
-    contentBlockIndex: z3.number(),
-    delta: z3.union([
-      z3.object({ text: z3.string() }),
-      z3.object({ toolUse: z3.object({ input: z3.string() }) }),
-      z3.object({
-        reasoningContent: z3.object({ text: z3.string() })
+var BedrockStreamSchema = z4.object({
+  contentBlockDelta: z4.object({
+    contentBlockIndex: z4.number(),
+    delta: z4.union([
+      z4.object({ text: z4.string() }),
+      z4.object({ toolUse: z4.object({ input: z4.string() }) }),
+      z4.object({
+        reasoningContent: z4.object({ text: z4.string() })
       }),
-      z3.object({
-        reasoningContent: z3.object({
-          signature: z3.string()
+      z4.object({
+        reasoningContent: z4.object({
+          signature: z4.string()
         })
       }),
-      z3.object({
-        reasoningContent: z3.object({ data: z3.string() })
+      z4.object({
+        reasoningContent: z4.object({ data: z4.string() })
       })
     ]).nullish()
   }).nullish(),
-  contentBlockStart: z3.object({
-    contentBlockIndex: z3.number(),
-    start: z3.object({
+  contentBlockStart: z4.object({
+    contentBlockIndex: z4.number(),
+    start: z4.object({
       toolUse: BedrockToolUseSchema.nullish()
     }).nullish()
   }).nullish(),
-  contentBlockStop: z3.object({
-    contentBlockIndex: z3.number()
+  contentBlockStop: z4.object({
+    contentBlockIndex: z4.number()
   }).nullish(),
-  internalServerException: z3.record(z3.string(), z3.unknown()).nullish(),
-  messageStop: z3.object({
+  internalServerException: z4.record(z4.string(), z4.unknown()).nullish(),
+  messageStop: z4.object({
     additionalModelResponseFields: BedrockAdditionalModelResponseFieldsSchema.nullish(),
     stopReason: BedrockStopReasonSchema
   }).nullish(),
-  metadata: z3.object({
-    trace: z3.unknown().nullish(),
-    performanceConfig: z3.object({ latency: z3.string() }).nullish(),
-    serviceTier: z3.object({ type: z3.string() }).nullish(),
-    usage: z3.object({
-      cacheReadInputTokens: z3.number().nullish(),
-      cacheWriteInputTokens: z3.number().nullish(),
-      cacheDetails: z3.array(z3.object({ inputTokens: z3.number(), ttl: z3.string() })).nullish(),
-      inputTokens: z3.number(),
-      outputTokens: z3.number()
+  metadata: z4.object({
+    trace: z4.unknown().nullish(),
+    performanceConfig: z4.object({ latency: z4.string() }).nullish(),
+    serviceTier: z4.object({ type: z4.string() }).nullish(),
+    usage: z4.object({
+      cacheReadInputTokens: z4.number().nullish(),
+      cacheWriteInputTokens: z4.number().nullish(),
+      cacheDetails: z4.array(z4.object({ inputTokens: z4.number(), ttl: z4.string() })).nullish(),
+      inputTokens: z4.number(),
+      outputTokens: z4.number()
     }).nullish()
   }).nullish(),
-  modelStreamErrorException: z3.record(z3.string(), z3.unknown()).nullish(),
-  throttlingException: z3.record(z3.string(), z3.unknown()).nullish(),
-  validationException: z3.record(z3.string(), z3.unknown()).nullish()
-});
-var bedrockReasoningMetadataSchema = z3.object({
-  signature: z3.string().optional(),
-  redactedData: z3.string().optional()
+  modelStreamErrorException: z4.record(z4.string(), z4.unknown()).nullish(),
+  throttlingException: z4.record(z4.string(), z4.unknown()).nullish(),
+  validationException: z4.record(z4.string(), z4.unknown()).nullish()
 });
 var bedrockReasoningEffortMap = {
   minimal: "low",
@@ -1712,29 +1736,29 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/bedrock-embedding-options.ts
-import { z as z4 } from "zod/v4";
-var amazonBedrockEmbeddingModelOptionsSchema = z4.object({
+import { z as z5 } from "zod/v4";
+var amazonBedrockEmbeddingModelOptionsSchema = z5.object({
   /**
    * The number of dimensions the resulting output embeddings should have (defaults to 1024).
    * Only supported in amazon.titan-embed-text-v2:0.
    */
-  dimensions: z4.union([z4.literal(1024), z4.literal(512), z4.literal(256)]).optional(),
+  dimensions: z5.union([z5.literal(1024), z5.literal(512), z5.literal(256)]).optional(),
   /**
    * Flag indicating whether or not to normalize the output embeddings. Defaults to true.
    * Only supported in amazon.titan-embed-text-v2:0.
    */
-  normalize: z4.boolean().optional(),
+  normalize: z5.boolean().optional(),
   /**
    * The number of dimensions for Nova embedding models (defaults to 1024).
    * Supported values: 256, 384, 1024, 3072.
    * Only supported in amazon.nova-* embedding models.
    */
-  embeddingDimension: z4.union([z4.literal(256), z4.literal(384), z4.literal(1024), z4.literal(3072)]).optional(),
+  embeddingDimension: z5.union([z5.literal(256), z5.literal(384), z5.literal(1024), z5.literal(3072)]).optional(),
   /**
    * The purpose of the embedding. Defaults to 'GENERIC_INDEX'.
    * Only supported in amazon.nova-* embedding models.
    */
-  embeddingPurpose: z4.enum([
+  embeddingPurpose: z5.enum([
     "GENERIC_INDEX",
     "TEXT_RETRIEVAL",
     "IMAGE_RETRIEVAL",
@@ -1750,21 +1774,21 @@ var amazonBedrockEmbeddingModelOptionsSchema = z4.object({
    * Common values: `search_document`, `search_query`, `classification`, `clustering`.
    * If not set, the provider defaults to `search_query`.
    */
-  inputType: z4.enum(["search_document", "search_query", "classification", "clustering"]).optional(),
+  inputType: z5.enum(["search_document", "search_query", "classification", "clustering"]).optional(),
   /**
    * Truncation behavior when input exceeds the model's context length.
    * Supported in Cohere and Nova embedding models. Defaults to 'END' for Nova models.
    */
-  truncate: z4.enum(["NONE", "START", "END"]).optional(),
+  truncate: z5.enum(["NONE", "START", "END"]).optional(),
   /**
    * The number of dimensions the resulting output embeddings should have (defaults to 1536).
    * Only supported in cohere.embed-v4:0 and newer Cohere embedding models.
    */
-  outputDimension: z4.union([z4.literal(256), z4.literal(512), z4.literal(1024), z4.literal(1536)]).optional()
+  outputDimension: z5.union([z5.literal(256), z5.literal(512), z5.literal(1024), z5.literal(1536)]).optional()
 });
 
 // src/bedrock-embedding-model.ts
-import { z as z5 } from "zod/v4";
+import { z as z6 } from "zod/v4";
 var BedrockEmbeddingModel = class _BedrockEmbeddingModel {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -1872,30 +1896,30 @@ var BedrockEmbeddingModel = class _BedrockEmbeddingModel {
     };
   }
 };
-var BedrockEmbeddingResponseSchema = z5.union([
+var BedrockEmbeddingResponseSchema = z6.union([
   // Titan-style response
-  z5.object({
-    embedding: z5.array(z5.number()),
-    inputTextTokenCount: z5.number()
+  z6.object({
+    embedding: z6.array(z6.number()),
+    inputTextTokenCount: z6.number()
   }),
   // Nova-style response
-  z5.object({
-    embeddings: z5.array(
-      z5.object({
-        embeddingType: z5.string(),
-        embedding: z5.array(z5.number())
+  z6.object({
+    embeddings: z6.array(
+      z6.object({
+        embeddingType: z6.string(),
+        embedding: z6.array(z6.number())
       })
     ),
-    inputTokenCount: z5.number().optional()
+    inputTokenCount: z6.number().optional()
   }),
   // Cohere v3-style response
-  z5.object({
-    embeddings: z5.array(z5.array(z5.number()))
+  z6.object({
+    embeddings: z6.array(z6.array(z6.number()))
   }),
   // Cohere v4-style response
-  z5.object({
-    embeddings: z5.object({
-      float: z5.array(z5.array(z5.number()))
+  z6.object({
+    embeddings: z6.object({
+      float: z6.array(z6.array(z6.number()))
     })
   })
 ]);
@@ -1919,7 +1943,7 @@ var modelMaxImagesPerCall = {
 };
 
 // src/bedrock-image-model.ts
-import { z as z6 } from "zod/v4";
+import { z as z7 } from "zod/v4";
 var BedrockImageModel = class _BedrockImageModel {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -2117,16 +2141,16 @@ function getBase64Data(file) {
   }
   return file.data;
 }
-var bedrockImageResponseSchema = z6.object({
+var bedrockImageResponseSchema = z7.object({
   // Normal successful response
-  images: z6.array(z6.string()).optional(),
+  images: z7.array(z7.string()).optional(),
   // Moderation response fields
-  id: z6.string().optional(),
-  status: z6.string().optional(),
-  result: z6.unknown().optional(),
-  progress: z6.unknown().optional(),
-  details: z6.record(z6.string(), z6.unknown()).optional(),
-  preview: z6.unknown().optional()
+  id: z7.string().optional(),
+  status: z7.string().optional(),
+  result: z7.unknown().optional(),
+  progress: z7.unknown().optional(),
+  details: z7.record(z7.string(), z7.unknown()).optional(),
+  preview: z7.unknown().optional()
 });
 
 // src/bedrock-sigv4-fetch.ts
@@ -2139,7 +2163,7 @@ import {
 import { AwsV4Signer } from "aws4fetch";
 
 // src/version.ts
-var VERSION = true ? "5.0.0-beta.44" : "0.0.0-test";
+var VERSION = true ? "5.0.0-beta.45" : "0.0.0-test";
 
 // src/bedrock-sigv4-fetch.ts
 function createSigV4FetchFunction(getCredentials, fetch = globalThis.fetch) {
@@ -2234,35 +2258,35 @@ import {
 
 // src/reranking/bedrock-reranking-api.ts
 import { lazySchema, zodSchema } from "@ai-sdk/provider-utils";
-import { z as z7 } from "zod/v4";
+import { z as z8 } from "zod/v4";
 var bedrockRerankingResponseSchema = lazySchema(
   () => zodSchema(
-    z7.object({
-      results: z7.array(
-        z7.object({
-          index: z7.number(),
-          relevanceScore: z7.number()
+    z8.object({
+      results: z8.array(
+        z8.object({
+          index: z8.number(),
+          relevanceScore: z8.number()
         })
       ),
-      nextToken: z7.string().optional()
+      nextToken: z8.string().optional()
     })
   )
 );
 
 // src/reranking/bedrock-reranking-options.ts
 import { lazySchema as lazySchema2, zodSchema as zodSchema2 } from "@ai-sdk/provider-utils";
-import { z as z8 } from "zod/v4";
+import { z as z9 } from "zod/v4";
 var amazonBedrockRerankingModelOptionsSchema = lazySchema2(
   () => zodSchema2(
-    z8.object({
+    z9.object({
       /**
        * If the total number of results was greater than could fit in a response, a token is returned in the nextToken field. You can enter that token in this field to return the next batch of results.
        */
-      nextToken: z8.string().optional(),
+      nextToken: z9.string().optional(),
       /**
        * Additional model request fields to pass to the model.
        */
-      additionalModelRequestFields: z8.record(z8.string(), z8.any()).optional()
+      additionalModelRequestFields: z9.record(z9.string(), z9.any()).optional()
     })
   )
 );
@@ -2388,7 +2412,7 @@ function createAmazonBedrock(options = {}) {
           environmentVariableName: "AWS_SECRET_ACCESS_KEY",
           description: "AWS secret access key"
         }),
-        sessionToken: loadOptionalSetting({
+        sessionToken: options.accessKeyId != null && options.secretAccessKey != null ? options.sessionToken : loadOptionalSetting({
           settingValue: options.sessionToken,
           environmentVariableName: "AWS_SESSION_TOKEN"
         })