@ai-sdk/anthropic 4.0.57 → 4.0.59

package/dist/internal/index.d.ts

@@ -738,6 +738,17 @@ declare const anthropicResponseSchema: _ai_sdk_provider_utils.LazySchema<{
         path: string;
         reason: string;
     }[] | null | undefined;
+    safeguard_results?: {
+        type: string;
+        status: {
+            type: string;
+            tool_uses?: Record<string, {
+                type: string;
+                outcome?: string | null | undefined;
+                explanation?: string | null | undefined;
+            }> | null | undefined;
+        };
+    }[] | null | undefined;
     container?: {
         expires_at: string;
         id: string;
@@ -844,6 +855,10 @@ declare class AnthropicLanguageModel implements LanguageModelV4 {
                     type: "compact_20260112";
                 })[];
             } | undefined;
+            safeguards?: {
+                classifier_context?: Record<string, unknown> | undefined;
+                type: "dangerous_tool_use";
+            }[] | undefined;
             system: AnthropicTextContent[] | undefined;
             messages: AnthropicMessage[];
             container?: string | {

package/dist/internal/index.js

@@ -141,6 +141,20 @@ var anthropicStopDetailsSchema = z3.object({
   explanation: z3.string().nullish(),
   recommended_model: z3.string().nullish()
 });
+var anthropicSafeguardResultSchema = z3.object({
+  type: z3.string(),
+  status: z3.object({
+    type: z3.string(),
+    tool_uses: z3.record(
+      z3.string(),
+      z3.object({
+        type: z3.string(),
+        outcome: z3.string().nullish(),
+        explanation: z3.string().nullish()
+      })
+    ).nullish()
+  })
+});
 var anthropicToolCallCallerSchema = z3.union([
   z3.object({
     type: z3.literal("code_execution_20250825"),
@@ -474,6 +488,7 @@ var anthropicResponseSchema = lazySchema3(
       stop_sequence: z3.string().nullish(),
       stop_details: anthropicStopDetailsSchema.nullish(),
       input_transformations: z3.array(anthropicInputTransformationSchema).nullish(),
+      safeguard_results: z3.array(anthropicSafeguardResultSchema).nullish(),
       usage: z3.looseObject({
         input_tokens: z3.number(),
         output_tokens: z3.number(),
@@ -857,6 +872,7 @@ var anthropicChunkSchema = lazySchema3(
           stop_reason: z3.string().nullish(),
           stop_sequence: z3.string().nullish(),
           stop_details: anthropicStopDetailsSchema.nullish(),
+          safeguard_results: z3.array(anthropicSafeguardResultSchema).nullish(),
           container: z3.object({
             expires_at: z3.string(),
             id: z3.string(),
@@ -1205,6 +1221,22 @@ var anthropicLanguageModelOptions = z4.object({
    * Allow a provider to receive the full `betas` set if it needs it.
    */
   anthropicBeta: z4.array(z4.string()).optional(),
+  /**
+   * Server-side safeguards to run as part of the request.
+   *
+   * `dangerous_tool_use` asks the API to classify every `tool_use` block in
+   * the response for dangerous actions (the check Claude Code's auto mode
+   * relies on). The per-call verdicts are returned in
+   * `providerMetadata.anthropic.safeguardResults`, keyed by tool call id.
+   * `classifierContext` is passed through to the API as `classifier_context`.
+   * The `dangerous-tool-use-2026-09-03` beta is added automatically.
+   */
+  safeguards: z4.array(
+    z4.object({
+      type: z4.literal("dangerous_tool_use"),
+      classifierContext: z4.record(z4.string(), z4.unknown()).optional()
+    })
+  ).optional(),
   contextManagement: z4.object({
     edits: z4.array(
       z4.discriminatedUnion("type", [
@@ -4237,6 +4269,14 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
       // prompt:
       system: messagesPrompt.system,
       messages: messagesPrompt.messages,
+      ...(anthropicOptions == null ? void 0 : anthropicOptions.safeguards) && anthropicOptions.safeguards.length > 0 && {
+        safeguards: anthropicOptions.safeguards.map((safeguard) => ({
+          type: safeguard.type,
+          ...safeguard.classifierContext !== void 0 && {
+            classifier_context: safeguard.classifierContext
+          }
+        }))
+      },
       ...contextManagement && {
         context_management: {
           edits: contextManagement.edits.map((edit) => {
@@ -4349,6 +4389,9 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     if ((anthropicOptions == null ? void 0 : anthropicOptions.mcpServers) && anthropicOptions.mcpServers.length > 0) {
       betas.add("mcp-client-2025-04-04");
     }
+    if ((anthropicOptions == null ? void 0 : anthropicOptions.safeguards) && anthropicOptions.safeguards.length > 0) {
+      betas.add("dangerous-tool-use-2026-09-03");
+    }
     if (contextManagement) {
       betas.add("context-management-2025-06-27");
       if (contextManagement.edits.some((e) => e.type === "compact_20260112")) {
@@ -4970,6 +5013,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
           stopSequence: (_a2 = response.stop_sequence) != null ? _a2 : null,
           ...stopDetails != null ? { stopDetails } : {},
           ...response.input_transformations != null ? { inputTransformations: response.input_transformations } : {},
+          ...response.safeguard_results != null ? { safeguardResults: response.safeguard_results } : {},
           iterations: response.usage.iterations ? response.usage.iterations.map(
             (iter) => ({
               type: iter.type,
@@ -5056,6 +5100,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
     let stopSequence = null;
     let stopDetails = void 0;
     let inputTransformations;
+    let safeguardResults;
     let container = null;
     let isJsonResponseFromTool = false;
     let isMessageOpen = false;
@@ -5830,6 +5875,9 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
               if (value.input_transformations != null) {
                 inputTransformations = value.input_transformations;
               }
+              if (value.delta.safeguard_results != null) {
+                safeguardResults = value.delta.safeguard_results;
+              }
               rawUsage = {
                 ...rawUsage,
                 ...value.usage
@@ -5844,6 +5892,7 @@ var AnthropicLanguageModel = class _AnthropicLanguageModel {
                 stopSequence,
                 ...stopDetails != null ? { stopDetails } : {},
                 ...inputTransformations != null ? { inputTransformations } : {},
+                ...safeguardResults != null ? { safeguardResults } : {},
                 iterations: usage.iterations ? usage.iterations.map(
                   (iter) => ({
                     type: iter.type,