@ai-sdk/amazon-bedrock 3.0.98 → 3.0.100

package/dist/index.mjs

@@ -8,7 +8,7 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/version.ts
-var VERSION = true ? "3.0.98" : "0.0.0-test";
+var VERSION = true ? "3.0.100" : "0.0.0-test";
 
 // src/bedrock-provider.ts
 import { anthropicTools as anthropicTools2 } from "@ai-sdk/anthropic/internal";
@@ -22,7 +22,7 @@ import {
   postJsonToApi,
   resolve
 } from "@ai-sdk/provider-utils";
-import { z as z3 } from "zod/v4";
+import { z as z4 } from "zod/v4";
 
 // src/bedrock-api-types.ts
 var BEDROCK_CACHE_POINT = {
@@ -350,6 +350,15 @@ import {
   UnsupportedFunctionalityError as UnsupportedFunctionalityError2
 } from "@ai-sdk/provider";
 import { convertToBase64, parseProviderOptions } 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/convert-to-bedrock-chat-messages.ts
 function getCachePoint(providerMetadata) {
   var _a;
   return (_a = providerMetadata == null ? void 0 : providerMetadata.bedrock) == null ? void 0 : _a.cachePoint;
@@ -568,6 +577,21 @@ async function convertToBedrockChatMessages(prompt) {
                       }
                     });
                   }
+                } else if (part.providerOptions == null || Object.keys(part.providerOptions).every(
+                  (k2) => k2 === "bedrock" || k2 === "amazonBedrock"
+                )) {
+                  bedrockContent.push({
+                    reasoningContent: {
+                      reasoningText: {
+                        text: trimIfLast(
+                          isLastBlock,
+                          isLastMessage,
+                          isLastContentPart,
+                          part.text
+                        )
+                      }
+                    }
+                  });
                 }
                 break;
               }
@@ -1350,110 +1374,106 @@ var BedrockChatLanguageModel = class {
     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(),
-  usage: z3.object({
-    inputTokens: z3.number(),
-    outputTokens: z3.number(),
-    totalTokens: z3.number(),
-    cacheReadInputTokens: z3.number().nullish(),
-    cacheWriteInputTokens: z3.number().nullish()
+  trace: z4.unknown().nullish(),
+  usage: z4.object({
+    inputTokens: z4.number(),
+    outputTokens: z4.number(),
+    totalTokens: z4.number(),
+    cacheReadInputTokens: z4.number().nullish(),
+    cacheWriteInputTokens: z4.number().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(),
-    usage: z3.object({
-      cacheReadInputTokens: z3.number().nullish(),
-      cacheWriteInputTokens: z3.number().nullish(),
-      inputTokens: z3.number(),
-      outputTokens: z3.number()
+  metadata: z4.object({
+    trace: z4.unknown().nullish(),
+    usage: z4.object({
+      cacheReadInputTokens: z4.number().nullish(),
+      cacheWriteInputTokens: z4.number().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()
 });
 
 // src/bedrock-embedding-model.ts
@@ -1470,22 +1490,22 @@ import {
 } from "@ai-sdk/provider-utils";
 
 // src/bedrock-embedding-options.ts
-import { z as z4 } from "zod/v4";
-var bedrockEmbeddingProviderOptions = z4.object({
+import { z as z5 } from "zod/v4";
+var bedrockEmbeddingProviderOptions = 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()
 });
 
 // src/bedrock-embedding-model.ts
-import { z as z5 } from "zod/v4";
+import { z as z6 } from "zod/v4";
 var BedrockEmbeddingModel = class {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -1547,9 +1567,9 @@ var BedrockEmbeddingModel = class {
     };
   }
 };
-var BedrockEmbeddingResponseSchema = z5.object({
-  embedding: z5.array(z5.number()),
-  inputTextTokenCount: z5.number()
+var BedrockEmbeddingResponseSchema = z6.object({
+  embedding: z6.array(z6.number()),
+  inputTextTokenCount: z6.number()
 });
 
 // src/bedrock-image-model.ts
@@ -1567,7 +1587,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 {
   constructor(modelId, config) {
     this.modelId = modelId;
@@ -1651,8 +1671,8 @@ var BedrockImageModel = class {
     };
   }
 };
-var bedrockImageResponseSchema = z6.object({
-  images: z6.array(z6.string())
+var bedrockImageResponseSchema = z7.object({
+  images: z7.array(z7.string())
 });
 
 // src/bedrock-sigv4-fetch.ts