anthropic 1.12.0 → 1.14.0

data/lib/anthropic/helpers/tools/base_tool.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module Tools
+      class BaseTool
+        include Anthropic::Internal::Type::Converter
+        include Anthropic::Helpers::InputSchema::JsonSchemaConverter
+
+        class << self
+          # @api public
+          #
+          # @return [Class<Anthropic::Helpers::InputSchema::BaseModel>]
+          attr_reader :model
+
+          # @return [String]
+          attr_reader :doc_string
+
+          # @api public
+          #
+          # @param description [String]
+          def description(description) = (@doc_string = description)
+
+          alias_method :doc, :description
+
+          # @api public
+          #
+          # @model [Class<Anthropic::Helpers::InputSchema::BaseModel>]
+          def input_schema(model) = (@model = model)
+
+          # @api private
+          #
+          # @param depth [Integer]
+          def inspect(depth: 0) = "#{name}[#{model.inspect(depth:)}]"
+        end
+
+        # @api private
+        #
+        def to_json_schema_inner(state:) = self.class.model&.to_json_schema_inner(state:)
+
+        # @api private
+        #
+        def to_json_schema = self.class.model&.to_json_schema
+
+        # @api private
+        #
+        def dump(value, state:)
+          Anthropic::Internal::Type::Converter.dump(self.class.model, value, state:)
+        end
+
+        # @api private
+        #
+        def coerce(value, state:)
+          parsed = parse(value)
+          Anthropic::Internal::Type::Converter.coerce(self.class.model, parsed, state:)
+        end
+
+        # rubocop:disable Lint/UnusedMethodArgument
+
+        # @api public
+        #
+        # Override the `#parse` method to customize the pre-processing of the tool call argument
+        #
+        # @param value [Object]
+        #
+        # @return [Object]
+        def parse(value) = value
+
+        # @api public
+        #
+        # @param parsed [Anthropic::Helpers::InputSchema::BaseModel]
+        def call(parsed) = raise NotImplementedError.new
+
+        # rubocop:enable Lint/UnusedMethodArgument
+
+        # @api private
+        #
+        def inspect = "#<#{self.class.inspect(depth: 1)}:0x#{object_id.to_s(16)}>"
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/tools/runner.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module Tools
+      # @api private
+      #
+      class Runner
+        # @return [Anthropic::Models::Beta::MessageCreateParams]
+        attr_accessor :params
+
+        # @return [Boolean]
+        def finished? = @finished
+
+        # @param params [Array<Anthropic::Beta::BetaMessageParam>]
+        def feed_messages(*messages)
+          self.params = {**params.to_h, messages: params[:messages].to_a + messages}
+        end
+
+        # @return [Array<Anthropic::Beta::BetaMessageParam>]
+        private def current_messages = params&.[](:messages).to_a
+
+        # @return [Anthropic::Models::BetaMessage, nil]
+        def next_message
+          message = nil
+          unless finished?
+            fold do
+              message = @client.beta.messages.create(_1)
+              [true, message]
+            end
+          end
+          message
+        end
+
+        # @return [Array<Anthropic::Models::BetaMessage>]
+        def run_until_finished
+          messages = []
+          each_streaming { messages << _1.accumulated_message }
+          messages
+        end
+
+        # @yieldparam [Anthropic::Models::BetaMessage]
+        def each_message(&blk)
+          unless block_given?
+            raise ArgumentError.new("A block must be given to ##{__method__}")
+          end
+
+          fold do
+            message = @client.beta.messages.create(_1)
+            blk.call(message)
+            [false, message]
+          end
+        end
+
+        # @yieldparam [Anthropic::Internal::Stream<Anthropic::Models::Beta::BetaRawMessageStartEvent, Anthropic::Models::Beta::BetaRawMessageDeltaEvent, Anthropic::Models::Beta::BetaRawMessageStopEvent, Anthropic::Models::Beta::BetaRawContentBlockStartEvent, Anthropic::Models::Beta::BetaRawContentBlockDeltaEvent, Anthropic::Models::Beta::BetaRawContentBlockStopEvent>]
+        def each_streaming(&blk)
+          unless block_given?
+            raise ArgumentError.new("A block must be given to ##{__method__}")
+          end
+
+          fold do
+            stream = @client.beta.messages.stream(_1)
+            blk.call(stream)
+            [false, stream.accumulated_message]
+          ensure
+            stream&.close
+          end
+        end
+
+        # @api private
+        #
+        # @yieldparam [Array(Boolean, Anthropic::Models::Beta::MessageCreateParams)]
+        private def fold(&blk)
+          return nil if finished?
+
+          count =
+            case @param
+            in {max_iterations: Integer => m}
+              m
+            else
+              nil
+            end
+
+          # rubocop:disable Metrics/BlockLength
+          # rubocop:disable Style/CaseEquality
+          loop do
+            return if (count = count&.pred)&.negative?
+
+            tools = params[:tools].to_a.grep(Anthropic::Helpers::Tools::BaseTool)
+            messages = current_messages
+            brk, response = blk.call(params)
+
+            next unless current_messages.equal?(messages)
+
+            mapped =
+              response
+              .content
+              .lazy
+              .grep(Anthropic::Beta::BetaToolUseBlock)
+              .map do |tool_use|
+                resp = {type: :tool_result, tool_use_id: tool_use.id}
+                if (tool = tools.find { _1.class.model === tool_use.parsed })
+                  begin
+                    raw = tool.call(tool_use.parsed)
+                    is_error = false
+                  rescue StandardError => e
+                    is_error = true
+                    raw = e.message
+                  end
+                else
+                  is_error = true
+                  raw = "Error: parsed '#{tool_use.name}' not found"
+                end
+                content = raw.is_a?(Array) ? raw : raw.to_s
+                {**resp, content:, is_error:}
+              end
+              .to_a
+
+            if mapped.empty?
+              @finished = true
+              break
+            end
+
+            content = response.content.map do
+              case _1
+              in Anthropic::Beta::BetaToolUseBlock
+                raw = {**_1, input: _1.parsed}.except(:parsed)
+                Anthropic::Internal::Type::Converter.dump(Anthropic::Beta::BetaToolUseBlock, raw)
+              else
+                _1
+              end
+            end
+
+            messages << {role: :assistant, content:}
+            messages << {role: :user, content: mapped}
+
+            break if brk
+          end
+          # rubocop:enable Style/CaseEquality
+          # rubocop:enable Metrics/BlockLength
+        end
+
+        # @api private
+        #
+        # @param client [Anthropic::Client]
+        #
+        # @param params [Anthropic::Models::Beta::MessageCreateParams]
+        def initialize(client, params:)
+          @client = client
+          @params = params.to_h
+          @finished = false
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/tools.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Anthropic
+  BaseTool = Anthropic::Helpers::Tools::BaseTool
+end

