anthropic 1.1.1 → 1.9.0

data/lib/anthropic/internal/type/base_stream.rb

@@ -64,12 +64,14 @@ module Anthropic
         # @param url [URI::Generic]
         # @param status [Integer]
         # @param response [Net::HTTPResponse]
+        # @param unwrap [Symbol, Integer, Array<Symbol, Integer>, Proc]
         # @param stream [Enumerable<Object>]
-        def initialize(model:, url:, status:, response:, stream:)
+        def initialize(model:, url:, status:, response:, unwrap:, stream:)
           @model = model
           @url = url
           @status = status
           @response = response
+          @unwrap = unwrap
           @stream = stream
           @iterator = iterator
 

data/lib/anthropic/internal/type/boolean.rb

@@ -31,14 +31,20 @@ module Anthropic
         class << self
           # @api private
           #
+          # Coerce value to Boolean if possible, otherwise return the original value.
+          #
           # @param value [Boolean, Object]
           #
           # @param state [Hash{Symbol=>Object}] .
           #
-          #   @option state [Boolean, :strong] :strictness
+          #   @option state [Boolean] :translate_names
+          #
+          #   @option state [Boolean] :strictness
           #
           #   @option state [Hash{Symbol=>Object}] :exactness
           #
+          #   @option state [Class<StandardError>] :error
+          #
           #   @option state [Integer] :branched
           #
           # @return [Boolean, Object]

data/lib/anthropic/internal/type/converter.rb

@@ -15,10 +15,14 @@ module Anthropic
         #
         # @param state [Hash{Symbol=>Object}] .
         #
-        #   @option state [Boolean, :strong] :strictness
+        #   @option state [Boolean] :translate_names
+        #
+        #   @option state [Boolean] :strictness
         #
         #   @option state [Hash{Symbol=>Object}] :exactness
         #
+        #   @option state [Class<StandardError>] :error
+        #
         #   @option state [Integer] :branched
         #
         # @return [Object]
@@ -94,6 +98,48 @@ module Anthropic
             end
           end
 
+          # @api private
+          #
+          # @param type_info [Hash{Symbol=>Object}, Proc, Anthropic::Internal::Type::Converter, Class] .
+          #
+          #   @option type_info [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const
+          #
+          #   @option type_info [Proc] :enum
+          #
+          #   @option type_info [Proc] :union
+          #
+          #   @option type_info [Boolean] :"nil?"
+          #
+          # @param spec [Hash{Symbol=>Object}, Proc, Anthropic::Internal::Type::Converter, Class] .
+          #
+          #   @option spec [NilClass, TrueClass, FalseClass, Integer, Float, Symbol] :const
+          #
+          #   @option spec [Proc] :enum
+          #
+          #   @option spec [Proc] :union
+          #
+          #   @option spec [Boolean] :"nil?"
+          #
+          # @return [Hash{Symbol=>Object}]
+          def meta_info(type_info, spec)
+            [spec, type_info].grep(Hash).first.to_h.except(:const, :enum, :union, :nil?)
+          end
+
+          # @api private
+          #
+          # @param translate_names [Boolean]
+          #
+          # @return [Hash{Symbol=>Object}]
+          def new_coerce_state(translate_names: true)
+            {
+              translate_names: translate_names,
+              strictness: true,
+              exactness: {yes: 0, no: 0, maybe: 0},
+              error: nil,
+              branched: 0
+            }
+          end
+
           # @api private
           #
           # Based on `target`, transform `value` into `target`, to the extent possible:
@@ -110,14 +156,11 @@ module Anthropic
           #
           # @param value [Object]
           #
-          # @param state [Hash{Symbol=>Object}] The `strictness` is one of `true`, `false`, or `:strong`. This informs the
-          # coercion strategy when we have to decide between multiple possible conversion
-          # targets:
+          # @param state [Hash{Symbol=>Object}] The `strictness` is one of `true`, `false`. This informs the coercion strategy
+          # when we have to decide between multiple possible conversion targets:
           #
           # - `true`: the conversion must be exact, with minimum coercion.
           # - `false`: the conversion can be approximate, with some coercion.
