@ai-sdk/amazon-bedrock 5.0.93 → 5.0.96

package/src/amazon-bedrock-prepare-tools.ts

@@ -27,6 +27,7 @@ export async function prepareTools({
   modelFamily,
   reasoningBudgetTokens,
   disableParallelToolUse,
+  rejectsForcedToolUse = false,
 }: {
   tools: LanguageModelV4CallOptions['tools'];
   toolChoice?: LanguageModelV4CallOptions['toolChoice'];
@@ -34,6 +35,7 @@ export async function prepareTools({
   modelFamily?: AmazonBedrockChatModelSettings['modelFamily'];
   reasoningBudgetTokens?: number;
   disableParallelToolUse?: boolean;
+  rejectsForcedToolUse?: boolean;
 }): Promise<{
   toolConfig: AmazonBedrockToolConfiguration;
   additionalTools: Record<string, unknown> | undefined;
@@ -84,13 +86,22 @@ export async function prepareTools({
     modelFamily,
     reasoningBudgetTokens,
   });
-  const ProviderTools = supportedTools.filter(t => t.type === 'provider');
+  const providerTools = supportedTools.filter(t => t.type === 'provider');
   const functionTools = supportedTools.filter(t => t.type === 'function');
+  const rejectsForcedToolChoice =
+    isAnthropicModel &&
+    rejectsForcedToolUse &&
+    (toolChoice?.type === 'required' || toolChoice?.type === 'tool');
+  const providerToolsForRequest =
+    rejectsForcedToolChoice && toolChoice.type === 'tool'
+      ? providerTools.filter(tool => tool.name === toolChoice.toolName)
+      : providerTools;
 
   let additionalTools: Record<string, unknown> | undefined = undefined;
   const amazonBedrockTools: AmazonBedrockTool[] = [];
 
-  const usingAnthropicTools = isAnthropicModel && ProviderTools.length > 0;
+  const usingAnthropicTools =
+    isAnthropicModel && providerToolsForRequest.length > 0;
 
   // Handle Anthropic provider-defined tools for Anthropic models on Bedrock
   if (usingAnthropicTools) {
@@ -99,11 +110,12 @@ export async function prepareTools({
       toolWarnings: anthropicToolWarnings,
       betas: anthropicBetas,
     } = await prepareAnthropicTools({
-      tools: ProviderTools,
+      tools: providerTools,
       toolChoice,
       disableParallelToolUse,
       supportsStructuredOutput: false,
       supportsStrictTools: false,
+      rejectsForcedToolUse,
     });
 
     toolWarnings.push(...anthropicToolWarnings);
@@ -118,7 +130,7 @@ export async function prepareTools({
     }
 
     // Create a standard Bedrock tool representation for validation purposes
-    for (const tool of ProviderTools) {
+    for (const tool of providerToolsForRequest) {
       const toolFactory = Object.values(anthropicTools).find(factory => {
         const instance = (factory as (args: any) => any)({});
         return instance.id === tool.id;
@@ -141,11 +153,34 @@ export async function prepareTools({
     }
   } else {
     // Report unsupported provider-defined tools for non-anthropic models
-    for (const tool of ProviderTools) {
+    for (const tool of providerToolsForRequest) {
       toolWarnings.push({ type: 'unsupported', feature: `tool ${tool.id}` });
     }
   }
 
+  let preparedToolChoice = toolChoice;
+  if (!usingAnthropicTools && rejectsForcedToolChoice) {
+    if (toolChoice.type === 'tool') {
+      toolWarnings.push({
+        type: 'unsupported',
+        feature: 'toolChoice',
+        details:
+          `toolChoice 'tool' is not supported by this model because it rejects forced tool use. ` +
+          `Only the '${toolChoice.toolName}' tool is sent with 'auto' tool choice. ` +
+          `Instruct the model to use the tool in the prompt and verify that a tool call was made.`,
+      });
+    } else {
+      toolWarnings.push({
+        type: 'unsupported',
+        feature: 'toolChoice',
+        details:
+          `toolChoice 'required' is not supported by this model because it rejects forced tool use. ` +
+          `Using 'auto' instead. Instruct the model to use a tool in the prompt and verify that a tool call was made.`,
+      });
+    }
+    preparedToolChoice = { type: 'auto' };
+  }
+
   const filteredFunctionTools =
     toolChoice?.type === 'tool'
       ? functionTools.filter(t => t.name === toolChoice.toolName)
@@ -193,16 +228,16 @@ export async function prepareTools({
     !usingAnthropicTools &&
     disableParallelToolUse &&
     amazonBedrockTools.length > 0 &&
-    toolChoice?.type !== 'none'
+    preparedToolChoice?.type !== 'none'
   ) {
     additionalTools = {
       tool_choice:
-        toolChoice?.type === 'required'
+        preparedToolChoice?.type === 'required'
           ? { type: 'any', disable_parallel_tool_use: true }
-          : toolChoice?.type === 'tool'
+          : preparedToolChoice?.type === 'tool'
             ? {
                 type: 'tool',
-                name: toolChoice.toolName,
+                name: preparedToolChoice.toolName,
                 disable_parallel_tool_use: true,
               }
             : { type: 'auto', disable_parallel_tool_use: true },
@@ -216,9 +251,9 @@ export async function prepareTools({
     !usingAnthropicTools &&
     additionalTools?.tool_choice == null &&
     amazonBedrockTools.length > 0 &&
-    toolChoice
+    preparedToolChoice
   ) {
-    const type = toolChoice.type;
+    const type = preparedToolChoice.type;
     switch (type) {
       case 'auto':
         amazonBedrockToolChoice = { auto: {} };
@@ -231,7 +266,9 @@ export async function prepareTools({
         amazonBedrockToolChoice = undefined;
         break;
       case 'tool':
-        amazonBedrockToolChoice = { tool: { name: toolChoice.toolName } };
+        amazonBedrockToolChoice = {
+          tool: { name: preparedToolChoice.toolName },
+        };
         break;
       default: {
         const _exhaustiveCheck: never = type;

package/src/normalize-tool-call-id.ts

@@ -16,7 +16,7 @@ export function isMistralModel(modelId: string): boolean {
  * Bedrock generates tool call IDs in formats like `tooluse_bpe71yCfRu2b5i-nKGDr5g`,
  * which are incompatible with Mistral's requirements.
  *
- * This function extracts the first 9 alphanumeric characters from the ID.
+ * This function hashes incompatible IDs into 9 alphanumeric characters.
  *
  * @param toolCallId - The original tool call ID from Bedrock
  * @param isMistral - Whether the model is a Mistral model
@@ -30,7 +30,40 @@ export function normalizeToolCallId(
     return toolCallId;
   }
 
-  // Extract only alphanumeric characters and take first 9
-  const alphanumericChars = toolCallId.replace(/[^a-zA-Z0-9]/g, '');
-  return alphanumericChars.slice(0, 9);
+  if (/^[a-zA-Z0-9]{9}$/.test(toolCallId)) {
+    return toolCallId;
+  }
+
+  return convertToBase62Hash(toolCallId);
+}
+
+const base62Characters =
+  '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+const base62Length = BigInt(base62Characters.length);
+const normalizedToolCallIdLength = 9;
+const normalizedToolCallIdSpace =
+  base62Length ** BigInt(normalizedToolCallIdLength);
+const fnvOffsetBasis64 = BigInt('14695981039346656037');
+const fnvPrime64 = BigInt('1099511628211');
+const fnv64BitMask = BigInt('18446744073709551615');
+
+function convertToBase62Hash(value: string): string {
+  // FNV-1a 64-bit is deterministic across runtimes and gives the normalized ID
+  // access to the full 9-character base62 space.
+  let hash = fnvOffsetBasis64;
+
+  for (let i = 0; i < value.length; i++) {
+    hash ^= BigInt(value.charCodeAt(i));
+    hash = (hash * fnvPrime64) & fnv64BitMask;
+  }
+
+  let base62Value = hash % normalizedToolCallIdSpace;
+  let result = '';
+
+  for (let i = 0; i < normalizedToolCallIdLength; i++) {
+    result = base62Characters[Number(base62Value % base62Length)] + result;
+    base62Value /= base62Length;
+  }
+
+  return result;
 }