data/lib/anthropic/internal/transport/base_client.rb

@@ -201,7 +201,8 @@ module Anthropic
             self.class::PLATFORM_HEADERS,
             {
               "accept" => "application/json",
-              "content-type" => "application/json"
+              "content-type" => "application/json",
+              "user-agent" => user_agent
             },
             headers
           )
@@ -219,6 +220,11 @@ module Anthropic
         # @return [Hash{String=>String}]
         private def auth_headers = {}
 
+        # @api private
+        #
+        # @return [String]
+        private def user_agent = "#{self.class.name}/Ruby #{Anthropic::VERSION}"
+
         # @api private
         #
         # @return [String]

data/lib/anthropic/internal/transport/pooled_net_requester.rb

@@ -16,10 +16,11 @@ module Anthropic
         class << self
           # @api private
           #
+          # @param cert_store [OpenSSL::X509::Store]
           # @param url [URI::Generic]
           #
           # @return [Net::HTTP]
-          def connect(url)
+          def connect(cert_store:, url:)
             port =
               case [url.port, url.scheme]
               in [Integer, _]
@@ -33,6 +34,8 @@ module Anthropic
             Net::HTTP.new(url.host, port).tap do
               _1.use_ssl = %w[https wss].include?(url.scheme)
               _1.max_retries = 0