-          # - `:strong`: the conversion must be exact, with no coercion, and raise an error
-          #   if not possible.
           #
           # The `exactness` is `Hash` with keys being one of `yes`, `no`, or `maybe`. For
           # any given conversion attempt, the exactness will be updated based on how closely
@@ -130,21 +173,20 @@ module Anthropic
           #
           # See implementation below for more details.
           #
-          #   @option state [Boolean, :strong] :strictness
+          #   @option state [Boolean] :translate_names
+          #
+          #   @option state [Boolean] :strictness
           #
           #   @option state [Hash{Symbol=>Object}] :exactness
           #
+          #   @option state [Class<StandardError>] :error
+          #
           #   @option state [Integer] :branched
           #
           # @return [Object]
-          def coerce(
-            target,
-            value,
-            state: {strictness: true, exactness: {yes: 0, no: 0, maybe: 0}, branched: 0}
-          )
-            # rubocop:disable Lint/SuppressedException
+          def coerce(target, value, state: Anthropic::Internal::Type::Converter.new_coerce_state)
             # rubocop:disable Metrics/BlockNesting
-            strictness, exactness = state.fetch_values(:strictness, :exactness)
+            exactness = state.fetch(:exactness)
 
             case target
             in Anthropic::Internal::Type::Converter
@@ -160,29 +202,26 @@ module Anthropic
                 exactness[value.nil? ? :yes : :maybe] += 1
                 return nil
               in -> { _1 <= Integer }
-                if value.is_a?(Integer)
+                case value
+                in Integer
                   exactness[:yes] += 1
                   return value
-                elsif strictness == :strong && Integer(value, exception: false) != value
-                  message = "no implicit conversion of #{value.class} into #{target.inspect}"
-                  raise value.is_a?(Numeric) ? ArgumentError.new(message) : TypeError.new(message)
                 else
                   Kernel.then do
                     return Integer(value).tap { exactness[:maybe] += 1 }
-                  rescue ArgumentError, TypeError
+                  rescue ArgumentError, TypeError => e
+                    state[:error] = e
                   end
                 end
               in -> { _1 <= Float }
                 if value.is_a?(Numeric)
                   exactness[:yes] += 1
                   return Float(value)
-                elsif strictness == :strong
-                  message = "no implicit conversion of #{value.class} into #{target.inspect}"
-                  raise TypeError.new(message)
                 else
                   Kernel.then do
                     return Float(value).tap { exactness[:maybe] += 1 }
-                  rescue ArgumentError, TypeError
+                  rescue ArgumentError, TypeError => e
+                    state[:error] = e
                   end
                 end
               in -> { _1 <= String }
@@ -194,16 +233,13 @@ module Anthropic
                   exactness[:yes] += 1
                   return value.string
                 else
-                  if strictness == :strong
-                    message = "no implicit conversion of #{value.class} into #{target.inspect}"
-                    raise TypeError.new(message)
-                  end
+                  state[:error] = TypeError.new("#{value.class} can't be coerced into #{String}")
                 end
               in -> { _1 <= Date || _1 <= Time }
                 Kernel.then do
                   return target.parse(value).tap { exactness[:yes] += 1 }
                 rescue ArgumentError, TypeError => e
-                  raise e if strictness == :strong
+                  state[:error] = e
                 end
               in -> { _1 <= StringIO } if value.is_a?(String)
                 exactness[:yes] += 1
@@ -221,10 +257,8 @@ module Anthropic
                   return value
                 end
               else
-                if strictness == :strong
-                  message = "cannot convert non-matching #{value.class} into #{target.inspect}"
-                  raise ArgumentError.new(message)
-                end
+                message = "cannot convert non-matching #{value.class} into #{target.inspect}"
+                state[:error] = ArgumentError.new(message)
               end
             else
             end
