@ai-sdk/amazon-bedrock 3.0.0-beta.13 → 3.0.0-beta.14

package/dist/index.mjs

@@ -5,6 +5,7 @@ import {
   loadSetting,
   withoutTrailingSlash
 } from "@ai-sdk/provider-utils";
+import { anthropicTools as anthropicTools2 } from "@ai-sdk/anthropic/internal";
 
 // src/bedrock-chat-language-model.ts
 import {
@@ -152,90 +153,143 @@ var createBedrockEventStreamResponseHandler = (chunkSchema) => async ({ response
 import {
   UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
-function promptContainsToolContent(prompt) {
-  return prompt.some((message) => {
-    if ("content" in message && Array.isArray(message.content)) {
-      return message.content.some(
-        (part) => part.type === "tool-call" || part.type === "tool-result"
-      );
-    }
-    return false;
-  });
-}
+import { asSchema } from "@ai-sdk/provider-utils";
+import {
+  anthropicTools,
+  prepareTools as prepareAnthropicTools
+} from "@ai-sdk/anthropic/internal";
 function prepareTools({
   tools,
   toolChoice,
-  prompt
+  modelId
 }) {
-  tools = (tools == null ? void 0 : tools.length) ? tools : void 0;
-  const hasToolContent = promptContainsToolContent(prompt);
-  if (tools == null) {
+  const toolWarnings = [];
+  const betas = /* @__PURE__ */ new Set();
+  if (tools == null || tools.length === 0) {
     return {
-      toolConfig: {
-        tools: void 0,
-        toolChoice: void 0
-      },
-      toolWarnings: []
+      toolConfig: {},
+      additionalTools: void 0,
+      betas,
+      toolWarnings
     };
   }
-  const toolWarnings = [];
-  const bedrockTools = [];
-  for (const tool of tools) {
-    if (tool.type === "provider-defined") {
-      toolWarnings.push({ type: "unsupported-tool", tool });
-    } else {
-      bedrockTools.push({
-        toolSpec: {
-          name: tool.name,
-          description: tool.description,
-          inputSchema: {
-            json: tool.inputSchema
-          }
-        }
+  const supportedTools = tools.filter((tool) => {
+    if (tool.type === "provider-defined" && tool.id === "anthropic.web_search_20250305") {
+      toolWarnings.push({
+        type: "unsupported-tool",
+        tool,
+        details: "The web_search_20250305 tool is not supported on Amazon Bedrock."
       });
+      return false;
     }
-  }
-  if (toolChoice == null) {
+    return true;
+  });
+  if (supportedTools.length === 0) {
     return {
-      toolConfig: { tools: bedrockTools, toolChoice: void 0 },
+      toolConfig: {},
+      additionalTools: void 0,
+      betas,
       toolWarnings
     };
   }
-  const type = toolChoice.type;
-  switch (type) {
-    case "auto":
-      return {
-        toolConfig: { tools: bedrockTools, toolChoice: { auto: {} } },
-        toolWarnings
-      };
-    case "required":
-      return {
-        toolConfig: { tools: bedrockTools, toolChoice: { any: {} } },
-        toolWarnings
-      };
-    case "none":
-      return {
-        toolConfig: {
-          tools: void 0,
-          toolChoice: void 0
-        },
-        toolWarnings
-      };
-    case "tool":
-      return {
-        toolConfig: {
-          tools: bedrockTools,
-          toolChoice: { tool: { name: toolChoice.toolName } }
-        },
-        toolWarnings
+  const isAnthropicModel = modelId.includes("anthropic.");
+  const providerDefinedTools = supportedTools.filter(
+    (t) => t.type === "provider-defined"
+  );
+  const functionTools = supportedTools.filter((t) => t.type === "function");
+  let additionalTools = void 0;
+  const bedrockTools = [];
+  const usingAnthropicTools = isAnthropicModel && providerDefinedTools.length > 0;
+  if (usingAnthropicTools) {
+    if (functionTools.length > 0) {
+      toolWarnings.push({
+        type: "unsupported-setting",
+        setting: "tools",
+        details: "Mixed Anthropic provider-defined tools and standard function tools are not supported in a single call to Bedrock. Only Anthropic tools will be used."
+      });
+    }
+    const {
+      toolChoice: preparedAnthropicToolChoice,
+      toolWarnings: anthropicToolWarnings,
+      betas: anthropicBetas
+    } = prepareAnthropicTools({
+      tools: providerDefinedTools,
+      toolChoice
+    });
+    toolWarnings.push(...anthropicToolWarnings);
+    anthropicBetas.forEach((beta) => betas.add(beta));
+    if (preparedAnthropicToolChoice) {
+      additionalTools = {
+        tool_choice: preparedAnthropicToolChoice
       };
-    default: {
-      const _exhaustiveCheck = type;
-      throw new UnsupportedFunctionalityError({
-        functionality: `tool choice type: ${_exhaustiveCheck}`
+    }
+    for (const tool of providerDefinedTools) {
+      const toolFactory = Object.values(anthropicTools).find((factory) => {
+        const instance = factory({});
+        return instance.id === tool.id;
       });
+      if (toolFactory != null) {
+        const fullToolDefinition = toolFactory({});
+        bedrockTools.push({
+          toolSpec: {
+            name: tool.name,
+            inputSchema: {
+              json: asSchema(fullToolDefinition.inputSchema).jsonSchema
+            }
+          }
+        });
+      } else {
+        toolWarnings.push({ type: "unsupported-tool", tool });
+      }
+    }
+  } else {
+    for (const tool of providerDefinedTools) {
+      toolWarnings.push({ type: "unsupported-tool", tool });
     }
   }
+  for (const tool of functionTools) {
+    bedrockTools.push({
+      toolSpec: {
+        name: tool.name,
+        description: tool.description,
+        inputSchema: {
+          json: tool.inputSchema
+        }
+      }
+    });
+  }
+  let bedrockToolChoice = void 0;
+  if (!usingAnthropicTools && bedrockTools.length > 0 && toolChoice) {
+    const type = toolChoice.type;
+    switch (type) {
+      case "auto":
+        bedrockToolChoice = { auto: {} };
+        break;
+      case "required":
+        bedrockToolChoice = { any: {} };
+        break;
+      case "none":
+        bedrockTools.length = 0;
+        bedrockToolChoice = void 0;
+        break;
+      case "tool":
+        bedrockToolChoice = { tool: { name: toolChoice.toolName } };
+        break;
+      default: {
+        const _exhaustiveCheck = type;
+        throw new UnsupportedFunctionalityError({
+          functionality: `tool choice type: ${_exhaustiveCheck}`
+        });
+      }
+    }
+  }
+  const toolConfig = bedrockTools.length > 0 ? { tools: bedrockTools, toolChoice: bedrockToolChoice } : {};
+  return {
+    toolConfig,
+    additionalTools,
+    betas,
+    toolWarnings
+  };
 }
 
 // src/convert-to-bedrock-chat-messages.ts
@@ -592,7 +646,7 @@ var BedrockChatLanguageModel = class {
     toolChoice,
     providerOptions
   }) {
-    var _a, _b, _c, _d;
+    var _a, _b, _c, _d, _e, _f;
     const bedrockOptions = (_a = await parseProviderOptions2({
       provider: "bedrock",
       providerOptions,
@@ -644,6 +698,18 @@ var BedrockChatLanguageModel = class {
       description: "Respond with a JSON object.",
       inputSchema: responseFormat.schema
     } : void 0;
+    const { toolConfig, additionalTools, toolWarnings, betas } = prepareTools({
+      tools: jsonResponseTool ? [jsonResponseTool, ...tools != null ? tools : []] : tools,
+      toolChoice: jsonResponseTool != null ? { type: "tool", toolName: jsonResponseTool.name } : toolChoice,
+      modelId: this.modelId
+    });
+    warnings.push(...toolWarnings);
+    if (additionalTools) {
+      bedrockOptions.additionalModelRequestFields = {
+        ...bedrockOptions.additionalModelRequestFields,
+        ...additionalTools
+      };
+    }
     const isThinking = ((_b = bedrockOptions.reasoningConfig) == null ? void 0 : _b.type) === "enabled";
     const thinkingBudget = (_c = bedrockOptions.reasoningConfig) == null ? void 0 : _c.budgetTokens;
     const inferenceConfig = {
@@ -682,9 +748,9 @@ var BedrockChatLanguageModel = class {
         details: "topP is not supported when thinking is enabled"
       });
     }
-    const activeTools = jsonResponseTool != null ? [jsonResponseTool] : tools != null ? tools : [];
+    const hasAnyTools = ((_f = (_e = toolConfig.tools) == null ? void 0 : _e.length) != null ? _f : 0) > 0 || additionalTools;
     let filteredPrompt = prompt;
-    if (activeTools.length === 0) {
+    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"
@@ -709,11 +775,6 @@ var BedrockChatLanguageModel = class {
       }
     }
     const { system, messages } = await convertToBedrockChatMessages(filteredPrompt);
-    const { toolConfig, toolWarnings } = prepareTools({
-      tools: activeTools,
-      toolChoice: jsonResponseTool != null ? { type: "tool", toolName: jsonResponseTool.name } : toolChoice,
-      prompt: filteredPrompt
-    });
     const { reasoningConfig: _, ...filteredBedrockOptions } = (providerOptions == null ? void 0 : providerOptions.bedrock) || {};
     return {
       command: {
@@ -724,26 +785,35 @@ var BedrockChatLanguageModel = class {
           inferenceConfig
         },
         ...filteredBedrockOptions,
-        ...toolConfig.tools !== void 0 ? { toolConfig } : {}
+        ...toolConfig.tools !== void 0 && toolConfig.tools.length > 0 ? { toolConfig } : {}
       },
-      warnings: [...warnings, ...toolWarnings],
-      usesJsonResponseTool: jsonResponseTool != null
+      warnings,
+      usesJsonResponseTool: jsonResponseTool != null,
+      betas
     };
   }
+  async getHeaders({
+    betas,
+    headers
+  }) {
+    return combineHeaders(
+      await resolve(this.config.headers),
+      betas.size > 0 ? { "anthropic-beta": Array.from(betas).join(",") } : {},
+      headers
+    );
+  }
   async doGenerate(options) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
     const {
       command: args,
       warnings,
-      usesJsonResponseTool
+      usesJsonResponseTool,
+      betas
     } = await this.getArgs(options);
     const url = `${this.getUrl(this.modelId)}/converse`;
     const { value: response, responseHeaders } = await postJsonToApi({
       url,
-      headers: combineHeaders(
-        await resolve(this.config.headers),
-        options.headers
-      ),
+      headers: await this.getHeaders({ betas, headers: options.headers }),
       body: args,
       failedResponseHandler: createJsonErrorResponseHandler({
         errorSchema: BedrockErrorSchema,
@@ -840,15 +910,13 @@ var BedrockChatLanguageModel = class {
     const {
       command: args,
       warnings,
-      usesJsonResponseTool
+      usesJsonResponseTool,
+      betas
     } = await this.getArgs(options);
     const url = `${this.getUrl(this.modelId)}/converse-stream`;
     const { value: response, responseHeaders } = await postJsonToApi({
       url,
-      headers: combineHeaders(
-        await resolve(this.config.headers),
-        options.headers
-      ),
+      headers: await this.getHeaders({ betas, headers: options.headers }),
       body: args,
       failedResponseHandler: createJsonErrorResponseHandler({
         errorSchema: BedrockErrorSchema,
@@ -1602,6 +1670,7 @@ Original error: ${errorMessage}`
   provider.textEmbeddingModel = createEmbeddingModel;
   provider.image = createImageModel;
   provider.imageModel = createImageModel;
+  provider.tools = anthropicTools2;
   return provider;
 }
 var bedrock = createAmazonBedrock();