+
+              (_1.cert_store = cert_store) if _1.use_ssl?
             end
           end
 
@@ -102,7 +105,7 @@ module Anthropic
           pool =
             @mutex.synchronize do
               @pools[origin] ||= ConnectionPool.new(size: @size) do
-                self.class.connect(url)
+                self.class.connect(cert_store: @cert_store, url: url)
               end
             end
 
@@ -128,40 +131,48 @@ module Anthropic
           url, deadline = request.fetch_values(:url, :deadline)
 
           req = nil
-          eof = false
           finished = false
-          closing = nil
 
           # rubocop:disable Metrics/BlockLength
           enum = Enumerator.new do |y|
             next if finished
 
             with_pool(url, deadline: deadline) do |conn|
-              req, closing = self.class.build_request(request) do
-                self.class.calibrate_socket_timeout(conn, deadline)
-              end
-
-              self.class.calibrate_socket_timeout(conn, deadline)
-              unless conn.started?
-                conn.keep_alive_timeout = self.class::KEEP_ALIVE_TIMEOUT
-                conn.start
-              end
+              eof = false
+              closing = nil
+              ::Thread.handle_interrupt(Object => :never) do
+                ::Thread.handle_interrupt(Object => :immediate) do
+                  req, closing = self.class.build_request(request) do
+                    self.class.calibrate_socket_timeout(conn, deadline)
+                  end
 
-              self.class.calibrate_socket_timeout(conn, deadline)
-              conn.request(req) do |rsp|
-                y << [req, rsp]
-                break if finished
-
-                rsp.read_body do |bytes|
-                  y << bytes.force_encoding(Encoding::BINARY)
-                  break if finished
+                  self.class.calibrate_socket_timeout(conn, deadline)
+                  unless conn.started?
+                    conn.keep_alive_timeout = self.class::KEEP_ALIVE_TIMEOUT
+                    conn.start
+                  end
 
                   self.class.calibrate_socket_timeout(conn, deadline)
+                  conn.request(req) do |rsp|
+                    y << [req, rsp]
+                    break if finished
+
+                    rsp.read_body do |bytes|
+                      y << bytes.force_encoding(Encoding::BINARY)
+                      break if finished
+
+                      self.class.calibrate_socket_timeout(conn, deadline)
+                    end
+                    eof = true
+                  end
+                end
+              ensure
+                begin
+                  conn.finish if !eof && conn&.started?
+                ensure
+                  closing&.call
                 end
-                eof = true
               end
-            ensure
-              conn.finish if !eof && conn&.started?
             end
           rescue Timeout::Error
             raise Anthropic::Errors::APITimeoutError.new(url: url, request: req)
@@ -174,8 +185,6 @@ module Anthropic
           body = Anthropic::Internal::Util.fused_enum(enum, external: true) do
             finished = true
             loop { enum.next }
-          ensure
-            closing&.call
           end
           [Integer(response.code), response, body]
         end
@@ -186,6 +195,7 @@ module Anthropic
         def initialize(size: self.class::DEFAULT_MAX_CONNECTIONS)
           @mutex = Mutex.new
           @size = size
+          @cert_store = OpenSSL::X509::Store.new.tap(&:set_default_paths)
           @pools = {}
         end
 

data/lib/anthropic/models/beta/beta_all_thinking_turns.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    module Beta
+      class BetaAllThinkingTurns < Anthropic::Internal::Type::BaseModel
+        # @!attribute type
+        #
+        #   @return [Symbol, :all]
+        required :type, const: :all
+
+        # @!method initialize(type: :all)
+        #   @param type [Symbol, :all]
+      end
+    end
+
+    BetaAllThinkingTurns = Beta::BetaAllThinkingTurns
+  end
+end

