@ai-sdk/amazon-bedrock
Version:
The **[Amazon Bedrock provider](https://ai-sdk.dev/providers/ai-sdk-providers/amazon-bedrock)** for the [AI SDK](https://ai-sdk.dev/docs) contains language model support for the Amazon Bedrock [converse API](https://docs.aws.amazon.com/bedrock/latest/APIR
1,357 lines (1,341 loc) • 95 kB
JavaScript
// src/amazon-bedrock-provider.ts
import { anthropicTools as anthropicTools2 } from "@ai-sdk/anthropic/internal";
import {
generateId,
loadOptionalSetting,
loadSetting,
withoutTrailingSlash,
withUserAgentSuffix as withUserAgentSuffix2
} from "@ai-sdk/provider-utils";
// src/amazon-bedrock-chat-language-model.ts
import {
combineHeaders,
createJsonErrorResponseHandler,
createJsonResponseHandler,
isCustomReasoning,
mapReasoningToProviderBudget,
mapReasoningToProviderEffort,
parseProviderOptions as parseProviderOptions2,
postJsonToApi,
resolve,
serializeModelOptions,
WORKFLOW_SERIALIZE,
WORKFLOW_DESERIALIZE
} from "@ai-sdk/provider-utils";
import { getModelCapabilities } from "@ai-sdk/anthropic/internal";
import { z as z4 } from "zod/v4";
// src/amazon-bedrock-api-types.ts
var BEDROCK_STOP_REASONS = [
"stop",
"stop_sequence",
"end_turn",
"length",
"max_tokens",
"content-filter",
"content_filtered",
"guardrail_intervened",
"tool-calls",
"tool_use"
];
var BEDROCK_IMAGE_MIME_TYPES = {
"image/jpeg": "jpeg",
"image/png": "png",
"image/gif": "gif",
"image/webp": "webp"
};
var BEDROCK_DOCUMENT_MIME_TYPES = {
"application/pdf": "pdf",
"text/csv": "csv",
"application/msword": "doc",
"application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
"application/vnd.ms-excel": "xls",
"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
"text/html": "html",
"text/plain": "txt",
"text/markdown": "md"
};
// src/amazon-bedrock-chat-language-model-options.ts
import { z } from "zod/v4";
var amazonBedrockFilePartProviderOptions = z.object({
/**
* Citation configuration for this document.
* When enabled, this document will generate citations in the response.
*/
citations: z.object({
/**
* Enable citations for this document
*/
enabled: z.boolean()
}).optional()
});
var amazonBedrockLanguageModelChatOptions = z.object({
/**
* Additional inference parameters that the model supports,
* beyond the base set of inference parameters that Converse
* supports in the inferenceConfig field
*/
additionalModelRequestFields: z.record(z.string(), z.any()).optional(),
reasoningConfig: z.object({
type: z.union([
z.literal("enabled"),
z.literal("disabled"),
z.literal("adaptive")
]).optional(),
budgetTokens: z.number().optional(),
maxReasoningEffort: z.enum(["low", "medium", "high", "xhigh", "max"]).optional(),
display: z.enum(["omitted", "summarized"]).optional()
}).optional(),
/**
* Anthropic beta features to enable
*/
anthropicBeta: z.array(z.string()).optional(),
/**
* Service tier for the request.
* @see https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html
*
* - 'reserved': Uses provisioned throughput capacity
* - 'priority': Prioritizes low-latency inference when capacity is available
* - 'default': Standard on-demand tier
* - 'flex': Lower-cost tier for flexible latency workloads
*/
serviceTier: z.enum(["reserved", "priority", "default", "flex"]).optional()
});
// src/amazon-bedrock-error.ts
import { z as z2 } from "zod/v4";
var AmazonBedrockErrorSchema = z2.object({
message: z2.string(),
type: z2.string().nullish()
});
// src/amazon-bedrock-event-stream-response-handler.ts
import { EmptyResponseBodyError } from "@ai-sdk/provider";
import {
safeParseJSON,
extractResponseHeaders,
safeValidateTypes
} from "@ai-sdk/provider-utils";
// src/amazon-bedrock-event-stream-decoder.ts
import { EventStreamCodec } from "@smithy/eventstream-codec";
import { toUtf8, fromUtf8 } from "@smithy/util-utf8";
function createAmazonBedrockEventStreamDecoder(body, processEvent) {
const codec = new EventStreamCodec(toUtf8, fromUtf8);
let buffer = new Uint8Array(0);
const textDecoder = new TextDecoder();
return body.pipeThrough(
new TransformStream({
async transform(chunk, controller) {
var _a, _b;
const newBuffer = new Uint8Array(buffer.length + chunk.length);
newBuffer.set(buffer);
newBuffer.set(chunk, buffer.length);
buffer = newBuffer;
while (buffer.length >= 4) {
const totalLength = new DataView(
buffer.buffer,
buffer.byteOffset,
buffer.byteLength
).getUint32(0, false);
if (buffer.length < totalLength) {
break;
}
try {
const subView = buffer.subarray(0, totalLength);
const decoded = codec.decode(subView);
buffer = buffer.slice(totalLength);
const messageType = (_a = decoded.headers[":message-type"]) == null ? void 0 : _a.value;
const eventType = (_b = decoded.headers[":event-type"]) == null ? void 0 : _b.value;
const data = textDecoder.decode(decoded.body);
await processEvent({ messageType, eventType, data }, controller);
} catch (e) {
break;
}
}
}
})
);
}
// src/amazon-bedrock-event-stream-response-handler.ts
var createAmazonBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response }) => {
const responseHeaders = extractResponseHeaders(response);
if (response.body == null) {
throw new EmptyResponseBodyError({});
}
return {
responseHeaders,
value: createAmazonBedrockEventStreamDecoder(
response.body,
async (event, controller) => {
if (event.messageType === "event") {
const parsedDataResult = await safeParseJSON({ text: event.data });
if (!parsedDataResult.success) {
controller.enqueue(parsedDataResult);
return;
}
delete parsedDataResult.value.p;
const wrappedData = {
[event.eventType]: parsedDataResult.value
};
const validatedWrappedData = await safeValidateTypes({
value: wrappedData,
schema: chunkSchema
});
if (!validatedWrappedData.success) {
controller.enqueue(validatedWrappedData);
} else {
controller.enqueue({
success: true,
value: validatedWrappedData.value,
rawValue: wrappedData
});
}
}
}
)
};
};
// src/amazon-bedrock-prepare-tools.ts
import {
UnsupportedFunctionalityError
} from "@ai-sdk/provider";
import { asSchema } from "@ai-sdk/provider-utils";
import {
anthropicTools,
prepareTools as prepareAnthropicTools
} from "@ai-sdk/anthropic/internal";
async function prepareTools({
tools,
toolChoice,
modelId
}) {
var _a;
const toolWarnings = [];
const betas = /* @__PURE__ */ new Set();
if (tools == null || tools.length === 0) {
return {
toolConfig: {},
additionalTools: void 0,
betas,
toolWarnings
};
}
const supportedTools = tools.filter((tool) => {
if (tool.type === "provider" && tool.id === "anthropic.web_search_20250305") {
toolWarnings.push({
type: "unsupported",
feature: "web_search_20250305 tool",
details: "The web_search_20250305 tool is not supported on Amazon Bedrock."
});
return false;
}
return true;
});
if (supportedTools.length === 0) {
return {
toolConfig: {},
additionalTools: void 0,
betas,
toolWarnings
};
}
const isAnthropicModel = modelId.includes("anthropic.");
const ProviderTools = supportedTools.filter((t) => t.type === "provider");
const functionTools = supportedTools.filter((t) => t.type === "function");
let additionalTools = void 0;
const amazonBedrockTools = [];
const usingAnthropicTools = isAnthropicModel && ProviderTools.length > 0;
if (usingAnthropicTools) {
const {
toolChoice: preparedAnthropicToolChoice,
toolWarnings: anthropicToolWarnings,
betas: anthropicBetas
} = await prepareAnthropicTools({
tools: ProviderTools,
toolChoice,
supportsStructuredOutput: false,
supportsStrictTools: false
});
toolWarnings.push(...anthropicToolWarnings);
anthropicBetas.forEach((beta) => betas.add(beta));
if (preparedAnthropicToolChoice) {
additionalTools = {
tool_choice: preparedAnthropicToolChoice
};
}
for (const tool of ProviderTools) {
const toolFactory = Object.values(anthropicTools).find((factory) => {
const instance = factory({});
return instance.id === tool.id;
});
if (toolFactory != null) {
const fullToolDefinition = toolFactory({});
amazonBedrockTools.push({
toolSpec: {
name: tool.name,
inputSchema: {
json: await asSchema(fullToolDefinition.inputSchema).jsonSchema
}
}
});
} else {
toolWarnings.push({ type: "unsupported", feature: "tool ${tool.id}" });
}
}
} else {
for (const tool of ProviderTools) {
toolWarnings.push({ type: "unsupported", feature: `tool ${tool.id}` });
}
}
const filteredFunctionTools = (toolChoice == null ? void 0 : toolChoice.type) === "tool" ? functionTools.filter((t) => t.name === toolChoice.toolName) : functionTools;
const supportsStrictOnTools = !modelId.includes("claude-opus-4-7") && !modelId.includes("claude-opus-4-8");
for (const tool of filteredFunctionTools) {
amazonBedrockTools.push({
toolSpec: {
name: tool.name,
...((_a = tool.description) == null ? void 0 : _a.trim()) !== "" ? { description: tool.description } : {},
...tool.strict != null && supportsStrictOnTools ? { strict: tool.strict } : {},
inputSchema: {
json: tool.inputSchema
}
}
});
}
let amazonBedrockToolChoice = void 0;
if (!usingAnthropicTools && amazonBedrockTools.length > 0 && toolChoice) {
const type = toolChoice.type;
switch (type) {
case "auto":
amazonBedrockToolChoice = { auto: {} };
break;
case "required":
amazonBedrockToolChoice = { any: {} };
break;
case "none":
amazonBedrockTools.length = 0;
amazonBedrockToolChoice = void 0;
break;
case "tool":
amazonBedrockToolChoice = { tool: { name: toolChoice.toolName } };
break;
default: {
const _exhaustiveCheck = type;
throw new UnsupportedFunctionalityError({
functionality: `tool choice type: ${_exhaustiveCheck}`
});
}
}
}
const toolConfig = amazonBedrockTools.length > 0 ? { tools: amazonBedrockTools, toolChoice: amazonBedrockToolChoice } : {};
return {
toolConfig,
additionalTools,
betas,
toolWarnings
};
}
// src/convert-amazon-bedrock-usage.ts
function convertAmazonBedrockUsage(usage) {
var _a, _b;
if (usage == null) {
return {
inputTokens: {
total: void 0,
noCache: void 0,
cacheRead: void 0,
cacheWrite: void 0
},
outputTokens: {
total: void 0,
text: void 0,
reasoning: void 0
},
raw: void 0
};
}
const inputTokens = usage.inputTokens;
const outputTokens = usage.outputTokens;
const cacheReadTokens = (_a = usage.cacheReadInputTokens) != null ? _a : 0;
const cacheWriteTokens = (_b = usage.cacheWriteInputTokens) != null ? _b : 0;
return {
inputTokens: {
total: inputTokens + cacheReadTokens + cacheWriteTokens,
noCache: inputTokens,
cacheRead: cacheReadTokens,
cacheWrite: cacheWriteTokens
},
outputTokens: {
total: outputTokens,
text: outputTokens,
reasoning: void 0
},
raw: usage
};
}
// src/convert-to-amazon-bedrock-chat-messages.ts
import {
UnsupportedFunctionalityError as UnsupportedFunctionalityError2
} from "@ai-sdk/provider";
import {
convertToBase64,
getTopLevelMediaType,
isFullMediaType,
parseProviderOptions,
resolveFullMediaType,
stripFileExtension
} from "@ai-sdk/provider-utils";
// src/amazon-bedrock-reasoning-metadata.ts
import { z as z3 } from "zod/v4";
var amazonBedrockReasoningMetadataSchema = z3.object({
signature: z3.string().optional(),
redactedData: z3.string().optional()
});
// src/normalize-tool-call-id.ts
function isMistralModel(modelId) {
return modelId.includes("mistral.");
}
function normalizeToolCallId(toolCallId, isMistral) {
if (!isMistral) {
return toolCallId;
}
const alphanumericChars = toolCallId.replace(/[^a-zA-Z0-9]/g, "");
return alphanumericChars.slice(0, 9);
}
// src/convert-to-amazon-bedrock-chat-messages.ts
function getCachePoint(providerMetadata) {
var _a, _b, _c;
const cachePointConfig = (_c = (_a = providerMetadata == null ? void 0 : providerMetadata.amazonBedrock) == null ? void 0 : _a.cachePoint) != null ? _c : (_b = providerMetadata == null ? void 0 : providerMetadata.bedrock) == null ? void 0 : _b.cachePoint;
if (!cachePointConfig) {
return void 0;
}
return { cachePoint: cachePointConfig };
}
function pushCachePoint(content, providerMetadata) {
const cachePoint = getCachePoint(providerMetadata);
if (cachePoint) {
content.push(cachePoint);
}
}
async function shouldEnableCitations(providerMetadata) {
var _a, _b, _c;
const amazonBedrockOptions = (_a = await parseProviderOptions({
provider: "amazonBedrock",
providerOptions: providerMetadata,
schema: amazonBedrockFilePartProviderOptions
})) != null ? _a : await parseProviderOptions({
provider: "bedrock",
providerOptions: providerMetadata,
schema: amazonBedrockFilePartProviderOptions
});
return (_c = (_b = amazonBedrockOptions == null ? void 0 : amazonBedrockOptions.citations) == null ? void 0 : _b.enabled) != null ? _c : false;
}
async function convertToAmazonBedrockChatMessages(prompt, isMistral = false) {
var _a, _b;
const blocks = groupIntoBlocks(prompt);
let system = [];
const messages = [];
let documentCounter = 0;
const generateDocumentName = () => `document-${++documentCounter}`;
for (let i = 0; i < blocks.length; i++) {
const block = blocks[i];
const isLastBlock = i === blocks.length - 1;
const type = block.type;
switch (type) {
case "system": {
if (messages.length > 0) {
throw new UnsupportedFunctionalityError2({
functionality: "Multiple system messages that are separated by user/assistant messages"
});
}
for (const message of block.messages) {
system.push({ text: message.content });
const cachePoint = getCachePoint(message.providerOptions);
if (cachePoint) {
system.push(cachePoint);
}
}
break;
}
case "user": {
const amazonBedrockContent = [];
for (const message of block.messages) {
const { role, content, providerOptions } = message;
switch (role) {
case "user": {
for (let j = 0; j < content.length; j++) {
const part = content[j];
switch (part.type) {
case "text": {
amazonBedrockContent.push({
text: part.text
});
break;
}
case "file": {
switch (part.data.type) {
case "reference": {
throw new UnsupportedFunctionalityError2({
functionality: "file parts with provider references"
});
}
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
);
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
);
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;
}
}
pushCachePoint(amazonBedrockContent, part.providerOptions);
}
break;
}
case "tool": {
for (const part of content) {
if (part.type === "tool-approval-response") {
continue;
}
let toolResultContent;
const output = part.output;
switch (output.type) {
case "content": {
toolResultContent = await Promise.all(
output.value.map(async (contentPart) => {
switch (contentPart.type) {
case "text":
return { text: contentPart.text };
case "file": {
if (contentPart.data.type !== "data") {
throw new UnsupportedFunctionalityError2({
functionality: `tool result file data of type "${contentPart.data.type}"`
});
}
const fullMediaType = resolveFullMediaType({
part: contentPart
});
if (getTopLevelMediaType(fullMediaType) !== "image") {
const enableCitations = await shouldEnableCitations(
contentPart.providerOptions
);
return {
document: {
format: getAmazonBedrockDocumentFormat(
fullMediaType
),
name: contentPart.filename ? stripFileExtension(contentPart.filename) : generateDocumentName(),
source: {
bytes: convertToBase64(
contentPart.data.data
)
},
...enableCitations && {
citations: { enabled: true }
}
}
};
}
return {
image: {
format: getAmazonBedrockImageFormat(fullMediaType),
source: {
bytes: convertToBase64(contentPart.data.data)
}
}
};
}
default: {
throw new UnsupportedFunctionalityError2({
functionality: `unsupported tool content part type: ${contentPart.type}`
});
}
}
})
);
break;
}
case "text":
case "error-text":
toolResultContent = [{ text: output.value }];
break;
case "execution-denied":
toolResultContent = [
{ text: (_a = output.reason) != null ? _a : "Tool call execution denied." }
];
break;
case "json":
case "error-json":
default:
toolResultContent = [
{ text: JSON.stringify(output.value) }
];
break;
}
amazonBedrockContent.push({
toolResult: {
toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
content: toolResultContent
}
});
pushCachePoint(amazonBedrockContent, part.providerOptions);
}
break;
}
default: {
const _exhaustiveCheck = role;
throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
}
}
pushCachePoint(amazonBedrockContent, providerOptions);
}
messages.push({ role: "user", content: amazonBedrockContent });
break;
}
case "assistant": {
const amazonBedrockContent = [];
for (let j = 0; j < block.messages.length; j++) {
const message = block.messages[j];
const isLastMessage = j === block.messages.length - 1;
const { content } = message;
const hasReasoningBlocks = content.some(
(part) => part.type === "reasoning"
);
for (let k = 0; k < content.length; k++) {
const part = content[k];
const isLastContentPart = k === content.length - 1;
switch (part.type) {
case "text": {
if (!part.text.trim() && !hasReasoningBlocks) {
break;
}
amazonBedrockContent.push({
text: (
// 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
trimIfLast(
isLastBlock,
isLastMessage,
isLastContentPart,
part.text
)
)
});
break;
}
case "reasoning": {
const reasoningMetadata = (_b = await parseProviderOptions({
provider: "amazonBedrock",
providerOptions: part.providerOptions,
schema: amazonBedrockReasoningMetadataSchema
})) != null ? _b : await parseProviderOptions({
provider: "bedrock",
providerOptions: part.providerOptions,
schema: amazonBedrockReasoningMetadataSchema
});
if ((reasoningMetadata == null ? void 0 : reasoningMetadata.signature) != null) {
amazonBedrockContent.push({
reasoningContent: {
reasoningText: {
text: part.text,
signature: reasoningMetadata.signature
}
}
});
} else if ((reasoningMetadata == null ? void 0 : reasoningMetadata.redactedData) != null) {
amazonBedrockContent.push({
reasoningContent: {
redactedReasoning: {
data: reasoningMetadata.redactedData
}
}
});
}
break;
}
case "tool-call": {
amazonBedrockContent.push({
toolUse: {
toolUseId: normalizeToolCallId(part.toolCallId, isMistral),
name: part.toolName,
input: part.input
}
});
break;
}
}
pushCachePoint(amazonBedrockContent, part.providerOptions);
}
pushCachePoint(amazonBedrockContent, message.providerOptions);
}
messages.push({ role: "assistant", content: amazonBedrockContent });
break;
}
default: {
const _exhaustiveCheck = type;
throw new Error(`Unsupported type: ${_exhaustiveCheck}`);
}
}
}
return { system, messages };
}
function getAmazonBedrockImageFormat(mimeType) {
const format = BEDROCK_IMAGE_MIME_TYPES[mimeType];
if (!format) {
throw new UnsupportedFunctionalityError2({
functionality: `image mime type: ${mimeType}`,
message: `Unsupported image mime type: ${mimeType}, expected one of: ${Object.keys(BEDROCK_IMAGE_MIME_TYPES).join(", ")}`
});
}
return format;
}
function getAmazonBedrockDocumentFormat(mimeType) {
const format = BEDROCK_DOCUMENT_MIME_TYPES[mimeType];
if (!format) {
throw new UnsupportedFunctionalityError2({
functionality: `file mime type: ${mimeType}`,
message: `Unsupported file mime type: ${mimeType}, expected one of: ${Object.keys(BEDROCK_DOCUMENT_MIME_TYPES).join(", ")}`
});
}
return format;
}
function trimIfLast(isLastBlock, isLastMessage, isLastContentPart, text) {
return isLastBlock && isLastMessage && isLastContentPart ? text.trim() : text;
}
function groupIntoBlocks(prompt) {
const blocks = [];
let currentBlock = void 0;
for (const message of prompt) {
const { role } = message;
switch (role) {
case "system": {
if ((currentBlock == null ? void 0 : currentBlock.type) !== "system") {
currentBlock = { type: "system", messages: [] };
blocks.push(currentBlock);
}
currentBlock.messages.push(message);
break;
}
case "assistant": {
if ((currentBlock == null ? void 0 : currentBlock.type) !== "assistant") {
currentBlock = { type: "assistant", messages: [] };
blocks.push(currentBlock);
}
currentBlock.messages.push(message);
break;
}
case "user": {
if ((currentBlock == null ? void 0 : currentBlock.type) !== "user") {
currentBlock = { type: "user", messages: [] };
blocks.push(currentBlock);
}
currentBlock.messages.push(message);
break;
}
case "tool": {
if ((currentBlock == null ? void 0 : currentBlock.type) !== "user") {
currentBlock = { type: "user", messages: [] };
blocks.push(currentBlock);
}
currentBlock.messages.push(message);
break;
}
default: {
const _exhaustiveCheck = role;
throw new Error(`Unsupported role: ${_exhaustiveCheck}`);
}
}
}
return blocks;
}
// src/map-amazon-bedrock-finish-reason.ts
function mapAmazonBedrockFinishReason(finishReason, isJsonResponseFromTool) {
switch (finishReason) {
case "stop_sequence":
case "end_turn":
return "stop";
case "max_tokens":
return "length";
case "content_filtered":
case "guardrail_intervened":
return "content-filter";
case "tool_use":
return isJsonResponseFromTool ? "stop" : "tool-calls";
default:
return "other";
}
}
// src/amazon-bedrock-chat-language-model.ts
var AmazonBedrockChatLanguageModel = class _AmazonBedrockChatLanguageModel {
constructor(modelId, config) {
this.modelId = modelId;
this.config = config;
this.specificationVersion = "v4";
this.provider = "amazon-bedrock";
this.supportedUrls = {
// no supported urls for bedrock
};
}
static [WORKFLOW_SERIALIZE](model) {
return serializeModelOptions({
modelId: model.modelId,
config: model.config
});
}
static [WORKFLOW_DESERIALIZE](options) {
return new _AmazonBedrockChatLanguageModel(options.modelId, options.config);
}
async getArgs({
prompt,
maxOutputTokens,
temperature,
topP,
topK,
frequencyPenalty,
presencePenalty,
stopSequences,
responseFormat,
seed,
tools,
toolChoice,
reasoning,
providerOptions
}) {
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
let amazonBedrockOptions = (_b = (_a = await parseProviderOptions2({
provider: "amazonBedrock",
providerOptions,
schema: amazonBedrockLanguageModelChatOptions
})) != null ? _a : await parseProviderOptions2({
provider: "bedrock",
providerOptions,
schema: amazonBedrockLanguageModelChatOptions
})) != null ? _b : {};
const warnings = [];
if (frequencyPenalty != null) {
warnings.push({
type: "unsupported",
feature: "frequencyPenalty"
});
}
if (presencePenalty != null) {
warnings.push({
type: "unsupported",
feature: "presencePenalty"
});
}
if (seed != null) {
warnings.push({
type: "unsupported",
feature: "seed"
});
}
if (temperature != null && temperature > 1) {
warnings.push({
type: "unsupported",
feature: "temperature",
details: `${temperature} exceeds bedrock maximum of 1.0. clamped to 1.0`
});
temperature = 1;
} else if (temperature != null && temperature < 0) {
warnings.push({
type: "unsupported",
feature: "temperature",
details: `${temperature} is below bedrock minimum of 0. clamped to 0`
});
temperature = 0;
}
if (responseFormat != null && responseFormat.type !== "text" && responseFormat.type !== "json") {
warnings.push({
type: "unsupported",
feature: "responseFormat",
details: "Only text and json response formats are supported."
});
}
const isAnthropicModel = this.modelId.includes("anthropic");
const isOpenAIModel = this.modelId.startsWith("openai.");
amazonBedrockOptions = resolveAmazonBedrockReasoningConfig({
reasoning,
amazonBedrockOptions,
warnings,
isAnthropicModel,
modelId: this.modelId
});
const isThinkingEnabled = ((_c = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _c.type) === "enabled" || ((_d = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _d.type) === "adaptive";
const { supportsStructuredOutput: modelSupportsStructuredOutput } = getModelCapabilities(this.modelId);
const useNativeStructuredOutput = isAnthropicModel && (modelSupportsStructuredOutput || isThinkingEnabled) && (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null;
const jsonResponseTool = (responseFormat == null ? void 0 : responseFormat.type) === "json" && responseFormat.schema != null && !useNativeStructuredOutput ? {
type: "function",
name: "json",
description: "Respond with a JSON object.",
inputSchema: responseFormat.schema
} : void 0;
const { toolConfig, additionalTools, toolWarnings, betas } = await prepareTools({
tools: jsonResponseTool ? [...tools != null ? tools : [], jsonResponseTool] : tools,
toolChoice: jsonResponseTool != null ? { type: "required" } : toolChoice,
modelId: this.modelId
});
warnings.push(...toolWarnings);
if (additionalTools) {
amazonBedrockOptions.additionalModelRequestFields = {
...amazonBedrockOptions.additionalModelRequestFields,
...additionalTools
};
}
if (betas.size > 0 || amazonBedrockOptions.anthropicBeta) {
const existingBetas = (_e = amazonBedrockOptions.anthropicBeta) != null ? _e : [];
const mergedBetas = betas.size > 0 ? [...existingBetas, ...Array.from(betas)] : existingBetas;
amazonBedrockOptions.additionalModelRequestFields = {
...amazonBedrockOptions.additionalModelRequestFields,
anthropic_beta: mergedBetas
};
}
const thinkingType = (_f = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _f.type;
const thinkingBudget = thinkingType === "enabled" ? (_g = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _g.budgetTokens : void 0;
const thinkingDisplay = thinkingType === "adaptive" ? (_h = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _h.display : void 0;
const isAnthropicThinkingEnabled = isAnthropicModel && isThinkingEnabled;
const inferenceConfig = {
...maxOutputTokens != null && { maxTokens: maxOutputTokens },
...temperature != null && { temperature },
...topP != null && { topP },
...topK != null && { topK },
...stopSequences != null && { stopSequences }
};
if (isAnthropicThinkingEnabled) {
if (thinkingBudget != null) {
if (inferenceConfig.maxTokens != null) {
inferenceConfig.maxTokens += thinkingBudget;
} else {
inferenceConfig.maxTokens = thinkingBudget + 4096;
}
amazonBedrockOptions.additionalModelRequestFields = {
...amazonBedrockOptions.additionalModelRequestFields,
thinking: {
type: "enabled",
budget_tokens: thinkingBudget
}
};
} else if (thinkingType === "adaptive") {
amazonBedrockOptions.additionalModelRequestFields = {
...amazonBedrockOptions.additionalModelRequestFields,
thinking: {
type: "adaptive",
...thinkingDisplay != null && { display: thinkingDisplay }
}
};
}
} else if (!isAnthropicModel) {
if (((_i = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _i.budgetTokens) != null) {
warnings.push({
type: "unsupported",
feature: "budgetTokens",
details: "budgetTokens applies only to Anthropic models on Bedrock and will be ignored for this model."
});
}
if (thinkingType === "adaptive") {
warnings.push({
type: "unsupported",
feature: "adaptive thinking",
details: "adaptive thinking type applies only to Anthropic models on Bedrock."
});
}
}
const maxReasoningEffort = (_j = amazonBedrockOptions.reasoningConfig) == null ? void 0 : _j.maxReasoningEffort;
if (maxReasoningEffort != null) {
if (isAnthropicModel) {
amazonBedrockOptions.additionalModelRequestFields = {
...amazonBedrockOptions.additionalModelRequestFields,
output_config: {
...(_k = amazonBedrockOptions.additionalModelRequestFields) == null ? void 0 : _k.output_config,
effort: maxReasoningEffort
}
};
} else if (isOpenAIModel) {
amazonBedrockOptions.additionalModelRequestFields = {
...amazonBedrockOptions.additionalModelRequestFields,
reasoning_effort: maxReasoningEffort
};
} else {
amazonBedrockOptions.additionalModelRequestFields = {
...amazonBedrockOptions.additionalModelRequestFields,
reasoningConfig: {
...thinkingType != null && thinkingType !== "adaptive" && { type: thinkingType },
...thinkingBudget != null && { budgetTokens: thinkingBudget },
maxReasoningEffort
}
};
}
}
if (useNativeStructuredOutput) {
amazonBedrockOptions.additionalModelRequestFields = {
...amazonBedrockOptions.additionalModelRequestFields,
output_config: {
...(_l = amazonBedrockOptions.additionalModelRequestFields) == null ? void 0 : _l.output_config,
format: {
type: "json_schema",
schema: responseFormat.schema
}
}
};
}
if (isAnthropicThinkingEnabled && inferenceConfig.temperature != null) {
delete inferenceConfig.temperature;
warnings.push({
type: "unsupported",
feature: "temperature",
details: "temperature is not supported when thinking is enabled"
});
}
if (isAnthropicThinkingEnabled && inferenceConfig.topP != null) {
delete inferenceConfig.topP;
warnings.push({
type: "unsupported",
feature: "topP",
details: "topP is not supported when thinking is enabled"
});
}
if (isAnthropicThinkingEnabled && inferenceConfig.topK != null) {
delete inferenceConfig.topK;
warnings.push({
type: "unsupported",
feature: "topK",
details: "topK is not supported when thinking is enabled"
});
}
const hasAnyTools = ((_n = (_m = toolConfig.tools) == null ? void 0 : _m.length) != null ? _n : 0) > 0 || additionalTools;
let filteredPrompt = prompt;
if (!hasAnyTools) {
const hasToolContent = prompt.some(
(message) => "content" in message && Array.isArray(message.content) && message.content.some(
(part) => part.type === "tool-call" || part.type === "tool-result"
)
);
if (hasToolContent) {
filteredPrompt = prompt.map(
(message) => message.role === "system" ? message : {
...message,
content: message.content.filter(
(part) => part.type !== "tool-call" && part.type !== "tool-result"
)
}
).filter(
(message) => message.role === "system" || message.content.length > 0
);
warnings.push({
type: "unsupported",
feature: "toolContent",
details: "Tool calls and results removed from conversation because Bedrock does not support tool content without active tools."
});
}
}
const isMistral = isMistralModel(this.modelId);
const { system, messages } = await convertToAmazonBedrockChatMessages(
filteredPrompt,
isMistral
);
const {
reasoningConfig: _,
additionalModelRequestFields: __,
serviceTier: ___,
...filteredAmazonBedrockOptions
} = (_p = (_o = providerOptions == null ? void 0 : providerOptions.amazonBedrock) != null ? _o : providerOptions == null ? void 0 : providerOptions.bedrock) != null ? _p : {};
const additionalModelResponseFieldPaths = isAnthropicModel ? ["/delta/stop_sequence"] : void 0;
return {
command: {
system,
messages,
additionalModelRequestFields: amazonBedrockOptions.additionalModelRequestFields,
...additionalModelResponseFieldPaths && {
additionalModelResponseFieldPaths
},
...Object.keys(inferenceConfig).length > 0 && {
inferenceConfig
},
...amazonBedrockOptions.serviceTier != null && {
serviceTier: {
type: amazonBedrockOptions.serviceTier
}
},
...filteredAmazonBedrockOptions,
...toolConfig.tools !== void 0 && toolConfig.tools.length > 0 ? { toolConfig } : {}
},
warnings,
usesJsonResponseTool: jsonResponseTool != null,
betas
};
}
async getHeaders({
headers
}) {
return combineHeaders(
this.config.headers ? await resolve(this.config.headers) : void 0,
headers
);
}
async doGenerate(options) {
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
const {
command: args,
warnings,
usesJsonResponseTool
} = await this.getArgs(options);
const url = `${this.getUrl(this.modelId)}/converse`;
const { value: response, responseHeaders } = await postJsonToApi({
url,
headers: await this.getHeaders({ headers: options.headers }),
body: args,
failedResponseHandler: createJsonErrorResponseHandler({
errorSchema: AmazonBedrockErrorSchema,
errorToMessage: (error) => {
var _a2;
return `${(_a2 = error.message) != null ? _a2 : "Unknown error"}`;
}
}),
successfulResponseHandler: createJsonResponseHandler(
AmazonBedrockResponseSchema
),
abortSignal: options.abortSignal,
fetch: this.config.fetch
});
const content = [];
let isJsonResponseFromTool = false;
for (const part of response.output.message.content) {
if (part.text != null) {
content.push({ type: "text", text: part.text });
}
if (part.reasoningContent) {
if ("reasoningText" in part.reasoningContent) {
const reasoning = {
type: "reasoning",
text: part.reasoningContent.reasoningText.text
};
if (part.reasoningContent.reasoningText.signature) {
const reasoningPayload = {
signature: part.reasoningContent.reasoningText.signature
};
reasoning.providerMetadata = {
amazonBedrock: reasoningPayload,
bedrock: reasoningPayload
};
}
content.push(reasoning);
} else if ("redactedReasoning" in part.reasoningContent) {
const redactedPayload = {
redactedData: (_a = part.reasoningContent.redactedReasoning.data) != null ? _a : ""
};
content.push({
type: "reasoning",
text: "",
providerMetadata: {
amazonBedrock: redactedPayload,
bedrock: redactedPayload
}
});
}
}
if (part.toolUse) {
const isJsonResponseTool = usesJsonResponseTool && part.toolUse.name === "json";
if (isJsonResponseTool) {
isJsonResponseFromTool = true;
content.push({
type: "text",
text: JSON.stringify(part.toolUse.input)
});
} else {
const isMistral = isMistralModel(this.modelId);
const rawToolCallId = (_c = (_b = part.toolUse) == null ? void 0 : _b.toolUseId) != null ? _c : this.config.generateId();
content.push({
type: "tool-call",
toolCallId: normalizeToolCallId(rawToolCallId, isMistral),
toolName: (_e = (_d = part.toolUse) == null ? void 0 : _d.name) != null ? _e : `tool-${this.config.generateId()}`,
input: JSON.stringify((_g = (_f = part.toolUse) == null ? void 0 : _f.input) != null ? _g : {})
});
}
}
}
const stopSequence = (_j = (_i = (_h = response.additionalModelResponseFields) == null ? void 0 : _h.delta) == null ? void 0 : _i.stop_sequence) != null ? _j : null;
const providerMetadataPayload = response.trace || response.usage || response.performanceConfig || response.serviceTier || isJsonResponseFromTool || stopSequence ? {
...response.trace && typeof response.trace === "object" ? { trace: response.trace } : {},
...response.performanceConfig && {
performanceConfig: response.performanceConfig
},
...response.serviceTier && {
serviceTier: response.serviceTier
},
...(((_k = response.usage) == null ? void 0 : _k.cacheWriteInputTokens) != null || ((_l = response.usage) == null ? void 0 : _l.cacheDetails) != null) && {
usage: {
...response.usage.cacheWriteInputTokens != null && {
cacheWriteInputTokens: response.usage.cacheWriteInputTokens
},
...response.usage.cacheDetails != null && {
cacheDetails: response.usage.cacheDetails
}
}
},
...isJsonResponseFromTool && { isJsonResponseFromTool: true },
stopSequence
} : void 0;
const providerMetadata = providerMetadataPayload ? {
amazonBedrock: providerMetadataPayload,
bedrock: providerMetadataPayload
} : void 0;
return {
content,
finishReason: {
unified: mapAmazonBedrockFinishReason(
response.stopReason,
isJsonResponseFromTool
),
raw: (_m = response.stopReason) != null ? _m : void 0
},
usage: convertAmazonBedrockUsage(response.usage),
response: {
id: (_n = responseHeaders == null ? void 0 : responseHeaders["x-amzn-requestid"]) != null ? _n : void 0,
timestamp: (responseHeaders == null ? void 0 : responseHeaders["date"]) != null ? new Date(responseHeaders["date"]) : void 0,
modelId: this.modelId,
headers: responseHeaders
},
warnings,
...providerMetadata && { providerMetadata }
};
}
async doStream(options) {
const {
command: args,
warnings,
usesJsonResponseTool
} = await this.getArgs(options);
const modelId = this.modelId;
const isMistral = isMistralModel(modelId);
const url = `${this.getUrl(modelId)}/converse-stream`;
const { value: response, responseHeaders } = await postJsonToApi({
url,
headers: await this.getHeaders({ headers: options.headers }),
body: args,
failedResponseHandler: createJsonErrorResponseHandler({
errorSchema: AmazonBedrockErrorSchema,
errorToMessage: (error) => `${error.type}: ${error.message}`
}),
successfulResponseHandler: createAmazonBedrockEventStreamResponseHandler(
AmazonBedrockStreamSchema
),
abortSignal: options.abortSignal,
fetch: this.config.fetch
});
let finishReason = {
unified: "other",
raw: void 0
};
let usage = void 0;
let providerMetadata = void 0;
let isJsonResponseFromTool = false;
let stopSequence = null;
const contentBlocks = {};
return {
stream: response.pipeThrough(
new TransformStream({
start(controller) {
var _a;
controller.enqueue({ type: "stream-start", warnings });
controller.enqueue({
type: "response-metadata",
id: (_a = responseHeaders == null ? void 0 : responseHeaders["x-amzn-requestid"]) != null ? _a : void 0,
timestamp: (responseHeaders == null ? void 0 : responseHeaders["date"]) != null ? new Date(responseHeaders["date"]) : void 0,
modelId
});
},
transform(chunk, controller) {
var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
function enqueueError(amazonBedrockError) {
finishReason = { unified: "error", raw: void 0 };
controller.enqueue({ type: "error", error: amazonBedrockError });
}
if (options.includeRawChunks) {
controller.enqueue({ type: "raw", rawValue: chunk.rawValue });
}
if (!chunk.success) {
enqueueError(chunk.error);
return;
}
const value = chunk.value;
if (value.internalServerException) {
enqueueError(value.internalServerException);
return;
}
if (value.modelStreamErrorException) {
enqueueError(value.modelStreamErrorException);
return;
}
if (value.throttlingException) {
enqueueError(value.throttlingException);
return;
}
if (value.validationException) {
enqueueError(value.validationException);
return;
}
if (value.messageStop) {
finishReason = {
unified: mapAmazonBedrockFinishReason(
value.messageStop.stopReason,
isJsonResponseFromTool
),
raw: (_a = value.messageStop.stopReason) != null ? _a : void 0
};
stopSequence = (_d = (_c = (_b = value.messageStop.additionalModelResponseFields) == null ? void 0 : _b.delta) == null ? void 0 : _c.stop_sequence) != null ? _d : null;
}
if (value.metadata) {
if (value.metadata.usage) {
usage = value.metadata.usage;
}
const cacheUsage = ((_e = value.metadata.usage) == null ? void 0 : _e.cacheWriteInputTokens) != null || ((_f = value.metadata.usage) == null ? void 0 : _f.cacheDetails) != null ? {
usage: {
...((_g = value.metadata.usage) == null ? void 0 : _g.cacheWriteInputTokens) != null && {