@@ -232,7 +266,6 @@ module Anthropic
             exactness[:no] += 1
             value
             # rubocop:enable Metrics/BlockNesting
-            # rubocop:enable Lint/SuppressedException
           end
 
           # @api private
@@ -277,8 +310,10 @@ module Anthropic
         define_sorbet_constant!(:CoerceState) do
           T.type_alias do
             {
-              strictness: T.any(T::Boolean, Symbol),
+              translate_names: T::Boolean,
+              strictness: T::Boolean,
               exactness: {yes: Integer, no: Integer, maybe: Integer},
+              error: T::Class[StandardError],
               branched: Integer
             }
           end

data/lib/anthropic/internal/type/enum.rb

@@ -81,10 +81,14 @@ module Anthropic
         #
         # @param state [Hash{Symbol=>Object}] .
         #
-        #   @option state [Boolean, :strong] :strictness
+        #   @option state [Boolean] :translate_names
+        #
+        #   @option state [Boolean] :strictness
         #
         #   @option state [Hash{Symbol=>Object}] :exactness
         #
+        #   @option state [Class<StandardError>] :error
+        #
         #   @option state [Integer] :branched
         #
         # @return [Symbol, Object]
@@ -95,8 +99,12 @@ module Anthropic
           if values.include?(val)
             exactness[:yes] += 1
             val
+          elsif values.first&.class == val.class
+            exactness[:maybe] += 1
+            value
           else
-            exactness[values.first&.class == val.class ? :maybe : :no] += 1
+            exactness[:no] += 1
+            state[:error] = TypeError.new("#{value.class} can't be coerced into #{self}")
             value
           end
         end
@@ -116,11 +124,14 @@ module Anthropic
         #
         # @return [Object]
         def to_sorbet_type
-          case values
+          types = values.map { Anthropic::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(_1) }.uniq
+          case types
           in []
             T.noreturn
-          in [value, *_]
-            T.all(Anthropic::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(value), self)
+          in [type]
+            type
+          else
+            T.any(*types)
           end
         end
 

data/lib/anthropic/internal/type/file_input.rb

@@ -45,10 +45,14 @@ module Anthropic
           #
           # @param state [Hash{Symbol=>Object}] .
           #
-          #   @option state [Boolean, :strong] :strictness
+          #   @option state [Boolean] :translate_names
+          #
+          #   @option state [Boolean] :strictness
           #
           #   @option state [Hash{Symbol=>Object}] :exactness
           #
+          #   @option state [Class<StandardError>] :error
+          #
           #   @option state [Integer] :branched
           #
           # @return [StringIO, Object]
@@ -62,6 +66,7 @@ module Anthropic
               exactness[:yes] += 1
               value
             else
+              state[:error] = TypeError.new("#{value.class} can't be coerced into #{StringIO}")
               exactness[:no] += 1
               value
             end

data/lib/anthropic/internal/type/hash_of.rb

@@ -77,10 +77,14 @@ module Anthropic
         #
         # @param state [Hash{Symbol=>Object}] .
         #
-        #   @option state [Boolean, :strong] :strictness
+        #   @option state [Boolean] :translate_names
+        #
+        #   @option state [Boolean] :strictness
         #
         #   @option state [Hash{Symbol=>Object}] :exactness
         #
+        #   @option state [Class<StandardError>] :error
+        #
         #   @option state [Integer] :branched
         #
         # @return [Hash{Symbol=>Object}, Object]
@@ -89,6 +93,7 @@ module Anthropic
 
           unless value.is_a?(Hash)
             exactness[:no] += 1
+            state[:error] = TypeError.new("#{value.class} can't be coerced into #{Hash}")
             return value
           end
 
@@ -163,6 +168,7 @@ module Anthropic
         #   @option spec [Boolean] :"nil?"
         def initialize(type_info, spec = {})
           @item_type_fn = Anthropic::Internal::Type::Converter.type_info(type_info || spec)