data/lib/anthropic/models/beta/beta_clear_thinking_20251015_edit.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    module Beta
+      class BetaClearThinking20251015Edit < Anthropic::Internal::Type::BaseModel
+        # @!attribute type
+        #
+        #   @return [Symbol, :clear_thinking_20251015]
+        required :type, const: :clear_thinking_20251015
+
+        # @!attribute keep
+        #   Number of most recent assistant turns to keep thinking blocks for. Older turns
+        #   will have their thinking blocks removed.
+        #
+        #   @return [Anthropic::Models::Beta::BetaThinkingTurns, Anthropic::Models::Beta::BetaAllThinkingTurns, Symbol, :all, nil]
+        optional :keep, union: -> { Anthropic::Beta::BetaClearThinking20251015Edit::Keep }
+
+        # @!method initialize(keep: nil, type: :clear_thinking_20251015)
+        #   Some parameter documentations has been truncated, see
+        #   {Anthropic::Models::Beta::BetaClearThinking20251015Edit} for more details.
+        #
+        #   @param keep [Anthropic::Models::Beta::BetaThinkingTurns, Anthropic::Models::Beta::BetaAllThinkingTurns, Symbol, :all] Number of most recent assistant turns to keep thinking blocks for. Older turns w
+        #
+        #   @param type [Symbol, :clear_thinking_20251015]
+
+        # Number of most recent assistant turns to keep thinking blocks for. Older turns
+        # will have their thinking blocks removed.
+        #
+        # @see Anthropic::Models::Beta::BetaClearThinking20251015Edit#keep
+        module Keep
+          extend Anthropic::Internal::Type::Union
+
+          variant -> { Anthropic::Beta::BetaThinkingTurns }
+
+          variant -> { Anthropic::Beta::BetaAllThinkingTurns }
+
+          variant const: :all
+
+          # @!method self.variants
+          #   @return [Array(Anthropic::Models::Beta::BetaThinkingTurns, Anthropic::Models::Beta::BetaAllThinkingTurns, Symbol, :all)]
+        end
+      end
+    end
+
+    BetaClearThinking20251015Edit = Beta::BetaClearThinking20251015Edit
+  end
+end

data/lib/anthropic/models/beta/beta_clear_thinking_20251015_edit_response.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    module Beta
+      class BetaClearThinking20251015EditResponse < Anthropic::Internal::Type::BaseModel
+        # @!attribute cleared_input_tokens
+        #   Number of input tokens cleared by this edit.
+        #
+        #   @return [Integer]
+        required :cleared_input_tokens, Integer
+
+        # @!attribute cleared_thinking_turns
+        #   Number of thinking turns that were cleared.
+        #
+        #   @return [Integer]
+        required :cleared_thinking_turns, Integer
+
+        # @!attribute type
+        #   The type of context management edit applied.
+        #
+        #   @return [Symbol, :clear_thinking_20251015]
+        required :type, const: :clear_thinking_20251015
+
+        # @!method initialize(cleared_input_tokens:, cleared_thinking_turns:, type: :clear_thinking_20251015)
+        #   @param cleared_input_tokens [Integer] Number of input tokens cleared by this edit.
+        #
+        #   @param cleared_thinking_turns [Integer] Number of thinking turns that were cleared.
+        #
+        #   @param type [Symbol, :clear_thinking_20251015] The type of context management edit applied.
+      end
+    end
+
+    BetaClearThinking20251015EditResponse = Beta::BetaClearThinking20251015EditResponse
+  end
+end

data/lib/anthropic/models/beta/beta_context_management_config.rb

@@ -7,11 +7,25 @@ module Anthropic
         # @!attribute edits
         #   List of context management edits to apply
         #
