import { Experimental_SandboxSession, FetchFunction, InferSchema, ProviderDefinedTool, Resolvable, Tool, ToolExecuteFunction, WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from "@ai-sdk/provider-utils";
import { z } from "zod/v4";
import { FilesV4, FilesV4UploadFileCallOptions, FilesV4UploadFileResult, JSONObject, JSONSchema7, LanguageModelV4, LanguageModelV4CallOptions, LanguageModelV4FilePart, LanguageModelV4GenerateResult, LanguageModelV4StreamResult, SharedV4ProviderMetadata, SharedV4Warning, SkillsV4 } from "@ai-sdk/provider";
//#region src/anthropic-files.d.ts
interface AnthropicFilesConfig {
  provider: string;
  baseURL: string;
  headers: Resolvable<Record<string, string | undefined>>;
  fetch?: FetchFunction;
}
export declare class AnthropicFiles implements FilesV4 {
  private readonly config;
  readonly specificationVersion = "v4";
  get provider(): string;
  constructor(config: AnthropicFilesConfig);
  uploadFile({ data, mediaType, filename, abortSignal, headers }: FilesV4UploadFileCallOptions): Promise<FilesV4UploadFileResult>;
}
//#endregion
//#region src/anthropic-api.d.ts
type AnthropicMessage = AnthropicUserMessage | AnthropicAssistantMessage | AnthropicSystemMessage;
type AnthropicCacheControl = {
  type: 'ephemeral';
  ttl?: '5m' | '1h';
};
interface AnthropicSystemMessage {
  role: 'system';
  content: Array<AnthropicTextContent | AnthropicToolChangeContent>;
  clear_at?: 'next_user_message';
  output_config?: {
    effort: 'low' | 'medium' | 'high' | 'xhigh' | 'max';
  };
}
/**
 * Mid-conversation tool change content block. Adds or removes a tool from the
 * conversation's tool set without invalidating the prompt cache.
 *
 * Only valid inside system messages that appear in the `messages` array.
 * Requires the `mid-conversation-tool-changes-2026-07-01` beta.
 */
interface AnthropicToolChangeContent {
  type: 'tool_addition' | 'tool_removal';
  tool: {
    type: 'tool_reference';
    name: string;
  };
  cache_control?: never;
}
interface AnthropicUserMessage {
  role: 'user';
  content: Array<AnthropicTextContent | AnthropicImageContent | AnthropicVideoContent | AnthropicDocumentContent | AnthropicContainerUploadContent | AnthropicToolResultContent>;
}
interface AnthropicAssistantMessage {
  role: 'assistant';
  content: Array<AnthropicTextContent | AnthropicThinkingContent | AnthropicRedactedThinkingContent | AnthropicFallbackContent | AnthropicToolCallContent | AnthropicServerToolUseContent | AnthropicCodeExecutionToolResultContent | AnthropicWebFetchToolResultContent | AnthropicWebSearchToolResultContent | AnthropicToolSearchToolResultContent | AnthropicBashCodeExecutionToolResultContent | AnthropicTextEditorCodeExecutionToolResultContent | AnthropicAdvisorToolResultContent | AnthropicMcpToolUseContent | AnthropicMcpToolResultContent | AnthropicCompactionContent>;
}
declare const anthropicFallbackContentSchema: () => z.ZodObject<{
  type: z.ZodLiteral<"fallback">;
  from: z.ZodObject<{
    model: z.ZodString;
  }, z.core.$strip>;
  to: z.ZodObject<{
    model: z.ZodString;
  }, z.core.$strip>;
}, z.core.$strip>;
type AnthropicFallbackContent = InferSchema<ReturnType<typeof anthropicFallbackContentSchema>> & {
  cache_control?: never;
};
interface AnthropicCompactionContent {
  type: 'compaction';
  content: string;
  signature?: string;
  cache_control?: AnthropicCacheControl;
}
interface AnthropicTextContent {
  type: 'text';
  text: string;
  citations?: Citation[];
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicThinkingContent {
  type: 'thinking';
  thinking: string;
  signature: string;
  cache_control?: never;
}
interface AnthropicRedactedThinkingContent {
  type: 'redacted_thinking';
  data: string;
  cache_control?: never;
}
type AnthropicContentSource = {
  type: 'base64';
  media_type: string;
  data: string;
} | {
  type: 'url';
  url: string;
} | {
  type: 'text';
  media_type: 'text/plain';
  data: string;
} | {
  type: 'file';
  file_id: string;
};
interface AnthropicImageContent {
  type: 'image';
  source: AnthropicContentSource;
  cache_control: AnthropicCacheControl | undefined;
}
/** Video blocks supplied by compatible providers through custom media conversion. */
interface AnthropicVideoContent {
  type: 'video';
  source: AnthropicContentSource;
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicDocumentContent {
  type: 'document';
  source: AnthropicContentSource;
  title?: string;
  context?: string;
  citations?: {
    enabled: boolean;
  };
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicContainerUploadContent {
  type: 'container_upload';
  file_id: string;
  cache_control?: never;
}
/**
 * The caller information for programmatic tool calling.
 * Present when a tool is called from within code execution.
 */
type AnthropicToolCallCaller = {
  type: 'code_execution_20250825';
  tool_id: string;
} | {
  type: 'code_execution_20260120';
  tool_id: string;
} | {
  type: 'direct';
};
interface AnthropicToolCallContent {
  type: 'tool_use';
  id: string;
  name: string;
  input: unknown;
  /**
   * Present when this tool call was triggered by a server-executed tool
   * (e.g., code execution calling a user-defined tool programmatically).
   */
  caller?: AnthropicToolCallCaller;
  /**
   * Present when this tool call is a member call of a toolset
   * (e.g. `computer` for the computer toolset). `name` is then the member name.
   */
  toolset_name?: string;
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicServerToolUseContent {
  type: 'server_tool_use';
  id: string;
  name: 'web_fetch' | 'web_search' | 'code_execution' | 'bash_code_execution' | 'text_editor_code_execution' | 'tool_search_tool_regex' | 'tool_search_tool_bm25' | 'advisor';
  input: unknown;
  caller?: AnthropicToolCallCaller;
  cache_control: AnthropicCacheControl | undefined;
}
type AnthropicNestedTextContent = Omit<AnthropicTextContent, 'cache_control'> & {
  cache_control?: never;
};
type AnthropicNestedImageContent = Omit<AnthropicImageContent, 'cache_control'> & {
  cache_control?: never;
};
type AnthropicNestedDocumentContent = Omit<AnthropicDocumentContent, 'cache_control'> & {
  cache_control?: never;
};
interface AnthropicToolReferenceContent {
  type: 'tool_reference';
  tool_name: string;
}
interface AnthropicToolResultContent {
  type: 'tool_result';
  tool_use_id: string;
  /**
   * Required for results of toolset member calls (e.g. `computer`).
   */
  toolset_name?: string;
  content: string | Array<AnthropicNestedTextContent | AnthropicNestedImageContent | AnthropicNestedDocumentContent | AnthropicToolReferenceContent>;
  is_error: boolean | undefined;
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicWebSearchToolResultContent {
  type: 'web_search_tool_result';
  tool_use_id: string;
  content: Array<{
    url: string;
    title: string | null;
    page_age: string | null;
    encrypted_content: string;
    type: string;
  }> | {
    type: 'web_search_tool_result_error';
    error_code: string;
  };
  caller?: AnthropicToolCallCaller;
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicToolSearchToolResultContent {
  type: 'tool_search_tool_result';
  tool_use_id: string;
  content: {
    type: 'tool_search_tool_search_result';
    tool_references: Array<{
      type: 'tool_reference';
      tool_name: string;
    }>;
  } | {
    type: 'tool_search_tool_result_error';
    error_code: string;
  };
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicCodeExecutionToolResultContent {
  type: 'code_execution_tool_result';
  tool_use_id: string;
  content: {
    type: 'code_execution_result';
    stdout: string;
    stderr: string;
    return_code: number;
    content: Array<{
      type: 'code_execution_output';
      file_id: string;
    }>;
  } | {
    type: 'encrypted_code_execution_result';
    encrypted_stdout: string;
    stderr: string;
    return_code: number;
    content: Array<{
      type: 'code_execution_output';
      file_id: string;
    }>;
  } | {
    type: 'code_execution_tool_result_error';
    error_code: string;
  };
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicTextEditorCodeExecutionToolResultContent {
  type: 'text_editor_code_execution_tool_result';
  tool_use_id: string;
  content: {
    type: 'text_editor_code_execution_tool_result_error';
    error_code: string;
  } | {
    type: 'text_editor_code_execution_create_result';
    is_file_update: boolean;
  } | {
    type: 'text_editor_code_execution_view_result';
    content: string;
    file_type: string;
    num_lines: number | null;
    start_line: number | null;
    total_lines: number | null;
  } | {
    type: 'text_editor_code_execution_str_replace_result';
    lines: string[] | null;
    new_lines: number | null;
    new_start: number | null;
    old_lines: number | null;
    old_start: number | null;
  };
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicBashCodeExecutionToolResultContent {
  type: 'bash_code_execution_tool_result';
  tool_use_id: string;
  content: {
    type: 'bash_code_execution_result';
    stdout: string;
    stderr: string;
    return_code: number;
    content: {
      type: 'bash_code_execution_output';
      file_id: string;
    }[];
  } | {
    type: 'bash_code_execution_tool_result_error';
    error_code: string;
  };
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicAdvisorToolResultContent {
  type: 'advisor_tool_result';
  tool_use_id: string;
  content: {
    type: 'advisor_result';
    text: string;
    stop_reason?: string;
  } | {
    type: 'advisor_redacted_result';
    encrypted_content: string;
    stop_reason?: string;
  } | {
    type: 'advisor_tool_result_error';
    /**
     * Available options: `max_uses_exceeded`, `too_many_requests`,
     * `overloaded`, `prompt_too_long`, `execution_time_exceeded`,
     * `unavailable`.
     */
    error_code: string;
  };
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicWebFetchToolResultContent {
  type: 'web_fetch_tool_result';
  tool_use_id: string;
  content: {
    type: 'web_fetch_result';
    url: string;
    retrieved_at: string | null;
    content: {
      type: 'document';
      title: string | null;
      citations?: {
        enabled: boolean;
      };
      source: {
        type: 'base64';
        media_type: 'application/pdf';
        data: string;
      } | {
        type: 'text';
        media_type: 'text/plain';
        data: string;
      };
    };
  } | {
    type: 'web_fetch_tool_result_error';
    error_code: string;
  };
  caller?: AnthropicToolCallCaller;
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicMcpToolUseContent {
  type: 'mcp_tool_use';
  id: string;
  name: string;
  server_name: string;
  input: unknown;
  cache_control: AnthropicCacheControl | undefined;
}
interface AnthropicMcpToolResultContent {
  type: 'mcp_tool_result';
  tool_use_id: string;
  is_error: boolean;
  content: string | Array<{
    type: 'text';
    text: string;
    citations?: Citation[] | null;
  }>;
  cache_control: AnthropicCacheControl | undefined;
}
type AnthropicTool = {
  name: string;
  description: string | undefined;
  input_schema: JSONSchema7;
  cache_control: AnthropicCacheControl | undefined;
  eager_input_streaming?: boolean;
  strict?: boolean;
  /**
   * When true, this tool is deferred and will only be loaded when
   * discovered via the tool search tool.
   */
  defer_loading?: boolean;
  /**
   * Programmatic tool calling: specifies which server-executed tools
   * are allowed to call this tool. When set, only the specified callers
   * can invoke this tool programmatically.
   *
   * @example ['code_execution_20250825']
   */
  allowed_callers?: Array<'direct' | 'code_execution_20250825' | 'code_execution_20260120'>;
} | {
  type: 'code_execution_20250522';
  name: string;
  cache_control: AnthropicCacheControl | undefined;
} | {
  type: 'code_execution_20250825';
  name: string;
} | {
  type: 'code_execution_20260120';
  name: string;
} | {
  name: string;
  type: 'computer_20250124' | 'computer_20241022';
  display_width_px: number;
  display_height_px: number;
  display_number: number;
  cache_control: AnthropicCacheControl | undefined;
} | {
  name: string;
  type: 'computer_20251124';
  display_width_px: number;
  display_height_px: number;
  display_number: number;
  enable_zoom?: boolean;
  cache_control: AnthropicCacheControl | undefined;
} | {
  /**
   * Computer toolset. Declared without a `name`; the API returns member
   * tool calls (e.g. `left_click`) with `toolset_name: 'computer'`.
   */
  type: 'computer_toolset_20260801';
  configs?: Record<string, {
    enabled?: boolean;
    defer_loading?: boolean;
  }>;
  cache_control: AnthropicCacheControl | undefined;
} | {
  name: string;
  type: 'text_editor_20250124' | 'text_editor_20241022' | 'text_editor_20250429';
  cache_control: AnthropicCacheControl | undefined;
} | {
  name: string;
  type: 'text_editor_20250728';
  max_characters?: number;
  cache_control: AnthropicCacheControl | undefined;
} | {
  name: string;
  type: 'bash_20250124' | 'bash_20241022';
  cache_control: AnthropicCacheControl | undefined;
} | {
  name: string;
  type: 'memory_20250818';
} | {
  type: 'web_fetch_20250910' | 'web_fetch_20260209' | 'web_fetch_20260318';
  name: string;
  max_uses?: number;
  allowed_domains?: string[];
  blocked_domains?: string[];
  citations?: {
    enabled: boolean;
  };
  max_content_tokens?: number;
  use_cache?: boolean;
  response_inclusion?: 'full' | 'excluded';
  cache_control: AnthropicCacheControl | undefined;
} | {
  type: 'web_search_20250305' | 'web_search_20260209' | 'web_search_20260318';
  name: string;
  max_uses?: number;
  allowed_domains?: string[];
  blocked_domains?: string[];
  user_location?: {
    type: 'approximate';
    city?: string;
    region?: string;
    country?: string;
    timezone?: string;
  };
  response_inclusion?: 'full' | 'excluded';
  cache_control: AnthropicCacheControl | undefined;
} | {
  type: 'tool_search_tool_regex_20251119';
  name: string;
} | {
  type: 'tool_search_tool_bm25_20251119';
  name: string;
} | {
  type: 'advisor_20260301';
  name: 'advisor';
  model: string;
  max_uses?: number;
  max_tokens?: number;
  caching?: {
    type: 'ephemeral';
    ttl: '5m' | '1h';
  };
};
type AnthropicToolChoice = {
  type: 'auto' | 'any';
  disable_parallel_tool_use?: boolean;
} | {
  type: 'none';
} | {
  type: 'tool';
  name: string;
  disable_parallel_tool_use?: boolean;
};
declare const anthropicResponseSchema: import("@ai-sdk/provider-utils").LazySchema<{
  type: "message";
  content: ({
    type: "fallback";
    from: {
      model: string;
    };
    to: {
      model: string;
    };
  } | {
    type: "text";
    text: string;
    citations?: ({
      type: "web_search_result_location";
      cited_text: string;
      url: string;
      title: string | null;
      encrypted_index: string;
    } | {
      type: "page_location";
      cited_text: string;
      document_index: number;
      document_title: string | null;
      start_page_number: number;
      end_page_number: number;
      file_id?: string | null | undefined;
    } | {
      type: "char_location";
      cited_text: string;
      document_index: number;
      document_title: string | null;
      start_char_index: number;
      end_char_index: number;
      file_id?: string | null | undefined;
    } | {
      type: "content_block_location";
      cited_text: string;
      document_index: number;
      document_title: string | null;
      start_block_index: number;
      end_block_index: number;
      file_id: string | null;
    } | {
      type: "search_result_location";
      cited_text: string;
      search_result_index: number;
      source: string;
      title: string | null;
      start_block_index: number;
      end_block_index: number;
    })[] | null | undefined;
  } | {
    type: "thinking";
    thinking: string;
    signature: string;
  } | {
    type: "redacted_thinking";
    data: string;
  } | {
    type: "compaction";
    content?: string | null | undefined;
    signature?: string | null | undefined;
  } | {
    type: "tool_use";
    id: string;
    name: string;
    input: unknown;
    caller?: {
      type: "code_execution_20250825";
      tool_id: string;
    } | {
      type: "code_execution_20260120";
      tool_id: string;
    } | {
      type: "direct";
    } | undefined;
    toolset_name?: string | null | undefined;
  } | {
    type: "server_tool_use";
    id: string;
    name: string;
    input?: Record<string, unknown> | null | undefined;
    caller?: {
      type: "code_execution_20250825";
      tool_id: string;
    } | {
      type: "code_execution_20260120";
      tool_id: string;
    } | {
      type: "direct";
    } | undefined;
  } | {
    type: "mcp_tool_use";
    id: string;
    name: string;
    input: unknown;
    server_name: string;
  } | {
    type: "mcp_tool_result";
    tool_use_id: string;
    is_error: boolean;
    content: string | (string | {
      type: "text";
      text: string;
      citations?: z.core.util.JSONType[] | null | undefined;
    })[];
  } | {
    type: "web_fetch_tool_result";
    tool_use_id: string;
    content: {
      type: "web_fetch_result";
      url: string;
      retrieved_at: string | null;
      content: {
        type: "document";
        title: string | null;
        source: {
          type: "base64";
          media_type: "application/pdf";
          data: string;
        } | {
          type: "text";
          media_type: "text/plain";
          data: string;
        };
        citations?: {
          enabled: boolean;
        } | undefined;
      };
    } | {
      type: "web_fetch_tool_result_error";
      error_code: string;
    };
    caller?: {
      type: "code_execution_20250825";
      tool_id: string;
    } | {
      type: "code_execution_20260120";
      tool_id: string;
    } | {
      type: "direct";
    } | undefined;
  } | {
    type: "web_search_tool_result";
    tool_use_id: string;
    content: {
      type: "web_search_result";
      url: string;
      title: string | null;
      encrypted_content: string;
      page_age?: string | null | undefined;
    }[] | {
      type: "web_search_tool_result_error";
      error_code: string;
    };
    caller?: {
      type: "code_execution_20250825";
      tool_id: string;
    } | {
      type: "code_execution_20260120";
      tool_id: string;
    } | {
      type: "direct";
    } | undefined;
  } | {
    type: "code_execution_tool_result";
    tool_use_id: string;
    content: {
      type: "code_execution_result";
      stdout: string;
      stderr: string;
      return_code: number;
      content: {
        type: "code_execution_output";
        file_id: string;
      }[];
    } | {
      type: "encrypted_code_execution_result";
      encrypted_stdout: string;
      stderr: string;
      return_code: number;
      content: {
        type: "code_execution_output";
        file_id: string;
      }[];
    } | {
      type: "code_execution_tool_result_error";
      error_code: string;
    };
  } | {
    type: "bash_code_execution_tool_result";
    tool_use_id: string;
    content: {
      type: "bash_code_execution_result";
      content: {
        type: "bash_code_execution_output";
        file_id: string;
      }[];
      stdout: string;
      stderr: string;
      return_code: number;
    } | {
      type: "bash_code_execution_tool_result_error";
      error_code: string;
    };
  } | {
    type: "text_editor_code_execution_tool_result";
    tool_use_id: string;
    content: {
      type: "text_editor_code_execution_tool_result_error";
      error_code: string;
    } | {
      type: "text_editor_code_execution_view_result";
      content: string;
      file_type: string;
      num_lines: number | null;
      start_line: number | null;
      total_lines: number | null;
    } | {
      type: "text_editor_code_execution_create_result";
      is_file_update: boolean;
    } | {
      type: "text_editor_code_execution_str_replace_result";
      lines: string[] | null;
      new_lines: number | null;
      new_start: number | null;
      old_lines: number | null;
      old_start: number | null;
    };
  } | {
    type: "tool_search_tool_result";
    tool_use_id: string;
    content: {
      type: "tool_search_tool_search_result";
      tool_references: {
        type: "tool_reference";
        tool_name: string;
      }[];
    } | {
      type: "tool_search_tool_result_error";
      error_code: string;
    };
  } | {
    type: "container_upload";
    file_id: string;
  } | {
    type: "advisor_tool_result";
    tool_use_id: string;
    content: {
      type: "advisor_result";
      text: string;
      stop_reason?: string | null | undefined;
    } | {
      type: "advisor_redacted_result";
      encrypted_content: string;
      stop_reason?: string | null | undefined;
    } | {
      type: "advisor_tool_result_error";
      error_code: string;
    };
  })[];
  usage: {
    [x: string]: unknown;
    input_tokens: number;
    output_tokens: number;
    output_tokens_details?: {
      thinking_tokens?: number | null | undefined;
    } | null | undefined;
    cache_creation_input_tokens?: number | null | undefined;
    cache_read_input_tokens?: number | null | undefined;
    iterations?: {
      type: "message" | "compaction" | "advisor_message" | "fallback_message";
      input_tokens: number;
      output_tokens: number;
      model?: string | null | undefined;
      cache_creation_input_tokens?: number | null | undefined;
      cache_read_input_tokens?: number | null | undefined;
    }[] | null | undefined;
  };
  id?: string | null | undefined;
  model?: string | null | undefined;
  stop_reason?: string | null | undefined;
  stop_sequence?: string | null | undefined;
  stop_details?: {
    type: string;
    category?: string | null | undefined;
    explanation?: string | null | undefined;
    recommended_model?: string | null | undefined;
  } | null | undefined;
  input_transformations?: {
    type: string;
    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;
    skills?: {
      type: "anthropic" | "custom";
      skill_id: string;
      version: string;
    }[] | null | undefined;
  } | null | undefined;
  context_management?: {
    applied_edits: ({
      type: "clear_tool_uses_20250919";
      cleared_tool_uses: number;
      cleared_input_tokens: number;
    } | {
      type: "clear_thinking_20251015";
      cleared_thinking_turns: number;
      cleared_input_tokens: number;
    } | {
      type: "compact_20260112";
    })[];
  } | null | undefined;
}>;
type Citation = NonNullable<(InferSchema<typeof anthropicResponseSchema>['content'][number] & {
  type: 'text';
})['citations']>[number];
//#endregion
//#region src/anthropic-language-model-options.d.ts
type AnthropicModelId = 'claude-3-haiku-20240307' | 'claude-haiku-4-5-20251001' | 'claude-haiku-4-5' | 'claude-haiku-5-5' | 'claude-opus-4-0' | 'claude-opus-4-20250514' | 'claude-opus-4-1-20250805' | 'claude-opus-4-1' | 'claude-opus-4-5' | 'claude-opus-4-5-20251101' | 'claude-sonnet-4-0' | 'claude-sonnet-4-20250514' | 'claude-sonnet-4-5-20250929' | 'claude-sonnet-4-5' | 'claude-sonnet-4-6' | 'claude-opus-4-6' | 'claude-opus-4-7' | 'claude-opus-4-8' | 'claude-opus-5' | 'claude-opus-5-5' | 'claude-fable-5' | 'claude-fable-5-1' | 'claude-sonnet-5' | 'claude-sonnet-5-5' | (string & {});
//#endregion
//#region src/get-cache-control.d.ts
declare class CacheControlValidator {
  private readonly providerOptionsName;
  private breakpointCount;
  private warnings;
  constructor(providerOptionsName?: string);
  getCacheControl(providerMetadata: SharedV4ProviderMetadata | undefined, context: {
    type: string;
    canCache: boolean;
  }): AnthropicCacheControl | undefined;
  getWarnings(): SharedV4Warning[];
}
//#endregion
//#region src/convert-to-anthropic-prompt.d.ts
/** Return undefined to use the default file conversion. */
type AnthropicMediaPartConverter = (part: LanguageModelV4FilePart) => PromiseLike<Omit<AnthropicImageContent | AnthropicVideoContent, 'cache_control'> | undefined>;
//#endregion
//#region src/anthropic-language-model.d.ts
type AnthropicLanguageModelConfig = {
  provider: string;
  baseURL: string;
  headers?: Resolvable<Record<string, string | undefined>>;
  fetch?: FetchFunction;
  buildRequestUrl?: (baseURL: string, isStreaming: boolean) => string;
  /** Custom media conversion for compatible providers; undefined uses the default. */
  convertMediaPart?: AnthropicMediaPartConverter;
  transformRequestBody?: (args: Record<string, any>, betas: Set<string>) => Record<string, any>;
  transformRequestHeaders?: (headers: Record<string, string | undefined>, providerOptions: LanguageModelV4CallOptions['providerOptions']) => Record<string, string | undefined> | PromiseLike<Record<string, string | undefined>>;
  supportedUrls?: () => LanguageModelV4['supportedUrls'];
  generateId?: () => string;
  supportsNativeStructuredOutput?: boolean;
  supportsStrictTools?: boolean;
  /** Maximum temperature for compatible providers. Defaults to 1. */
  maxTemperature?: number;
  /** Preserve temperature and topP with thinking for compatible providers. */
  supportsTemperatureAndTopPWithThinking?: boolean;
  /** Cache option namespace for compatible providers. Defaults to anthropic. */
  cacheControlProviderOptionsName?: string;
};
export declare class AnthropicLanguageModel implements LanguageModelV4 {
  readonly specificationVersion = "v4";
  readonly modelId: AnthropicModelId;
  protected readonly config: AnthropicLanguageModelConfig;
  protected readonly generateId: () => string;
  static [WORKFLOW_SERIALIZE](model: AnthropicLanguageModel): {
    modelId: string;
    config: JSONObject;
  };
  static [WORKFLOW_DESERIALIZE](options: {
    modelId: AnthropicModelId;
    config: AnthropicLanguageModelConfig;
  }): AnthropicLanguageModel;
  constructor(modelId: AnthropicModelId, config: AnthropicLanguageModelConfig);
  supportsUrl(url: URL): boolean;
  get provider(): string;
  get supportedUrls(): Record<string, RegExp[]> | PromiseLike<Record<string, RegExp[]>>;
  static prepareRequest({ modelId, config, options: { userSuppliedBetas, prompt, maxOutputTokens, temperature, topP, topK, frequencyPenalty, presencePenalty, stopSequences, responseFormat, seed, tools, toolChoice, reasoning, providerOptions, stream } }: {
    modelId: AnthropicModelId;
    config: AnthropicLanguageModelConfig;
    options: LanguageModelV4CallOptions & {
      stream: boolean;
      userSuppliedBetas: Set<string>;
    };
  }): Promise<{
    args: {
      tools: AnthropicTool[] | undefined;
      tool_choice: AnthropicToolChoice | undefined;
      stream: boolean | undefined;
      context_management?: {
        edits: ({
          exclude_tools?: string[] | undefined;
          clear_tool_inputs?: boolean | undefined;
          clear_at_least?: {
            type: "input_tokens";
            value: number;
          } | undefined;
          keep?: {
            type: "tool_uses";
            value: number;
          } | undefined;
          trigger?: {
            type: "input_tokens";
            value: number;
          } | {
            type: "tool_uses";
            value: number;
          } | undefined;
          type: "clear_tool_uses_20250919";
        } | {
          keep?: "all" | {
            type: "thinking_turns";
            value: number;
          } | undefined;
          type: "clear_thinking_20251015";
        } | {
          instructions?: string | undefined;
          pause_after_compaction?: boolean | undefined;
          trigger?: {
            type: "input_tokens";
            value: number;
          } | undefined;
          type: "compact_20260112";
        })[];
      } | undefined;
      compaction?: {
        instructions?: string | undefined;
        type: "summarize";
      } | undefined;
      safeguards?: {
        classifier_context?: Record<string, unknown> | undefined;
        type: "dangerous_tool_use";
      }[] | undefined;
      system: AnthropicTextContent[] | undefined;
      messages: AnthropicMessage[];
      container?: string | {
        id: string | undefined;
        skills: {
          type: "anthropic" | "custom";
          skill_id: string;
          version: string | undefined;
        }[];
      } | undefined;
      mcp_servers?: {
        type: "url";
        name: string;
        url: string;
        authorization_token: string | null | undefined;
        tool_configuration: {
          allowed_tools: string[] | null | undefined;
          enabled: boolean | null | undefined;
        } | undefined;
      }[] | undefined;
      metadata?: {
        user_id: string;
      } | undefined;
      cache_control?: {
        type: "ephemeral";
        ttl?: "5m" | "1h" | undefined;
      } | undefined;
      fallbacks?: "default" | {
        model: string;
        max_tokens?: number | undefined;
        thinking?: Record<string, unknown> | undefined;
        output_config?: Record<string, unknown> | undefined;
        speed?: "fast" | "standard" | undefined;
      }[] | undefined;
      inference_geo?: "us" | "global" | undefined;
      service_tier?: "auto" | "standard_only" | undefined;
      speed?: "fast" | "standard" | undefined;
      output_config?: {
        format?: {
          type: string;
          schema: import("@ai-sdk/provider").JSONSchema7;
        } | undefined;
        task_budget?: {
          remaining?: number | undefined;
          type: "tokens";
          total: number;
        } | undefined;
        effort?: "low" | "medium" | "high" | "xhigh" | "max" | undefined;
      } | undefined;
      thinking?: {
        block_binding?: {
          prefix_mismatch_behavior: "error" | "drop_block";
        } | undefined;
        display?: "omitted" | "summarized" | "updates" | undefined;
        budget_tokens?: number | undefined;
        type?: "adaptive" | "enabled" | "disabled" | "between_tools" | undefined;
      } | undefined;
      model: AnthropicModelId;
      max_tokens: number;
      temperature: number | undefined;
      top_k: number | undefined;
      top_p: number | undefined;
      stop_sequences: string[] | undefined;
    };
    warnings: SharedV4Warning[];
    betas: Set<string>;
    usesJsonResponseTool: boolean;
    toolNameMapping: import("@ai-sdk/provider-utils").ToolNameMapping;
    providerOptionsName: string;
    usedCustomProviderKey: boolean;
  }>;
  private getArgs;
  private getHeaders;
  private getBetasFromHeaders;
  private buildRequestUrl;
  protected transformRequestBody(args: Record<string, any>, betas: Set<string>): Record<string, any>;
  private extractCitationDocuments;
  doGenerate(options: LanguageModelV4CallOptions): Promise<LanguageModelV4GenerateResult>;
  doStream(options: LanguageModelV4CallOptions): Promise<LanguageModelV4StreamResult>;
}
/**
 * Returns the capabilities of a Claude model that are used for defaults and feature selection.
 *
 * @see https://docs.claude.com/en/docs/about-claude/models/overview#model-comparison-table
 * @see https://platform.claude.com/docs/en/build-with-claude/structured-outputs
 */
export declare function getModelCapabilities(modelId: string): {
  maxOutputTokens: number;
  supportsStructuredOutput: boolean;
  supportsAdaptiveThinking: boolean;
  rejectsSamplingParameters: boolean;
  supportsXhighEffort: boolean;
  rejectsThinkingDisabledAboveHighEffort: boolean;
  /**
   * Thinking is always adaptive: `thinking.type` `disabled` and `enabled`
   * are rejected with a 400.
   */
  rejectsThinkingDisabled: boolean;
  /**
   * Budget-based thinking (`thinking.type` `enabled` with `budget_tokens`) is
   * rejected with a 400. Only adaptive thinking is supported.
   */
  rejectsBudgetThinking: boolean;
  /**
   * Forced tool use (`tool_choice` `any` or a named tool) is rejected with a 400.
   */
  rejectsForcedToolUse: boolean;
  /**
   * Supports `thinking.type` `between_tools`, the lowest thinking setting on
   * models that reject disabled thinking.
   */
  supportsBetweenToolsThinking: boolean;
  isKnownModel: boolean;
};
//#endregion
//#region src/tool/computer-toolset_20260801.d.ts
/**
 * Member tools of the computer toolset. Each member is returned by the API as
 * its own `tool_use` block; the AI SDK exposes it as the `action` of a single
 * computer tool call.
 */
declare const computerToolset_20260801Members: readonly ["screenshot", "zoom", "left_click", "right_click", "middle_click", "double_click", "triple_click", "left_click_drag", "mouse_move", "left_mouse_down", "left_mouse_up", "cursor_position", "scroll", "type", "key", "hold_key", "wait"];
type ComputerToolset_20260801Member = (typeof computerToolset_20260801Members)[number];
//#endregion
//#region src/tool/bash_20241022.d.ts
type Bash20241022Input = {
  /**
   * The bash command to run. Required unless the tool is being restarted.
   */
  command: string;
  /**
   * Specifying true will restart this tool. Otherwise, leave this unspecified.
   */
  restart?: boolean;
};
type Bash20241022Options<OUTPUT> = {
  execute?: ToolExecuteFunction<Bash20241022Input, OUTPUT, {}>;
  needsApproval?: Tool<Bash20241022Input, OUTPUT, {}>['needsApproval'];
  toModelOutput?: Tool<Bash20241022Input, OUTPUT, {}>['toModelOutput'];
  onInputStart?: Tool<Bash20241022Input, OUTPUT, {}>['onInputStart'];
  onInputDelta?: Tool<Bash20241022Input, OUTPUT, {}>['onInputDelta'];
  onInputAvailable?: Tool<Bash20241022Input, OUTPUT, {}>['onInputAvailable'];
};
type Bash20241022DefaultOutput = Awaited<ReturnType<Experimental_SandboxSession['run']>>;
declare function bash_20241022(options?: Omit<Bash20241022Options<Bash20241022DefaultOutput>, 'execute'> & {
  execute?: undefined;
}): ProviderDefinedTool<Bash20241022Input, Bash20241022DefaultOutput, {}>;
declare function bash_20241022<OUTPUT = never>(options: Omit<Bash20241022Options<OUTPUT>, 'execute'> & {
  execute: null;
}): ProviderDefinedTool<Bash20241022Input, OUTPUT, {}>;
declare function bash_20241022<OUTPUT>(options: Omit<Bash20241022Options<OUTPUT>, 'execute'> & {
  execute: Bash20241022Options<OUTPUT>['execute'];
}): ProviderDefinedTool<Bash20241022Input, OUTPUT, {}>;
//#endregion
//#region src/tool/bash_20250124.d.ts
type Bash20250124Input = {
  /**
   * The bash command to run. Required unless the tool is being restarted.
   */
  command: string;
  /**
   * Specifying true will restart this tool. Otherwise, leave this unspecified.
   */
  restart?: boolean;
};
type Bash20250124Options<OUTPUT> = {
  execute?: ToolExecuteFunction<Bash20250124Input, OUTPUT, {}>;
  needsApproval?: Tool<Bash20250124Input, OUTPUT, {}>['needsApproval'];
  toModelOutput?: Tool<Bash20250124Input, OUTPUT, {}>['toModelOutput'];
  onInputStart?: Tool<Bash20250124Input, OUTPUT, {}>['onInputStart'];
  onInputDelta?: Tool<Bash20250124Input, OUTPUT, {}>['onInputDelta'];
  onInputAvailable?: Tool<Bash20250124Input, OUTPUT, {}>['onInputAvailable'];
};
type Bash20250124DefaultOutput = Awaited<ReturnType<Experimental_SandboxSession['run']>>;
declare function bash_20250124(options?: Omit<Bash20250124Options<Bash20250124DefaultOutput>, 'execute'> & {
  execute?: undefined;
}): ProviderDefinedTool<Bash20250124Input, Bash20250124DefaultOutput, {}>;
declare function bash_20250124<OUTPUT = never>(options: Omit<Bash20250124Options<OUTPUT>, 'execute'> & {
  execute: null;
}): ProviderDefinedTool<Bash20250124Input, OUTPUT, {}>;
declare function bash_20250124<OUTPUT>(options: Omit<Bash20250124Options<OUTPUT>, 'execute'> & {
  execute: Bash20250124Options<OUTPUT>['execute'];
}): ProviderDefinedTool<Bash20250124Input, OUTPUT, {}>;
//#endregion
//#region src/anthropic-tools.d.ts
export declare const anthropicTools: {
  /**
   * Pairs a faster executor model with a higher-intelligence advisor model
   * that provides strategic guidance mid-generation.
   *
   * The advisor lets a faster, lower-cost executor model consult a
   * higher-intelligence advisor model server-side. The advisor reads the
   * executor's full transcript and produces a plan or course correction;
   * the executor continues with the task, informed by the advice. All of
   * this happens inside a single `/v1/messages` request.
   *
   * Beta header `advisor-tool-2026-03-01` is added automatically when this
   * tool is included.
   *
   * Multi-turn conversations: pass the full assistant content (including
   * `advisor_tool_result` blocks) back to the API on subsequent turns. If
   * you omit the advisor tool from `tools` on a follow-up turn while the
   * message history still contains `advisor_tool_result` blocks, the API
   * returns a `400 invalid_request_error`.
   *
   * Supported executor models: Claude Haiku 4.5, Sonnet 4.6, Opus 4.6,
   * Opus 4.7. The advisor must be at least as capable as the executor.
   *
   * @param model - The advisor model ID (required), e.g. `"claude-opus-4-8"`.
   * @param maxUses - Maximum advisor calls per request (per-request cap).
   * @param maxTokens - Maximum advisor output tokens per call, including
   * thinking and text. Minimum 1024; Anthropic recommends starting with 2048.
   * @param caching - Enables prompt caching for the advisor's transcript
   * across calls within a conversation. Worthwhile from ~3 advisor calls
   * per conversation.
   */
  advisor_20260301: (args: Parameters<import("@ai-sdk/provider-utils").ProviderExecutedToolFactory<{}, {
    type: "advisor_result";
    text: string;
    stopReason?: string;
  } | {
    type: "advisor_redacted_result";
    encryptedContent: string;
    stopReason?: string;
  } | {
    type: "advisor_tool_result_error";
    errorCode: string;
  }, {
    model: string;
    maxUses?: number;
    maxTokens?: number;
    caching?: {
      type: "ephemeral";
      ttl: "5m" | "1h";
    };
  }, {}>>[0]) => import("@ai-sdk/provider-utils").ProviderExecutedTool<{}, {
    type: "advisor_result";
    text: string;
    stopReason?: string;
  } | {
    type: "advisor_redacted_result";
    encryptedContent: string;
    stopReason?: string;
  } | {
    type: "advisor_tool_result_error";
    errorCode: string;
  }, {}>;
  /**
   * The bash tool enables Claude to execute shell commands in a persistent bash session,
   * allowing system operations, script execution, and command-line automation.
   *
   * Image results are supported.
   */
  bash_20241022: typeof bash_20241022;
  /**
   * The bash tool enables Claude to execute shell commands in a persistent bash session,
   * allowing system operations, script execution, and command-line automation.
   *
   * Image results are supported.
   */
  bash_20250124: typeof bash_20250124;
  /**
   * Claude can analyze data, create visualizations, perform complex calculations,
   * run system commands, create and edit files, and process uploaded files directly within
   * the API conversation.
   *
   * The code execution tool allows Claude to run Bash commands and manipulate files,
   * including writing code, in a secure, sandboxed environment.
   */
  codeExecution_20250522: (args?: Parameters<import("@ai-sdk/provider-utils").ProviderExecutedToolFactory<{
    code: string;
  }, {
    type: "code_execution_result";
    stdout: string;
    stderr: string;
    return_code: number;
    content: Array<{
      type: "code_execution_output";
      file_id: string;
    }>;
  }, {}, {}>>[0]) => import("@ai-sdk/provider-utils").ProviderExecutedTool<{
    code: string;
  }, {
    type: "code_execution_result";
    stdout: string;
    stderr: string;
    return_code: number;
    content: Array<{
      type: "code_execution_output";
      file_id: string;
    }>;
  }, {}>;
  /**
   * Claude can analyze data, create visualizations, perform complex calculations,
   * run system commands, create and edit files, and process uploaded files directly within
   * the API conversation.
   *
   * The code execution tool allows Claude to run both Python and Bash commands and manipulate files,
   * including writing code, in a secure, sandboxed environment.
   *
   * This is the latest version with enhanced Bash support and file operations.
   */
  codeExecution_20250825: (args?: Parameters<import("@ai-sdk/provider-utils").ProviderExecutedToolFactory<{
    type: "programmatic-tool-call";
    code: string;
  } | {
    type: "bash_code_execution";
    command: string;
  } | {
    type: "text_editor_code_execution";
    command: "view";
    path: string;
  } | {
    type: "text_editor_code_execution";
    command: "create";
    path: string;
    file_text?: string | null;
  } | {
    type: "text_editor_code_execution";
    command: "str_replace";
    path: string;
    old_str: string;
    new_str: string;
  }, {
    type: "code_execution_result";
    stdout: string;
    stderr: string;
    return_code: number;
    content: Array<{
      type: "code_execution_output";
      file_id: string;
    }>;
  } | {
    type: "bash_code_execution_result";
    content: Array<{
      type: "bash_code_execution_output";
      file_id: string;
    }>;
    stdout: string;
    stderr: string;
    return_code: number;
  } | {
    type: "bash_code_execution_tool_result_error";
    error_code: string;
  } | {
    type: "text_editor_code_execution_tool_result_error";
    error_code: string;
  } | {
    type: "text_editor_code_execution_view_result";
    content: string;
    file_type: string;
    num_lines: number | null;
    start_line: number | null;
    total_lines: number | null;
  } | {
    type: "text_editor_code_execution_create_result";
    is_file_update: boolean;
  } | {
    type: "text_editor_code_execution_str_replace_result";
    lines: string[] | null;
    new_lines: number | null;
    new_start: number | null;
    old_lines: number | null;
    old_start: number | null;
  }, {}, {}>>[0]) => import("@ai-sdk/provider-utils").Experimental_ToolCallerTool<import("@ai-sdk/provider-utils").ProviderExecutedTool<{
    type: "programmatic-tool-call";
    code: string;
  } | {
    type: "bash_code_execution";
    command: string;
  } | {
    type: "text_editor_code_execution";
    command: "view";
    path: string;
  } | {
    type: "text_editor_code_execution";
    command: "create";
    path: string;
    file_text?: string | null;
  } | {
    type: "text_editor_code_execution";
    command: "str_replace";
    path: string;
    old_str: string;
    new_str: string;
  }, {
    type: "code_execution_result";
    stdout: string;
    stderr: string;
    return_code: number;
    content: Array<{
      type: "code_execution_output";
      file_id: string;
    }>;
  } | {
    type: "bash_code_execution_result";
    content: Array<{
      type: "bash_code_execution_output";
      file_id: string;
    }>;
    stdout: string;
    stderr: string;
    return_code: number;
  } | {
    type: "bash_code_execution_tool_result_error";
    error_code: string;
  } | {
    type: "text_editor_code_execution_tool_result_error";
    error_code: string;
  } | {
    type: "text_editor_code_execution_view_result";
    content: string;
    file_type: string;
    num_lines: number | null;
    start_line: number | null;
    total_lines: number | null;
  } | {
    type: "text_editor_code_execution_create_result";
    is_file_update: boolean;
  } | {
    type: "text_editor_code_execution_str_replace_result";
    lines: string[] | null;
    new_lines: number | null;
    new_start: number | null;
    old_lines: number | null;
    old_start: number | null;
  }, {}>>;
  /**
   * Claude can analyze data, create visualizations, perform complex calculations,
   * run system commands, create and edit files, and process uploaded files directly within
   * the API conversation.
   *
   * The code execution tool allows Claude to run both Python and Bash commands and manipulate files,
   * including writing code, in a secure, sandboxed environment.
   *
   * This is the recommended version. Does not require a beta header.
   *
   * Supported models: Claude Opus 4.6, Sonnet 4.6, Sonnet 4.5, Opus 4.5
   */
  codeExecution_20260120: (args?: Parameters<import("@ai-sdk/provider-utils").ProviderExecutedToolFactory<{
    type: "programmatic-tool-call";
    code: string;
  } | {
    type: "bash_code_execution";
    command: string;
  } | {
    type: "text_editor_code_execution";
    command: "view";
    path: string;
  } | {
    type: "text_editor_code_execution";
    command: "create";
    path: string;
    file_text?: string | null;
  } | {
    type: "text_editor_code_execution";
    command: "str_replace";
    path: string;
    old_str: string;
    new_str: string;
  }, {
    type: "code_execution_result";
    stdout: string;
    stderr: string;
    return_code: number;
    content: Array<{
      type: "code_execution_output";
      file_id: string;
    }>;
  } | {
    type: "encrypted_code_execution_result";
    encrypted_stdout: string;
    stderr: string;
    return_code: number;
    content: Array<{
      type: "code_execution_output";
      file_id: string;
    }>;
  } | {
    type: "bash_code_execution_result";
    content: Array<{
      type: "bash_code_execution_output";
      file_id: string;
    }>;
    stdout: string;
    stderr: string;
    return_code: number;
  } | {
    type: "bash_code_execution_tool_result_error";
    error_code: string;
  } | {
    type: "text_editor_code_execution_tool_result_error";
    error_code: string;
  } | {
    type: "text_editor_code_execution_view_result";
    content: string;
    file_type: string;
    num_lines: number | null;
    start_line: number | null;
    total_lines: number | null;
  } | {
    type: "text_editor_code_execution_create_result";
    is_file_update: boolean;
  } | {
    type: "text_editor_code_execution_str_replace_result";
    lines: string[] | null;
    new_lines: number | null;
    new_start: number | null;
    old_lines: number | null;
    old_start: number | null;
  }, {}, {}>>[0]) => import("@ai-sdk/provider-utils").Experimental_ToolCallerTool<import("@ai-sdk/provider-utils").ProviderExecutedTool<{
    type: "programmatic-tool-call";
    code: string;
  } | {
    type: "bash_code_execution";
    command: string;
  } | {
    type: "text_editor_code_execution";
    command: "view";
    path: string;
  } | {
    type: "text_editor_code_execution";
    command: "create";
    path: string;
    file_text?: string | null;
  } | {
    type: "text_editor_code_execution";
    command: "str_replace";
    path: string;
    old_str: string;
    new_str: string;
  }, {
    type: "code_execution_result";
    stdout: string;
    stderr: string;
    return_code: number;
    content: Array<{
      type: "code_execution_output";
      file_id: string;
    }>;
  } | {
    type: "encrypted_code_execution_result";
    encrypted_stdout: string;
    stderr: string;
    return_code: number;
    content: Array<{
      type: "code_execution_output";
      file_id: string;
    }>;
  } | {
    type: "bash_code_execution_result";
    content: Array<{
      type: "bash_code_execution_output";
      file_id: string;
    }>;
    stdout: string;
    stderr: string;
    return_code: number;
  } | {
    type: "bash_code_execution_tool_result_error";
    error_code: string;
  } | {
    type: "text_editor_code_execution_tool_result_error";
    error_code: string;
  } | {
    type: "text_editor_code_execution_view_result";
    content: string;
    file_type: string;
    num_lines: number | null;
    start_line: number | null;
    total_lines: number | null;
  } | {
    type: "text_editor_code_execution_create_result";
    is_file_update: boolean;
  } | {
    type: "text_editor_code_execution_str_replace_result";
    lines: string[] | null;
    new_lines: number | null;
    new_start: number | null;
    old_lines: number | null;
    old_start: number | null;
  }, {}>>;
  /**
   * Claude can interact with computer environments through the computer use tool, which
   * provides screenshot capabilities and mouse/keyboard control for autonomous desktop interaction.
   *
   * Image results are supported.
   *
   * @param displayWidthPx - The width of the display being controlled by the model in pixels.
   * @param displayHeightPx - The height of the display being controlled by the model in pixels.
   * @param displayNumber - The display number to control (only relevant for X11 environments). If specified, the tool will be provided a display number in the tool definition.
   */
  computer_20241022: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{
    action: "key" | "type" | "mouse_move" | "left_click" | "left_click_drag" | "right_click" | "middle_click" | "double_click" | "screenshot" | "cursor_position";
    coordinate?: number[];
    text?: string;
  }, {
    displayWidthPx: number;
    displayHeightPx: number;
    displayNumber?: number;
  }, {}>;
  /**
   * Claude can interact with computer environments through the computer use tool, which
   * provides screenshot capabilities and mouse/keyboard control for autonomous desktop interaction.
   *
   * Image results are supported.
   *
   * @param displayWidthPx - The width of the display being controlled by the model in pixels.
   * @param displayHeightPx - The height of the display being controlled by the model in pixels.
   * @param displayNumber - The display number to control (only relevant for X11 environments). If specified, the tool will be provided a display number in the tool definition.
   */
  computer_20250124: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{
    action: "key" | "hold_key" | "type" | "cursor_position" | "mouse_move" | "left_mouse_down" | "left_mouse_up" | "left_click" | "left_click_drag" | "right_click" | "middle_click" | "double_click" | "triple_click" | "scroll" | "wait" | "screenshot";
    coordinate?: [number, number];
    duration?: number;
    scroll_amount?: number;
    scroll_direction?: "up" | "down" | "left" | "right";
    start_coordinate?: [number, number];
    text?: string;
  }, {
    displayWidthPx: number;
    displayHeightPx: number;
    displayNumber?: number;
  }, {}>;
  /**
   * Claude can interact with computer environments through the computer use tool, which
   * provides screenshot capabilities and mouse/keyboard control for autonomous desktop interaction.
   *
   * This version adds the zoom action for detailed screen region inspection.
   *
   * Image results are supported.
   *
   * Supported models: Claude Opus 4.5
   *
   * @param displayWidthPx - The width of the display being controlled by the model in pixels.
   * @param displayHeightPx - The height of the display being controlled by the model in pixels.
   * @param displayNumber - The display number to control (only relevant for X11 environments). If specified, the tool will be provided a display number in the tool definition.
   * @param enableZoom - Enable zoom action. Set to true to allow Claude to zoom into specific screen regions. Default: false.
   */
  computer_20251124: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{
    action: "key" | "hold_key" | "type" | "cursor_position" | "mouse_move" | "left_mouse_down" | "left_mouse_up" | "left_click" | "left_click_drag" | "right_click" | "middle_click" | "double_click" | "triple_click" | "scroll" | "wait" | "screenshot" | "zoom";
    coordinate?: [number, number];
    duration?: number;
    region?: [number, number, number, number];
    scroll_amount?: number;
    scroll_direction?: "up" | "down" | "left" | "right";
    start_coordinate?: [number, number];
    text?: string;
  }, {
    displayWidthPx: number;
    displayHeightPx: number;
    displayNumber?: number;
    enableZoom?: boolean;
  }, {}>;
  /**
   * The computer toolset lets Claude control a computer through screenshots,
   * mouse, and keyboard. It replaces the versioned computer tools
   * (`computer_20251124` and earlier) on newer models.
   *
   * The API returns each computer action as its own `tool_use` block with
   * `toolset_name: 'computer'`. The AI SDK maps every member call to this tool
   * and exposes the member name as `action`, so `execute` receives the same
   * input shape as the older computer tools. Claude may return several actions
   * in one turn.
   *
   * Coordinates are always in the pixel space of the screenshots you return;
   * there are no display size parameters. Zoom is enabled by default.
   *
   * Does not require a beta header.
   *
   * Supported models: Claude Opus 5.5 (required; older computer tool types
   * are rejected), Opus 5, Sonnet 5, Fable 5, Fable 5.1, Opus 4.8.
   *
   * @param configs - Per-member settings keyed by member name, e.g.
   * `{ zoom: { enabled: false } }`. Omitted members keep their defaults.
   */
  computerToolset_20260801: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{
    action: ComputerToolset_20260801Member;
    coordinate?: [number, number];
    duration?: number;
    region?: [number, number, number, number];
    repeat?: number;
    scroll_amount?: number;
    scroll_direction?: "up" | "down" | "left" | "right";
    start_coordinate?: [number, number];
    text?: string;
  }, {
    configs?: Partial<Record<ComputerToolset_20260801Member, {
      enabled?: boolean;
      deferLoading?: boolean;
    }>>;
  }, {}>;
  /**
   * The memory tool enables Claude to store and retrieve information across conversations through a memory file directory.
   * Claude can create, read, update, and delete files that persist between sessions,
   * allowing it to build knowledge over time without keeping everything in the context window.
   * The memory tool operates client-side—you control where and how the data is stored through your own infrastructure.
   *
   * Supported models: Claude Sonnet 4.5, Claude Sonnet 4, Claude Opus 4.1, Claude Opus 4.
   */
  memory_20250818: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{
    command: "view";
    path: string;
    view_range?: [number, number];
  } | {
    command: "create";
    path: string;
    file_text: string;
  } | {
    command: "str_replace";
    path: string;
    old_str: string;
    new_str: string;
  } | {
    command: "insert";
    path: string;
    insert_line: number;
    insert_text: string;
  } | {
    command: "delete";
    path: string;
  } | {
    command: "rename";
    old_path: string;
    new_path: string;
  }, {}, {}>;
  /**
   * Claude can use an Anthropic-defined text editor tool to view and modify text files,
   * helping you debug, fix, and improve your code or other text documents. This allows Claude
   * to directly interact with your files, providing hands-on assistance rather than just suggesting changes.
   *
   * Supported models: Claude Sonnet 3.5
   */
  textEditor_20241022: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{
    command: "view" | "create" | "str_replace" | "insert" | "undo_edit";
    path: string;
    file_text?: string;
    insert_line?: number;
    new_str?: string;
    insert_text?: string;
    old_str?: string;
    view_range?: number[];
  }, {}, {}>;
  /**
   * Claude can use an Anthropic-defined text editor tool to view and modify text files,
   * helping you debug, fix, and improve your code or other text documents. This allows Claude
   * to directly interact with your files, providing hands-on assistance rather than just suggesting changes.
   *
   * Supported models: Claude Sonnet 3.7
   */
  textEditor_20250124: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{
    command: "view" | "create" | "str_replace" | "insert" | "undo_edit";
    path: string;
    file_text?: string;
    insert_line?: number;
    new_str?: string;
    insert_text?: string;
    old_str?: string;
    view_range?: number[];
  }, {}, {}>;
  /**
   * Claude can use an Anthropic-defined text editor tool to view and modify text files,
   * helping you debug, fix, and improve your code or other text documents. This allows Claude
   * to directly interact with your files, providing hands-on assistance rather than just suggesting changes.
   *
   * Note: This version does not support the "undo_edit" command.
   *
   * @deprecated Use textEditor_20250728 instead
   */
  textEditor_20250429: import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{
    command: "view" | "create" | "str_replace" | "insert";
    path: string;
    file_text?: string;
    insert_line?: number;
    new_str?: string;
    insert_text?: string;
    old_str?: string;
    view_range?: number[];
  }, {}, {}>;
  /**
   * Claude can use an Anthropic-defined text editor tool to view and modify text files,
   * helping you debug, fix, and improve your code or other text documents. This allows Claude
   * to directly interact with your files, providing hands-on assistance rather than just suggesting changes.
   *
   * Note: This version does not support the "undo_edit" command and adds optional max_characters parameter.
   *
   * Supported models: Claude Sonnet 4, Opus 4, and Opus 4.1
   *
   * @param maxCharacters - Optional maximum number of characters to view in the file
   */
  textEditor_20250728: (args?: Parameters<import("@ai-sdk/provider-utils").ProviderDefinedToolFactory<{
    command: "view" | "create" | "str_replace" | "insert";
    path: string;
    file_text?: string;
    insert_line?: number;
    new_str?: string;
    insert_text?: string;
    old_str?: string;
    view_range?: number[];
  }, {
    maxCharacters?: number;
  }, {}>>[0]) => import("@ai-sdk/provider-utils").ProviderDefinedTool<{
    command: "view" | "create" | "str_replace" | "insert";
    path: string;
    file_text?: string;
    insert_line?: number;
    new_str?: string;
    insert_text?: string;
    old_str?: string;
    view_range?: number[];
  }, unknown, {}>;
  /**
   * Creates a web fetch tool that gives Claude direct access to real-time web content.
   *
   * @param maxUses - The max_uses parameter limits the number of web fetches performed
   * @param allowedDomains - Only fetch from these domains
   * @param blockedDomains - Never fetch from these domains
   * @param citations - Unlike web search where citations are always enabled, citations are optional for web fetch. Set "citations": {"enabled": true} to enable Claude to cite specific passages from fetched documents.
   * @param maxContentTokens - The max_content_tokens parameter limits the amount of content that will be included in the context.
   */
  webFetch_20250910: (args?: Parameters<import("@ai-sdk/provider-utils").ProviderExecutedToolFactory<{
    url: string;
  }, {
    type: "web_fetch_result";
    url: string;
    content: {
      type: "document";
      title: string | null;
      citations?: {
        enabled: boolean;
      };
      source: {
        type: "base64";
        mediaType: "application/pdf";
        data: string;
      } | {
        type: "text";
        mediaType: "text/plain";
        data: string;
      };
    };
    retrievedAt: string | null;
  }, {
    maxUses?: number;
    allowedDomains?: string[];
    blockedDomains?: string[];
    citations?: {
      enabled: boolean;
    };
    maxContentTokens?: number;
  }, {}>>[0]) => import("@ai-sdk/provider-utils").ProviderExecutedTool<{
    url: string;
  }, {
    type: "web_fetch_result";
    url: string;
    content: {
      type: "document";
      title: string | null;
      citations?: {
        enabled: boolean;
      };
      source: {
        type: "base64";
        mediaType: "application/pdf";
        data: string;
      } | {
        type: "text";
        mediaType: "text/plain";
        data: string;
      };
    };
    retrievedAt: string | null;
  }, {}>;
  /**
   * Creates a web fetch tool that gives Claude direct access to real-time web content.
   *
   * @param maxUses - The max_uses parameter limits the number of web fetches performed
   * @param allowedDomains - Only fetch from these domains
   * @param blockedDomains - Never fetch from these domains
   * @param citations - Unlike web search where citations are always enabled, citations are optional for web fetch. Set "citations": {"enabled": true} to enable Claude to cite specific passages from fetched documents.
   * @param maxContentTokens - The max_content_tokens parameter limits the amount of content that will be included in the context.
   */
  webFetch_20260209: (args?: Parameters<import("@ai-sdk/provider-utils").ProviderExecutedToolFactory<{
    url: string;
  }, {
    type: "web_fetch_result";
    url: string;
    content: {
      type: "document";
      title: string | null;
      citations?: {
        enabled: boolean;
      };
      source: {
        type: "base64";
        mediaType: "application/pdf";
        data: string;
      } | {
        type: "text";
        mediaType: "text/plain";
        data: string;
      };
    };
    retrievedAt: string | null;
  }, {
    maxUses?: number;
    allowedDomains?: string[];
    blockedDomains?: string[];
    citations?: {
      enabled: boolean;
    };
    maxContentTokens?: number;
  }, {}>>[0]) => import("@ai-sdk/provider-utils").ProviderExecutedTool<{
    url: string;
  }, {
    type: "web_fetch_result";
    url: string;
    content: {
      type: "document";
      title: string | null;
      citations?: {
        enabled: boolean;
      };
      source: {
        type: "base64";
        mediaType: "application/pdf";
        data: string;
      } | {
        type: "text";
        mediaType: "text/plain";
        data: string;
      };
    };
    retrievedAt: string | null;
  }, {}>;
  /**
   * Creates a web fetch tool that gives Claude direct access to real-time web content.
   *
   * @param maxUses - The max_uses parameter limits the number of web fetches performed
   * @param allowedDomains - Only fetch from these domains
   * @param blockedDomains - Never fetch from these domains
   * @param citations - Unlike web search where citations are always enabled, citations are optional for web fetch. Set "citations": {"enabled": true} to enable Claude to cite specific passages from fetched documents.
   * @param maxContentTokens - The max_content_tokens parameter limits the amount of content that will be included in the context.
   * @param useCache - Whether cached content may be returned. Set to false to fetch fresh content.
   * @param responseInclusion - Whether result blocks consumed by completed code execution calls are returned. Defaults to "full".
   */
  webFetch_20260318: (args?: Parameters<import("@ai-sdk/provider-utils").ProviderExecutedToolFactory<{
    url: string;
  }, {
    type: "web_fetch_result";
    url: string;
    content: {
      type: "document";
      title: string | null;
      citations?: {
        enabled: boolean;
      };
      source: {
        type: "base64";
        mediaType: "application/pdf";
        data: string;
      } | {
        type: "text";
        mediaType: "text/plain";
        data: string;
      };
    };
    retrievedAt: string | null;
  }, {
    maxUses?: number;
    allowedDomains?: string[];
    blockedDomains?: string[];
    citations?: {
      enabled: boolean;
    };
    maxContentTokens?: number;
    useCache?: boolean;
    responseInclusion?: "full" | "excluded";
  }, {}>>[0]) => import("@ai-sdk/provider-utils").ProviderExecutedTool<{
    url: string;
  }, {
    type: "web_fetch_result";
    url: string;
    content: {
      type: "document";
      title: string | null;
      citations?: {
        enabled: boolean;
      };
      source: {
        type: "base64";
        mediaType: "application/pdf";
        data: string;
      } | {
        type: "text";
        mediaType: "text/plain";
        data: string;
      };
    };
    retrievedAt: string | null;
  }, {}>;
  /**
   * Creates a web search tool that gives Claude direct access to real-time web content.
   *
   * @param maxUses - Maximum number of web searches Claude can perform during the conversation.
   * @param allowedDomains - Optional list of domains that Claude is allowed to search.
   * @param blockedDomains - Optional list of domains that Claude should avoid when searching.
   * @param userLocation - Optional user location information to provide geographically relevant search results.
   */
  webSearch_20250305: (args?: Parameters<import("@ai-sdk/provider-utils").ProviderExecutedToolFactory<{
    query: string;
  }, {
    type: "web_search_result";
    url: string;
    title: string | null;
    pageAge: string | null;
    encryptedContent: string;
  }[], {
    maxUses?: number;
    allowedDomains?: string[];
    blockedDomains?: string[];
    userLocation?: {
      type: "approximate";
      city?: string;
      region?: string;
      country?: string;
      timezone?: string;
    };
  }, {}>>[0]) => import("@ai-sdk/provider-utils").ProviderExecutedTool<{
    query: string;
  }, {
    type: "web_search_result";
    url: string;
    title: string | null;
    pageAge: string | null;
    encryptedContent: string;
  }[], {}>;
  /**
   * Creates a web search tool that gives Claude direct access to real-time web content.
   *
   * @param maxUses - Maximum number of web searches Claude can perform during the conversation.
   * @param allowedDomains - Optional list of domains that Claude is allowed to search.
   * @param blockedDomains - Optional list of domains that Claude should avoid when searching.
   * @param userLocation - Optional user location information to provide geographically relevant search results.
   */
  webSearch_20260209: (args?: Parameters<import("@ai-sdk/provider-utils").ProviderExecutedToolFactory<{
    query: string;
  }, {
    type: "web_search_result";
    url: string;
    title: string | null;
    pageAge: string | null;
    encryptedContent: string;
  }[], {
    maxUses?: number;
    allowedDomains?: string[];
    blockedDomains?: string[];
    userLocation?: {
      type: "approximate";
      city?: string;
      region?: string;
      country?: string;
      timezone?: string;
    };
  }, {}>>[0]) => import("@ai-sdk/provider-utils").ProviderExecutedTool<{
    query: string;
  }, {
    type: "web_search_result";
    url: string;
    title: string | null;
    pageAge: string | null;
    encryptedContent: string;
  }[], {}>;
  /**
   * Creates a web search tool that gives Claude direct access to real-time web content.
   *
   * @param maxUses - Maximum number of web searches Claude can perform during the conversation.
   * @param allowedDomains - Optional list of domains that Claude is allowed to search.
   * @param blockedDomains - Optional list of domains that Claude should avoid when searching.
   * @param userLocation - Optional user location information to provide geographically relevant search results.
   * @param responseInclusion - Whether result blocks consumed by completed code execution calls are returned. Defaults to "full".
   */
  webSearch_20260318: (args?: Parameters<import("@ai-sdk/provider-utils").ProviderExecutedToolFactory<{
    query: string;
  }, {
    type: "web_search_result";
    url: string;
    title: string | null;
    pageAge: string | null;
    encryptedContent: string;
  }[], {
    maxUses?: number;
    allowedDomains?: string[];
    blockedDomains?: string[];
    userLocation?: {
      type: "approximate";
      city?: string;
      region?: string;
      country?: string;
      timezone?: string;
    };
    responseInclusion?: "full" | "excluded";
  }, {}>>[0]) => import("@ai-sdk/provider-utils").ProviderExecutedTool<{
    query: string;
  }, {
    type: "web_search_result";
    url: string;
    title: string | null;
    pageAge: string | null;
    encryptedContent: string;
  }[], {}>;
  /**
   * Creates a tool search tool that uses regex patterns to find tools.
   *
   * The tool search tool enables Claude to work with hundreds or thousands of tools
   * by dynamically discovering and loading them on-demand. Instead of loading all
   * tool definitions into the context window upfront, Claude searches your tool
   * catalog and loads only the tools it needs.
   *
   * Use `providerOptions: { anthropic: { deferLoading: true } }` on other tools
   * to mark them for deferred loading.
   *
   * Supported models: Claude Opus 4.5, Claude Sonnet 4.5
   */
  toolSearchRegex_20251119: (args?: Parameters<import("@ai-sdk/provider-utils").ProviderExecutedToolFactory<{
    pattern: string;
    limit?: number;
  }, {
    type: "tool_reference";
    toolName: string;
  }[], {}, {}>>[0]) => import("@ai-sdk/provider-utils").ProviderExecutedTool<{
    pattern: string;
    limit?: number;
  }, {
    type: "tool_reference";
    toolName: string;
  }[], {}>;
  /**
   * Creates a tool search tool that uses BM25 (natural language) to find tools.
   *
   * The tool search tool enables Claude to work with hundreds or thousands of tools
   * by dynamically discovering and loading them on-demand. Instead of loading all
   * tool definitions into the context window upfront, Claude searches your tool
   * catalog and loads only the tools it needs.
   *
   * Use `providerOptions: { anthropic: { deferLoading: true } }` on other tools
   * to mark them for deferred loading.
   *
   * Supported models: Claude Opus 4.5, Claude Sonnet 4.5
   */
  toolSearchBm25_20251119: (args?: Parameters<import("@ai-sdk/provider-utils").ProviderExecutedToolFactory<{
    query: string;
    limit?: number;
  }, {
    type: "tool_reference";
    toolName: string;
  }[], {}, {}>>[0]) => import("@ai-sdk/provider-utils").ProviderExecutedTool<{
    query: string;
    limit?: number;
  }, {
    type: "tool_reference";
    toolName: string;
  }[], {}>;
};
//#endregion
//#region src/anthropic-prepare-tools.d.ts
export declare function prepareTools({ tools, toolChoice, disableParallelToolUse, cacheControlValidator, supportsStructuredOutput, supportsStrictTools, defaultEagerInputStreaming, rejectsForcedToolUse }: {
  tools: LanguageModelV4CallOptions['tools'];
  toolChoice: LanguageModelV4CallOptions['toolChoice'] | undefined;
  disableParallelToolUse?: boolean;
  cacheControlValidator?: CacheControlValidator;
  /**
   * Whether the model supports native structured output response format.
   */
  supportsStructuredOutput: boolean;
  /**
   * Whether the model supports strict mode on tool definitions.
   */
  supportsStrictTools: boolean;
  /**
   * Default for `eager_input_streaming` on function tools that do not set
   * it explicitly. Driven by the model-level `toolStreaming` option.
   */
  defaultEagerInputStreaming?: boolean;
  /**
   * Whether the model or thinking configuration rejects forced tool use
   * (`tool_choice` `any` or a named tool). When true, `required` and `tool`
   * tool choices fall back to `auto` with a warning.
   */
  rejectsForcedToolUse?: boolean;
}): Promise<{
  tools: Array<AnthropicTool> | undefined;
  toolChoice: AnthropicToolChoice | undefined;
  toolWarnings: SharedV4Warning[];
  betas: Set<string>;
}>;
//#endregion
//#region src/sanitize-json-schema.d.ts
/**
 * Removes JSON Schema keywords that Anthropic rejects in
 * `output_config.format.schema`.
 *
 * The full original schema is still used by AI SDK result validation. This
 * only relaxes the schema sent to Anthropic's constrained decoder.
 */
export declare function sanitizeJsonSchema(schema: JSONSchema7): JSONSchema7;
//#endregion
//#region src/skills/anthropic-skills.d.ts
interface AnthropicSkillsConfig {
  provider: string;
  baseURL: string;
  headers: Resolvable<Record<string, string | undefined>>;
  fetch?: FetchFunction;
}
export declare class AnthropicSkills implements SkillsV4 {
  private readonly config;
  readonly specificationVersion = "v4";
  get provider(): string;
  constructor(config: AnthropicSkillsConfig);
  private getHeaders;
  private fetchVersionMetadata;
  uploadSkill(params: Parameters<SkillsV4['uploadSkill']>[0]): Promise<Awaited<ReturnType<SkillsV4['uploadSkill']>>>;
}
//#endregion
export { AnthropicLanguageModel as AnthropicMessagesLanguageModel, type AnthropicModelId as AnthropicMessagesModelId, type AnthropicModelId };
//# sourceMappingURL=index.d.ts.map