+          @meta = Anthropic::Internal::Type::Converter.meta_info(type_info, spec)
           @nilable = spec.fetch(:nil?, false)
         end
 

data/lib/anthropic/internal/type/union.rb

@@ -37,20 +37,20 @@ module Anthropic
         #
         # All of the specified variant info for this union.
         #
-        # @return [Array<Array(Symbol, Proc)>]
+        # @return [Array<Array(Symbol, Proc, Hash{Symbol=>Object})>]
         private def known_variants = (@known_variants ||= [])
 
         # @api private
         #
-        # @return [Array<Array(Symbol, Object)>]
+        # @return [Array<Array(Symbol, Object, Hash{Symbol=>Object})>]
         protected def derefed_variants
-          known_variants.map { |key, variant_fn| [key, variant_fn.call] }
+          known_variants.map { |key, variant_fn, meta| [key, variant_fn.call, meta] }
         end
 
         # All of the specified variants for this union.
         #
         # @return [Array<Object>]
-        def variants = derefed_variants.map(&:last)
+        def variants = derefed_variants.map { _2 }
 
         # @api private
         #
@@ -76,12 +76,13 @@ module Anthropic
         #
         #   @option spec [Boolean] :"nil?"
         private def variant(key, spec = nil)
+          meta = Anthropic::Internal::Type::Converter.meta_info(nil, spec)
           variant_info =
             case key
             in Symbol
-              [key, Anthropic::Internal::Type::Converter.type_info(spec)]
+              [key, Anthropic::Internal::Type::Converter.type_info(spec), meta]
             in Proc | Anthropic::Internal::Type::Converter | Class | Hash
-              [nil, Anthropic::Internal::Type::Converter.type_info(key)]
+              [nil, Anthropic::Internal::Type::Converter.type_info(key), meta]
             end
 
           known_variants << variant_info
@@ -104,7 +105,8 @@ module Anthropic
             return nil if key == Anthropic::Internal::OMIT
 
             key = key.to_sym if key.is_a?(String)
-            known_variants.find { |k,| k == key }&.last&.call
+            _, found = known_variants.find { |k,| k == key }
+            found&.call
           else
             nil
           end
@@ -140,14 +142,23 @@ module Anthropic
 
         # @api private
         #
+        # Tries to efficiently coerce the given value to one of the known variants.
+        #
+        # If the value cannot match any of the known variants, the coercion is considered
+        # non-viable and returns the original value.
+        #
         # @param value [Object]
         #
         # @param state [Hash{Symbol=>Object}] .
         #
-        #   @option state [Boolean, :strong] :strictness
+        #   @option state [Boolean] :translate_names
+        #
+        #   @option state [Boolean] :strictness
         #
         #   @option state [Hash{Symbol=>Object}] :exactness
         #
+        #   @option state [Class<StandardError>] :error
+        #
         #   @option state [Integer] :branched
         #
         # @return [Object]
@@ -158,7 +169,6 @@ module Anthropic
 
           strictness = state.fetch(:strictness)
           exactness = state.fetch(:exactness)
-          state[:strictness] = strictness == :strong ? true : strictness
 
           alternatives = []
           known_variants.each do |_, variant_fn|
@@ -177,13 +187,10 @@ module Anthropic
             end
           end
 
-          case alternatives.sort_by(&:first)
+          case alternatives.sort_by!(&:first)
           in []
             exactness[:no] += 1
-            if strictness == :strong
-              message = "no possible conversion of #{value.class} into a variant of #{target.inspect}"
-              raise ArgumentError.new(message)
-            end
+            state[:error] = ArgumentError.new("no matching variant for #{value.inspect}")
             value
           in [[_, exact, coerced], *]
             exact.each { exactness[_1] += _2 }
@@ -220,11 +227,14 @@ module Anthropic
         #
         # @return [Object]
         def to_sorbet_type
