anthropic-sdk-beta 0.1.0.pre.beta.3

data/lib/anthropic/models/thinking_block_param.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ThinkingBlockParam < Anthropic::Internal::Type::BaseModel
+      # @!attribute signature
+      #
+      #   @return [String]
+      required :signature, String
+
+      # @!attribute thinking
+      #
+      #   @return [String]
+      required :thinking, String
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :thinking]
+      required :type, const: :thinking
+
+      # @!parse
+      #   # @param signature [String]
+      #   # @param thinking [String]
+      #   # @param type [Symbol, :thinking]
+      #   #
+      #   def initialize(signature:, thinking:, type: :thinking, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/thinking_config_disabled.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ThinkingConfigDisabled < Anthropic::Internal::Type::BaseModel
+      # @!attribute type
+      #
+      #   @return [Symbol, :disabled]
+      required :type, const: :disabled
+
+      # @!parse
+      #   # @param type [Symbol, :disabled]
+      #   #
+      #   def initialize(type: :disabled, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/thinking_config_enabled.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ThinkingConfigEnabled < Anthropic::Internal::Type::BaseModel
+      # @!attribute budget_tokens
+      #   Determines how many tokens Claude can use for its internal reasoning process.
+      #   Larger budgets can enable more thorough analysis for complex problems, improving
+      #   response quality.
+      #
+      #   Must be ≥1024 and less than `max_tokens`.
+      #
+      #   See
+      #   [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking)
+      #   for details.
+      #
+      #   @return [Integer]
+      required :budget_tokens, Integer
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :enabled]
+      required :type, const: :enabled
+
+      # @!parse
+      #   # @param budget_tokens [Integer]
+      #   # @param type [Symbol, :enabled]
+      #   #
+      #   def initialize(budget_tokens:, type: :enabled, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/thinking_config_param.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    # Configuration for enabling Claude's extended thinking.
+    #
+    # When enabled, responses include `thinking` content blocks showing Claude's
+    # thinking process before the final answer. Requires a minimum budget of 1,024
+    # tokens and counts towards your `max_tokens` limit.
+    #
+    # See
+    # [extended thinking](https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking)
+    # for details.
+    module ThinkingConfigParam
+      extend Anthropic::Internal::Type::Union
+
+      discriminator :type
+
+      variant :enabled, -> { Anthropic::Models::ThinkingConfigEnabled }
+
+      variant :disabled, -> { Anthropic::Models::ThinkingConfigDisabled }
+
+      # @!parse
+      #   # @return [Array(Anthropic::Models::ThinkingConfigEnabled, Anthropic::Models::ThinkingConfigDisabled)]
+      #   def self.variants; end
+    end
+  end
+end

data/lib/anthropic/models/thinking_delta.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ThinkingDelta < Anthropic::Internal::Type::BaseModel
+      # @!attribute thinking
+      #
+      #   @return [String]
+      required :thinking, String
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :thinking_delta]
+      required :type, const: :thinking_delta
+
+      # @!parse
+      #   # @param thinking [String]
+      #   # @param type [Symbol, :thinking_delta]
+      #   #
+      #   def initialize(thinking:, type: :thinking_delta, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/tool.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class Tool < Anthropic::Internal::Type::BaseModel
+      # @!attribute input_schema
+      #   [JSON schema](https://json-schema.org/draft/2020-12) for this tool's input.
+      #
+      #   This defines the shape of the `input` that your tool accepts and that the model
+      #   will produce.
+      #
+      #   @return [Anthropic::Models::Tool::InputSchema]
+      required :input_schema, -> { Anthropic::Models::Tool::InputSchema }
+
+      # @!attribute name
+      #   Name of the tool.
+      #
+      #   This is how the tool will be called by the model and in tool_use blocks.
+      #
+      #   @return [String]
+      required :name, String
+
+      # @!attribute cache_control
+      #
+      #   @return [Anthropic::Models::CacheControlEphemeral, nil]
+      optional :cache_control, -> { Anthropic::Models::CacheControlEphemeral }, nil?: true
+
+      # @!attribute [r] description
+      #   Description of what this tool does.
+      #
+      #   Tool descriptions should be as detailed as possible. The more information that
+      #   the model has about what the tool is and how to use it, the better it will
+      #   perform. You can use natural language descriptions to reinforce important
+      #   aspects of the tool input JSON schema.
+      #
+      #   @return [String, nil]
+      optional :description, String
+
+      # @!parse
+      #   # @return [String]
+      #   attr_writer :description
+
+      # @!parse
+      #   # @param input_schema [Anthropic::Models::Tool::InputSchema]
+      #   # @param name [String]
+      #   # @param cache_control [Anthropic::Models::CacheControlEphemeral, nil]
+      #   # @param description [String]
+      #   #
+      #   def initialize(input_schema:, name:, cache_control: nil, description: nil, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+
+      # @see Anthropic::Models::Tool#input_schema
+      class InputSchema < Anthropic::Internal::Type::BaseModel
+        # @!attribute type
+        #
+        #   @return [Symbol, :object]
+        required :type, const: :object
+
+        # @!attribute properties
+        #
+        #   @return [Object, nil]
+        optional :properties, Anthropic::Internal::Type::Unknown, nil?: true
+
+        # @!parse
+        #   # [JSON schema](https://json-schema.org/draft/2020-12) for this tool's input.
+        #   #
+        #   # This defines the shape of the `input` that your tool accepts and that the model
+        #   # will produce.
+        #   #
+        #   # @param properties [Object, nil]
+        #   # @param type [Symbol, :object]
+        #   #
+        #   def initialize(properties: nil, type: :object, **) = super
+
+        # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+      end
+    end
+  end
+end