-        #   @return [Array<Anthropic::Models::Beta::BetaClearToolUses20250919Edit>, nil]
-        optional :edits, -> { Anthropic::Internal::Type::ArrayOf[Anthropic::Beta::BetaClearToolUses20250919Edit] }
+        #   @return [Array<Anthropic::Models::Beta::BetaClearToolUses20250919Edit, Anthropic::Models::Beta::BetaClearThinking20251015Edit>, nil]
+        optional :edits,
+                 -> { Anthropic::Internal::Type::ArrayOf[union: Anthropic::Beta::BetaContextManagementConfig::Edit] }
 
         # @!method initialize(edits: nil)
-        #   @param edits [Array<Anthropic::Models::Beta::BetaClearToolUses20250919Edit>] List of context management edits to apply
+        #   @param edits [Array<Anthropic::Models::Beta::BetaClearToolUses20250919Edit, Anthropic::Models::Beta::BetaClearThinking20251015Edit>] List of context management edits to apply
+
+        module Edit
+          extend Anthropic::Internal::Type::Union
+
+          discriminator :type
+
+          variant :clear_tool_uses_20250919, -> { Anthropic::Beta::BetaClearToolUses20250919Edit }
+
+          variant :clear_thinking_20251015, -> { Anthropic::Beta::BetaClearThinking20251015Edit }
+
+          # @!method self.variants
+          #   @return [Array(Anthropic::Models::Beta::BetaClearToolUses20250919Edit, Anthropic::Models::Beta::BetaClearThinking20251015Edit)]
+        end
       end
     end
 

data/lib/anthropic/models/beta/beta_context_management_response.rb

@@ -7,12 +7,25 @@ module Anthropic
         # @!attribute applied_edits
         #   List of context management edits that were applied.
         #
-        #   @return [Array<Anthropic::Models::Beta::BetaClearToolUses20250919EditResponse>]
+        #   @return [Array<Anthropic::Models::Beta::BetaClearToolUses20250919EditResponse, Anthropic::Models::Beta::BetaClearThinking20251015EditResponse>]
         required :applied_edits,
-                 -> { Anthropic::Internal::Type::ArrayOf[Anthropic::Beta::BetaClearToolUses20250919EditResponse] }
+                 -> { Anthropic::Internal::Type::ArrayOf[union: Anthropic::Beta::BetaContextManagementResponse::AppliedEdit] }
 
         # @!method initialize(applied_edits:)
-        #   @param applied_edits [Array<Anthropic::Models::Beta::BetaClearToolUses20250919EditResponse>] List of context management edits that were applied.
+        #   @param applied_edits [Array<Anthropic::Models::Beta::BetaClearToolUses20250919EditResponse, Anthropic::Models::Beta::BetaClearThinking20251015EditResponse>] List of context management edits that were applied.
+
+        module AppliedEdit
+          extend Anthropic::Internal::Type::Union
+
+          discriminator :type
+
+          variant :clear_tool_uses_20250919, -> { Anthropic::Beta::BetaClearToolUses20250919EditResponse }
+
+          variant :clear_thinking_20251015, -> { Anthropic::Beta::BetaClearThinking20251015EditResponse }
+
+          # @!method self.variants
+          #   @return [Array(Anthropic::Models::Beta::BetaClearToolUses20250919EditResponse, Anthropic::Models::Beta::BetaClearThinking20251015EditResponse)]
+        end
       end
     end
 

data/lib/anthropic/models/beta/beta_mcp_tool_use_block_param.rb

@@ -11,8 +11,8 @@ module Anthropic
 
         # @!attribute input
         #
-        #   @return [Object]
-        required :input, Anthropic::Internal::Type::Unknown
+        #   @return [Hash{Symbol=>Object}]
+        required :input, Anthropic::Internal::Type::HashOf[Anthropic::Internal::Type::Unknown]
 
         # @!attribute name
         #
@@ -39,7 +39,7 @@ module Anthropic
         # @!method initialize(id:, input:, name:, server_name:, cache_control: nil, type: :mcp_tool_use)
         #   @param id [String]
         #
-        #   @param input [Object]
+        #   @param input [Hash{Symbol=>Object}]
         #
         #   @param name [String]
         #