-          case (v = variants)
+          types = variants.map { Anthropic::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(_1) }.uniq
+          case types
           in []
             T.noreturn
+          in [type]
+            type
           else
-            T.any(*v.map { Anthropic::Internal::Util::SorbetRuntimeSupport.to_sorbet_type(_1) })
+            T.any(*types)
           end
         end
 

data/lib/anthropic/internal/type/unknown.rb

@@ -33,14 +33,20 @@ module Anthropic
         class << self
           # @api private
           #
+          # No coercion needed for Unknown type.
+          #
           # @param value [Object]
           #
           # @param state [Hash{Symbol=>Object}] .
           #
-          #   @option state [Boolean, :strong] :strictness
+          #   @option state [Boolean] :translate_names
+          #
+          #   @option state [Boolean] :strictness
           #
           #   @option state [Hash{Symbol=>Object}] :exactness
           #
+          #   @option state [Class<StandardError>] :error
+          #
           #   @option state [Integer] :branched
           #
           # @return [Object]

data/lib/anthropic/internal/util.rb

@@ -244,7 +244,7 @@ module Anthropic
         #
         # @return [String]
         def uri_origin(uri)
-          "#{uri.scheme}://#{uri.host}#{uri.port == uri.default_port ? '' : ":#{uri.port}"}"
+          "#{uri.scheme}://#{uri.host}#{":#{uri.port}" unless uri.port == uri.default_port}"
         end
 
         # @api private
@@ -497,7 +497,7 @@ module Anthropic
         # @param closing [Array<Proc>]
         # @param content_type [String, nil]
         private def write_multipart_content(y, val:, closing:, content_type: nil)
-          content_type ||= "application/octet-stream"
+          content_line = "Content-Type: %s\r\n\r\n"
 
           case val
           in Anthropic::FilePart
@@ -508,24 +508,21 @@ module Anthropic
               content_type: val.content_type
             )
           in Pathname
-            y << "Content-Type: #{content_type}\r\n\r\n"
+            y << format(content_line, content_type || "application/octet-stream")
             io = val.open(binmode: true)
             closing << io.method(:close)
             IO.copy_stream(io, y)
           in IO
-            y << "Content-Type: #{content_type}\r\n\r\n"
+            y << format(content_line, content_type || "application/octet-stream")
             IO.copy_stream(val, y)
           in StringIO
-            y << "Content-Type: #{content_type}\r\n\r\n"
+            y << format(content_line, content_type || "application/octet-stream")
             y << val.string
-          in String
-            y << "Content-Type: #{content_type}\r\n\r\n"
-            y << val.to_s
           in -> { primitive?(_1) }
-            y << "Content-Type: text/plain\r\n\r\n"
+            y << format(content_line, content_type || "text/plain")
             y << val.to_s
           else
-            y << "Content-Type: application/json\r\n\r\n"
+            y << format(content_line, content_type || "application/json")
             y << JSON.generate(val)
           end
           y << "\r\n"
@@ -563,11 +560,13 @@ module Anthropic
 
         # @api private
         #
+        # https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.1.md#special-considerations-for-multipart-content
+        #
         # @param body [Object]
         #
         # @return [Array(String, Enumerable<String>)]
         private def encode_multipart_streaming(body)
-          boundary = SecureRandom.urlsafe_base64(60)
+          boundary = SecureRandom.urlsafe_base64(30)
 
           closing = []
           strio = writable_enum do |y|

data/lib/anthropic/models/anthropic_beta.rb

@@ -35,6 +35,8 @@ module Anthropic
 
       variant const: -> { Anthropic::Models::AnthropicBeta::EXTENDED_CACHE_TTL_2025_04_11 }
 
+      variant const: -> { Anthropic::Models::AnthropicBeta::CONTEXT_1M_2025_08_07 }
+
       # @!method self.variants
       #   @return [Array(String, Symbol)]
 