data/lib/anthropic/models/tool_bash_20250124.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ToolBash20250124 < Anthropic::Internal::Type::BaseModel
+      # @!attribute name
+      #   Name of the tool.
+      #
+      #   This is how the tool will be called by the model and in tool_use blocks.
+      #
+      #   @return [Symbol, :bash]
+      required :name, const: :bash
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :bash_20250124]
+      required :type, const: :bash_20250124
+
+      # @!attribute cache_control
+      #
+      #   @return [Anthropic::Models::CacheControlEphemeral, nil]
+      optional :cache_control, -> { Anthropic::Models::CacheControlEphemeral }, nil?: true
+
+      # @!parse
+      #   # @param cache_control [Anthropic::Models::CacheControlEphemeral, nil]
+      #   # @param name [Symbol, :bash]
+      #   # @param type [Symbol, :bash_20250124]
+      #   #
+      #   def initialize(cache_control: nil, name: :bash, type: :bash_20250124, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/tool_choice.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    # How the model should use the provided tools. The model can use a specific tool,
+    # any available tool, decide by itself, or not use tools at all.
+    module ToolChoice
+      extend Anthropic::Internal::Type::Union
+
+      discriminator :type
+
+      # The model will automatically decide whether to use tools.
+      variant :auto, -> { Anthropic::Models::ToolChoiceAuto }
+
+      # The model will use any available tools.
+      variant :any, -> { Anthropic::Models::ToolChoiceAny }
+
+      # The model will use the specified tool with `tool_choice.name`.
+      variant :tool, -> { Anthropic::Models::ToolChoiceTool }
+
+      # The model will not be allowed to use tools.
+      variant :none, -> { Anthropic::Models::ToolChoiceNone }
+
+      # @!parse
+      #   # @return [Array(Anthropic::Models::ToolChoiceAuto, Anthropic::Models::ToolChoiceAny, Anthropic::Models::ToolChoiceTool, Anthropic::Models::ToolChoiceNone)]
+      #   def self.variants; end
+    end
+  end
+end