data/lib/anthropic/models/beta/beta_server_tool_use_block_param.rb

@@ -11,8 +11,8 @@ module Anthropic
 
         # @!attribute input
         #
-        #   @return [Object]
-        required :input, Anthropic::Internal::Type::Unknown
+        #   @return [Hash{Symbol=>Object}]
+        required :input, Anthropic::Internal::Type::HashOf[Anthropic::Internal::Type::Unknown]
 
         # @!attribute name
         #
@@ -33,7 +33,7 @@ module Anthropic
         # @!method initialize(id:, input:, name:, cache_control: nil, type: :server_tool_use)
         #   @param id [String]
         #
-        #   @param input [Object]
+        #   @param input [Hash{Symbol=>Object}]
         #
         #   @param name [Symbol, Anthropic::Models::Beta::BetaServerToolUseBlockParam::Name]
         #

data/lib/anthropic/models/beta/beta_thinking_turns.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Models
+    module Beta
+      class BetaThinkingTurns < Anthropic::Internal::Type::BaseModel
+        # @!attribute type
+        #
+        #   @return [Symbol, :thinking_turns]
+        required :type, const: :thinking_turns
+
+        # @!attribute value
+        #
+        #   @return [Integer]
+        required :value, Integer
+
+        # @!method initialize(value:, type: :thinking_turns)
+        #   @param value [Integer]
+        #   @param type [Symbol, :thinking_turns]
+      end
+    end
+
+    BetaThinkingTurns = Beta::BetaThinkingTurns
+  end
+end

data/lib/anthropic/models/beta/beta_tool.rb

@@ -66,8 +66,10 @@ module Anthropic
 
           # @!attribute properties
           #
-          #   @return [Object, nil]
-          optional :properties, Anthropic::Internal::Type::Unknown, nil?: true
+          #   @return [Hash{Symbol=>Object}, nil]
+          optional :properties,
+                   Anthropic::Internal::Type::HashOf[Anthropic::Internal::Type::Unknown],
+                   nil?: true
 
           # @!attribute required
           #
@@ -80,7 +82,7 @@ module Anthropic
           #   This defines the shape of the `input` that your tool accepts and that the model
           #   will produce.
           #
-          #   @param properties [Object, nil]
+          #   @param properties [Hash{Symbol=>Object}, nil]
           #   @param required [Array<String>, nil]
           #   @param type [Symbol, :object]
         end

data/lib/anthropic/models/beta/beta_tool_use_block.rb

@@ -24,6 +24,20 @@ module Anthropic
         #   @return [Symbol, :tool_use]
         required :type, const: :tool_use
 
+        response_only do
+          # @api public
+          #
+          # Parsed input data coerced to the tool's input schema model.
+          # Only present when tools are defined using the InputSchema DSL.
+          required :parsed, Anthropic::Internal::Type::Unknown
+
+          # @api private
+          #
+          # Internal buffer for accumulating partial JSON during streaming.
+          # Used by streaming helpers to reconstruct complete JSON input from deltas.
+          optional :_json_buf, String
+        end
+
         # @!method initialize(id:, input:, name:, type: :tool_use)
         #   @param id [String]
         #   @param input [Object]

data/lib/anthropic/models/beta/beta_tool_use_block_param.rb

@@ -11,8 +11,8 @@ module Anthropic
 
         # @!attribute input
         #
-        #   @return [Object]
-        required :input, Anthropic::Internal::Type::Unknown
+        #   @return [Hash{Symbol=>Object}]
+        required :input, Anthropic::Internal::Type::HashOf[Anthropic::Internal::Type::Unknown]
 
         # @!attribute name
         #
@@ -33,7 +33,7 @@ module Anthropic
         # @!method initialize(id:, input:, name:, cache_control: nil, type: :tool_use)
         #   @param id [String]
         #
-        #   @param input [Object]
+        #   @param input [Hash{Symbol=>Object}]
         #
         #   @param name [String]
         #