@@ -58,6 +60,7 @@ module Anthropic
       INTERLEAVED_THINKING_2025_05_14 = :"interleaved-thinking-2025-05-14"
       CODE_EXECUTION_2025_05_22 = :"code-execution-2025-05-22"
       EXTENDED_CACHE_TTL_2025_04_11 = :"extended-cache-ttl-2025-04-11"
+      CONTEXT_1M_2025_08_07 = :"context-1m-2025-08-07"
 
       # @!endgroup
     end

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

@@ -3,71 +3,7 @@
 module Anthropic
   module Models
     module Beta
-      class BetaBase64PDFBlock < Anthropic::Internal::Type::BaseModel
-        # @!attribute source
-        #
-        #   @return [Anthropic::Models::Beta::BetaBase64PDFSource, Anthropic::Models::Beta::BetaPlainTextSource, Anthropic::Models::Beta::BetaContentBlockSource, Anthropic::Models::Beta::BetaURLPDFSource, Anthropic::Models::Beta::BetaFileDocumentSource]
-        required :source, union: -> { Anthropic::Beta::BetaBase64PDFBlock::Source }
-
-        # @!attribute type
-        #
-        #   @return [Symbol, :document]
-        required :type, const: :document
-
-        # @!attribute cache_control
-        #   Create a cache control breakpoint at this content block.
-        #
-        #   @return [Anthropic::Models::Beta::BetaCacheControlEphemeral, nil]
-        optional :cache_control, -> { Anthropic::Beta::BetaCacheControlEphemeral }, nil?: true
-
-        # @!attribute citations
-        #
-        #   @return [Anthropic::Models::Beta::BetaCitationsConfigParam, nil]
-        optional :citations, -> { Anthropic::Beta::BetaCitationsConfigParam }
-
-        # @!attribute context
-        #
-        #   @return [String, nil]
-        optional :context, String, nil?: true
-
-        # @!attribute title
-        #
-        #   @return [String, nil]
-        optional :title, String, nil?: true
-
-        # @!method initialize(source:, cache_control: nil, citations: nil, context: nil, title: nil, type: :document)
-        #   @param source [Anthropic::Models::Beta::BetaBase64PDFSource, Anthropic::Models::Beta::BetaPlainTextSource, Anthropic::Models::Beta::BetaContentBlockSource, Anthropic::Models::Beta::BetaURLPDFSource, Anthropic::Models::Beta::BetaFileDocumentSource]
-        #
-        #   @param cache_control [Anthropic::Models::Beta::BetaCacheControlEphemeral, nil] Create a cache control breakpoint at this content block.
-        #
-        #   @param citations [Anthropic::Models::Beta::BetaCitationsConfigParam]
-        #
-        #   @param context [String, nil]
-        #
-        #   @param title [String, nil]
-        #
-        #   @param type [Symbol, :document]
-
-        # @see Anthropic::Models::Beta::BetaBase64PDFBlock#source
-        module Source
-          extend Anthropic::Internal::Type::Union
-
-          discriminator :type
-
-          variant :base64, -> { Anthropic::Beta::BetaBase64PDFSource }
-
-          variant :text, -> { Anthropic::Beta::BetaPlainTextSource }
-
-          variant :content, -> { Anthropic::Beta::BetaContentBlockSource }
-
-          variant :url, -> { Anthropic::Beta::BetaURLPDFSource }
-
-          variant :file, -> { Anthropic::Beta::BetaFileDocumentSource }
-
-          # @!method self.variants
-          #   @return [Array(Anthropic::Models::Beta::BetaBase64PDFSource, Anthropic::Models::Beta::BetaPlainTextSource, Anthropic::Models::Beta::BetaContentBlockSource, Anthropic::Models::Beta::BetaURLPDFSource, Anthropic::Models::Beta::BetaFileDocumentSource)]
-        end
-      end
+      BetaBase64PDFBlock = Anthropic::Models::Beta::BetaRequestDocumentBlock
     end
 
     BetaBase64PDFBlock = Beta::BetaBase64PDFBlock

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

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