data/lib/anthropic/models/tool_choice_any.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ToolChoiceAny < Anthropic::Internal::Type::BaseModel
+      # @!attribute type
+      #
+      #   @return [Symbol, :any]
+      required :type, const: :any
+
+      # @!attribute [r] disable_parallel_tool_use
+      #   Whether to disable parallel tool use.
+      #
+      #   Defaults to `false`. If set to `true`, the model will output exactly one tool
+      #   use.
+      #
+      #   @return [Boolean, nil]
+      optional :disable_parallel_tool_use, Anthropic::Internal::Type::Boolean
+
+      # @!parse
+      #   # @return [Boolean]
+      #   attr_writer :disable_parallel_tool_use
+
+      # @!parse
+      #   # The model will use any available tools.
+      #   #
+      #   # @param disable_parallel_tool_use [Boolean]
+      #   # @param type [Symbol, :any]
+      #   #
+      #   def initialize(disable_parallel_tool_use: nil, type: :any, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/tool_choice_auto.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ToolChoiceAuto < Anthropic::Internal::Type::BaseModel
+      # @!attribute type
+      #
+      #   @return [Symbol, :auto]
+      required :type, const: :auto
+
+      # @!attribute [r] disable_parallel_tool_use
+      #   Whether to disable parallel tool use.
+      #
+      #   Defaults to `false`. If set to `true`, the model will output at most one tool
+      #   use.
+      #
+      #   @return [Boolean, nil]
+      optional :disable_parallel_tool_use, Anthropic::Internal::Type::Boolean
+
+      # @!parse
+      #   # @return [Boolean]
+      #   attr_writer :disable_parallel_tool_use
+
+      # @!parse
+      #   # The model will automatically decide whether to use tools.
+      #   #
+      #   # @param disable_parallel_tool_use [Boolean]
+      #   # @param type [Symbol, :auto]
+      #   #
+      #   def initialize(disable_parallel_tool_use: nil, type: :auto, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/tool_choice_none.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ToolChoiceNone < Anthropic::Internal::Type::BaseModel
+      # @!attribute type
+      #
+      #   @return [Symbol, :none]
+      required :type, const: :none
+
+      # @!parse
+      #   # The model will not be allowed to use tools.
+      #   #
+      #   # @param type [Symbol, :none]
+      #   #
+      #   def initialize(type: :none, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/tool_choice_tool.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ToolChoiceTool < Anthropic::Internal::Type::BaseModel
+      # @!attribute name
+      #   The name of the tool to use.
+      #
+      #   @return [String]
+      required :name, String
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :tool]
+      required :type, const: :tool
+
+      # @!attribute [r] disable_parallel_tool_use
+      #   Whether to disable parallel tool use.
+      #
+      #   Defaults to `false`. If set to `true`, the model will output exactly one tool
+      #   use.
+      #
+      #   @return [Boolean, nil]
+      optional :disable_parallel_tool_use, Anthropic::Internal::Type::Boolean
+
+      # @!parse
+      #   # @return [Boolean]
+      #   attr_writer :disable_parallel_tool_use
+
+      # @!parse
+      #   # The model will use the specified tool with `tool_choice.name`.
+      #   #
+      #   # @param name [String]
+      #   # @param disable_parallel_tool_use [Boolean]
+      #   # @param type [Symbol, :tool]
+      #   #
+      #   def initialize(name:, disable_parallel_tool_use: nil, type: :tool, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/tool_result_block_param.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ToolResultBlockParam < Anthropic::Internal::Type::BaseModel
+      # @!attribute tool_use_id
+      #
+      #   @return [String]
+      required :tool_use_id, String
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :tool_result]
+      required :type, const: :tool_result
+
+      # @!attribute cache_control
+      #
+      #   @return [Anthropic::Models::CacheControlEphemeral, nil]
+      optional :cache_control, -> { Anthropic::Models::CacheControlEphemeral }, nil?: true
+
+      # @!attribute [r] content
+      #
+      #   @return [String, Array<Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam>, nil]
+      optional :content, union: -> { Anthropic::Models::ToolResultBlockParam::Content }
+
+      # @!parse
+      #   # @return [String, Array<Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam>]
+      #   attr_writer :content
+
+      # @!attribute [r] is_error
+      #
+      #   @return [Boolean, nil]
+      optional :is_error, Anthropic::Internal::Type::Boolean
+
+      # @!parse
+      #   # @return [Boolean]
+      #   attr_writer :is_error
+
+      # @!parse
+      #   # @param tool_use_id [String]
+      #   # @param cache_control [Anthropic::Models::CacheControlEphemeral, nil]
+      #   # @param content [String, Array<Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam>]
+      #   # @param is_error [Boolean]
+      #   # @param type [Symbol, :tool_result]
+      #   #
+      #   def initialize(tool_use_id:, cache_control: nil, content: nil, is_error: nil, type: :tool_result, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+
+      # @see Anthropic::Models::ToolResultBlockParam#content
+      module Content
+        extend Anthropic::Internal::Type::Union
+
+        variant String
+
+        variant -> { Anthropic::Models::ToolResultBlockParam::Content::ContentArray }
+
+        module Content
+          extend Anthropic::Internal::Type::Union
+
+          discriminator :type
+
+          variant :text, -> { Anthropic::Models::TextBlockParam }
+
+          variant :image, -> { Anthropic::Models::ImageBlockParam }
+
+          # @!parse
+          #   # @return [Array(Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam)]
+          #   def self.variants; end
+        end
+
+        # @!parse
+        #   # @return [Array(String, Array<Anthropic::Models::TextBlockParam, Anthropic::Models::ImageBlockParam>)]
+        #   def self.variants; end
+
+        ContentArray =
+          Anthropic::Internal::Type::ArrayOf[union: -> { Anthropic::Models::ToolResultBlockParam::Content::Content }]
+      end
+    end
+  end
+end

data/lib/anthropic/models/tool_text_editor_20250124.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ToolTextEditor20250124 < Anthropic::Internal::Type::BaseModel
+      # @!attribute name
+      #   Name of the tool.
+      #
+      #   This is how the tool will be called by the model and in tool_use blocks.
+      #
+      #   @return [Symbol, :str_replace_editor]
+      required :name, const: :str_replace_editor
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :text_editor_20250124]
+      required :type, const: :text_editor_20250124
+
+      # @!attribute cache_control
+      #
+      #   @return [Anthropic::Models::CacheControlEphemeral, nil]
+      optional :cache_control, -> { Anthropic::Models::CacheControlEphemeral }, nil?: true
+
+      # @!parse
+      #   # @param cache_control [Anthropic::Models::CacheControlEphemeral, nil]
+      #   # @param name [Symbol, :str_replace_editor]
+      #   # @param type [Symbol, :text_editor_20250124]
+      #   #
+      #   def initialize(cache_control: nil, name: :str_replace_editor, type: :text_editor_20250124, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/tool_union.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    module ToolUnion
+      extend Anthropic::Internal::Type::Union
+
+      variant -> { Anthropic::Models::Tool }
+
+      variant -> { Anthropic::Models::ToolBash20250124 }
+
+      variant -> { Anthropic::Models::ToolTextEditor20250124 }
+
+      # @!parse
+      #   # @return [Array(Anthropic::Models::Tool, Anthropic::Models::ToolBash20250124, Anthropic::Models::ToolTextEditor20250124)]
+      #   def self.variants; end
+    end
+  end
+end

data/lib/anthropic/models/tool_use_block.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ToolUseBlock < Anthropic::Internal::Type::BaseModel
+      # @!attribute id
+      #
+      #   @return [String]
+      required :id, String
+
+      # @!attribute input
+      #
+      #   @return [Object]
+      required :input, Anthropic::Internal::Type::Unknown
+
+      # @!attribute name
+      #
+      #   @return [String]
+      required :name, String
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :tool_use]
+      required :type, const: :tool_use
+
+      # @!parse
+      #   # @param id [String]
+      #   # @param input [Object]
+      #   # @param name [String]
+      #   # @param type [Symbol, :tool_use]
+      #   #
+      #   def initialize(id:, input:, name:, type: :tool_use, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/tool_use_block_param.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class ToolUseBlockParam < Anthropic::Internal::Type::BaseModel
+      # @!attribute id
+      #
+      #   @return [String]
+      required :id, String
+
+      # @!attribute input
+      #
+      #   @return [Object]
+      required :input, Anthropic::Internal::Type::Unknown
+
+      # @!attribute name
+      #
+      #   @return [String]
+      required :name, String
+
+      # @!attribute type
+      #
+      #   @return [Symbol, :tool_use]
+      required :type, const: :tool_use
+
+      # @!attribute cache_control
+      #
+      #   @return [Anthropic::Models::CacheControlEphemeral, nil]
+      optional :cache_control, -> { Anthropic::Models::CacheControlEphemeral }, nil?: true
+
+      # @!parse
+      #   # @param id [String]
+      #   # @param input [Object]
+      #   # @param name [String]
+      #   # @param cache_control [Anthropic::Models::CacheControlEphemeral, nil]
+      #   # @param type [Symbol, :tool_use]
+      #   #
+      #   def initialize(id:, input:, name:, cache_control: nil, type: :tool_use, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end

data/lib/anthropic/models/url_image_source.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    class URLImageSource < Anthropic::Internal::Type::BaseModel
+      # @!attribute type
+      #
+      #   @return [Symbol, :url]
+      required :type, const: :url
+
+      # @!attribute url
+      #
+      #   @return [String]
+      required :url, String
+
+      # @!parse
+      #   # @param url [String]
+      #   # @param type [Symbol, :url]
+      #   #
+      #   def initialize(url:, type: :url, **) = super
+
+      # def initialize: (Hash | Anthropic::Internal::Type::BaseModel) -> void
+    end
+  end
+end