anthropic 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66fd9539680e78df8e330ac6a5c6efc4848f35c6878eb56ef0b491511562ecf1
-  data.tar.gz: 43ef2cdd7fd4f7d95d889115dbf302edb8355681283aec9b76f80f7b1734ee67
+  metadata.gz: 5bffc3e0dc22d67590f26385ec3af28ad569d31d7c7c9ba90245e39122addd1c
+  data.tar.gz: 0f498573a662f41c2adc7a0d01cdd7113a8a27b94f3db60e7f4b03be91abf999
 SHA512:
-  metadata.gz: 55fb0db67745e8506eb2a2ae9708908cf72f1f16eb795d1a4279962864d25e5f972b3be3f53cdacb0293ef17c9c8e84a65643158604c1e50de28fc44aaa7e494
-  data.tar.gz: 1d479ce6f1b913816cf60d1778f039d874ce701077d1ed6187c9df5e7ba3ce0254da280753c55607343b64ef62aae72c72540a3e28ce5de49a7117b14e326bca
+  metadata.gz: 106bf53c21f57d53c2fc1aad81be8aa244093c03b246e175de0cab37fc876aa99cd0b2ddf8448460a88201bba57e3893ca0c2c32bc4b65001b9a5aea3e223694
+  data.tar.gz: 3199e41a1e31cdd83142fe37c35a8d016b948106c4416ecf75b475d6c392057c44392b635d3b9d5f88564b6df4ee9e2480d56cf5d407b3d68d91f27e8b5a88c3

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 1.8.0 (2025-09-02)
+
+Full Changelog: [v1.7.0...v1.8.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.7.0...v1.8.0)
+
+### Features
+
+* **client:** adds support for code-execution-2025-08-26 tool ([28e554e](https://github.com/anthropics/anthropic-sdk-ruby/commit/28e554ec75e8c34d20ef1e021672f9a02d5be3ec))
+* input schemas ([#660](https://github.com/anthropics/anthropic-sdk-ruby/issues/660)) ([3e062c0](https://github.com/anthropics/anthropic-sdk-ruby/commit/3e062c03b0fc964877095a34cb69de9ba63dfa19))
+
+
+### Bug Fixes
+
+* bump sorbet version and fix new type errors from the breaking change ([3c4f15d](https://github.com/anthropics/anthropic-sdk-ruby/commit/3c4f15d8f4115d6da6d8589856e7654162f91110))
+* correctly raise errors encountered during streaming ([be9bc45](https://github.com/anthropics/anthropic-sdk-ruby/commit/be9bc45d96ac227fd5648281199a7c8dd234897d))
+
+
+### Chores
+
+* add json schema comment for rubocop.yml ([3fce402](https://github.com/anthropics/anthropic-sdk-ruby/commit/3fce4021da72749b127adacee9436327d4b03f60))
+
 ## 1.7.0 (2025-08-13)
 
 Full Changelog: [v1.6.0...v1.7.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.6.0...v1.7.0)

data/README.md

@@ -15,7 +15,7 @@ To use this gem, install via Bundler by adding the following to your application
 <!-- x-release-please-start-version -->
 
 ```ruby
-gem "anthropic", "~> 1.7.0"
+gem "anthropic", "~> 1.8.0"
 ```
 
 <!-- x-release-please-end -->

data/lib/anthropic/helpers/input_schema/array_of.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      # @generic Elem
+      #
+      # @example
+      #   example = Anthropic::ArrayOf[Integer]
+      #
+      # @example
+      #   example = Anthropic::ArrayOf[Integer, nil?: true, doc: "hi there!"]
+      class ArrayOf < Anthropic::Internal::Type::ArrayOf
+        include Anthropic::Helpers::InputSchema::JsonSchemaConverter
+
+        # @api private
+        #
+        # @param state [Hash{Symbol=>Object}]
+        #
+        #   @option state [Hash{Object=>String}] :defs
+        #
+        #   @option state [Array<String>] :path
+        #
+        # @return [Hash{Symbol=>Object}]
+        def to_json_schema_inner(state:)
+          Anthropic::Helpers::InputSchema::JsonSchemaConverter.cache_def!(state, type: self) do
+            state.fetch(:path) << "[]"
+            items = Anthropic::Helpers::InputSchema::JsonSchemaConverter.to_json_schema_inner(
+              item_type,
+              state: state
+            )
+            items = Anthropic::Helpers::InputSchema::JsonSchemaConverter.to_nilable(items) if nilable?
+            Anthropic::Helpers::InputSchema::JsonSchemaConverter.assoc_meta!(items, meta: @meta)
+
+            {type: "array", items: items}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/input_schema/base_model.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      # Represents a response from Anthropic's API where the model's output has been structured according to a schema predefined by the user.
+      #
+      # This class is specifically used when making requests with the `input_schema` parameter.
+      #
+      # See {examples/input_schemas.rb} for a complete example of use
+      class BaseModel < Anthropic::Internal::Type::BaseModel
+        extend Anthropic::Helpers::InputSchema::JsonSchemaConverter
+
+        class << self
+          # @return [Hash{Symbol=>Object}]
+          def to_json_schema = Anthropic::Helpers::InputSchema::JsonSchemaConverter.to_json_schema(self)
+
+          # @api private
+          #
+          # @param state [Hash{Symbol=>Object}]
+          #
+          #   @option state [Hash{Object=>String}] :defs
+          #
+          #   @option state [Array<String>] :path
+          #
+          # @return [Hash{Symbol=>Object}]
+          def to_json_schema_inner(state:)
+            Anthropic::Helpers::InputSchema::JsonSchemaConverter.cache_def!(state, type: self) do
+              path = state.fetch(:path)
+              properties = fields.to_h do |name, field|
+                type, nilable, meta = field.fetch_values(:type, :nilable, :meta)
+                new_state = {**state, path: [*path, ".#{name}"]}
+
+                schema =
+                  case type
+                  in Anthropic::Helpers::InputSchema::JsonSchemaConverter
+                    type.to_json_schema_inner(state: new_state)
+                  else
+                    Anthropic::Helpers::InputSchema::JsonSchemaConverter.to_json_schema_inner(
+                      type,
+                      state: new_state
+                    )
+                  end
+                Anthropic::Helpers::InputSchema::JsonSchemaConverter.assoc_meta!(schema, meta: meta)
+                schema = Anthropic::Helpers::InputSchema::JsonSchemaConverter.to_nilable(schema) if nilable
+
+                [name, schema]
+              end
+
+              {
+                type: "object",
+                properties: properties,
+                required: fields.select { _2.fetch(:required) }.keys.map(&:to_s),
+                additionalProperties: false
+              }.tap { _1.store(:description, @doc_string) unless @doc_string.nil? }
+            end
+          end
+        end
+
+        class << self
+          def required(name_sym, type_info, *args)
+            spec = process_field_args(args)
+            super(name_sym, type_info, spec)
+          end
+
+          def optional(name_sym, type_info, *args)
+            spec = process_field_args(args)
+            super(name_sym, type_info, spec)
+          end
+
+          attr_reader :doc_string
+
+          # @param description [String]
+          def doc(description)
+            @doc_string = description
+          end
+
+          private def process_field_args(args)
+            # Only accept hash format for descriptions.
+            args.grep(Hash).first.to_h
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/input_schema/boolean.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      # @abstract
+      #
+      # Ruby does not have a "boolean" Class, this is something for models to refer to.
+      class Boolean < Anthropic::Internal::Type::Boolean
+        extend Anthropic::Helpers::InputSchema::JsonSchemaConverter
+
+        # rubocop:disable Lint/UnusedMethodArgument
+
+        # @api private
+        #
+        # @param state [Hash{Symbol=>Object}]
+        #
+        #   @option state [Hash{Object=>String}] :defs
+        #
+        #   @option state [Array<String>] :path
+        #
+        # @return [Hash{Symbol=>Object}]
+        def self.to_json_schema_inner(state:) = {type: "boolean"}
+
+        # rubocop:enable Lint/UnusedMethodArgument
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/input_schema/enum_of.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      # @generic Value
+      #
+      # @example
+      #   example = Anthropic::EnumOf[:foo, :bar, :zoo]
+      #
+      # @example
+      #   example = Anthropic::EnumOf[1, 2, 3]
+      class EnumOf
+        include Anthropic::Internal::Type::Enum
+        include Anthropic::Helpers::InputSchema::JsonSchemaConverter
+
+        # @api private
+        #
+        # @param state [Hash{Symbol=>Object}]
+        #
+        #   @option state [Hash{Object=>String}] :defs
+        #
+        #   @option state [Array<String>] :path
+        #
+        # @return [Hash{Symbol=>Object}]
+        def to_json_schema_inner(state:)
+          Anthropic::Helpers::InputSchema::JsonSchemaConverter.cache_def!(state, type: self) do
+            types = values.map do
+              case _1
+              in NilClass
+                "null"
+              in true | false
+                "boolean"
+              in Integer
+                "integer"
+              in Float
+                "number"
+              in Symbol
+                "string"
+              end
+            end
+              .uniq
+
+            {
+              type: types.length == 1 ? types.first : types,
+              enum: values.map { _1.is_a?(Symbol) ? _1.to_s : _1 }
+            }
+          end
+        end
+
+        private_class_method :new
+
+        def self.[](...) = new(...)
+
+        # @return [Array<generic<Value>>]
+        attr_reader :values
+
+        # @param values [Array<generic<Value>>]
+        def initialize(*values) = (@values = values.map { _1.is_a?(String) ? _1.to_sym : _1 })
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/input_schema/json_schema_converter.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      # To customize the JSON schema conversion for a type, implement the `JsonSchemaConverter` interface.
+      module JsonSchemaConverter
+        # @api private
+        POINTERS = Object.new.tap do
+          _1.define_singleton_method(:inspect) do
+            "#<#{Anthropic::Helpers::InputSchema::JsonSchemaConverter}::POINTERS>"
+          end
+        end.freeze
+        # @api private
+        NO_REF = Object.new.tap do
+          _1.define_singleton_method(:inspect) do
+            "#<#{Anthropic::Helpers::InputSchema::JsonSchemaConverter}::NO_REF>"
+          end
+        end.freeze
+
+        # rubocop:disable Lint/UnusedMethodArgument
+
+        # The exact JSON schema produced is subject to improvement between minor release versions.
+        #
+        # @param state [Hash{Symbol=>Object}]
+        #
+        #   @option state [Hash{Object=>String}] :defs
+        #
+        #   @option state [Array<String>] :path
+        #
+        # @return [Hash{Symbol=>Object}]
+        def to_json_schema_inner(state:) = (raise NotImplementedError)
+
+        # rubocop:enable Lint/UnusedMethodArgument
+
+        # Internal helpers methods.
+        class << self
+          # @api private
+          #
+          # @param schema [Hash{Symbol=>Object}]
+          #
+          # @return [Hash{Symbol=>Object}]
+          def to_nilable(schema)
+            null = "null"
+            case schema
+            in {"$ref": String} | {allOf: _}
+              # For references (simple or with allOf pattern for descriptions),
+              # wrap in anyOf with null. The allOf pattern is used when we need
+              # to add a description to a $ref (JSON Schema doesn't allow
+              # additional properties alongside $ref).
+              {anyOf: [schema, {type: null}]}
+            in {anyOf: schemas}
+              null = {type: null}
+              schemas.any? { _1 == null || _1 == {type: ["null"]} } ? schema : {anyOf: [*schemas, null]}
+            in {type: String => type}
+              type == null ? schema : schema.update(type: [type, null])
+            in {type: Array => types}
+              types.include?(null) ? schema : schema.update(type: [*types, null])
+            end
+          end
+
+          # @api private
+          #
+          # @param schema [Hash{Symbol=>Object}]
+          def assoc_meta!(schema, meta:)
+            xformed = meta.transform_keys(Anthropic::Helpers::InputSchema::PROPERTY_MAPPING)
+            schema.merge!(xformed)
+          end
+
+          # @api private
+          #
+          # @param state [Hash{Symbol=>Object}]
+          #
+          #   @option state [Hash{Object=>String}] :defs
+          #
+          #   @option state [Array<String>] :path
+          #
+          # @param type [Object]
+          #
+          # @param blk [Proc]
+          #
+          def cache_def!(state, type:, &blk)
+            defs, path = state.fetch_values(:defs, :path)
+            if (stored = defs[type])
+              pointers = stored.fetch(Anthropic::Helpers::InputSchema::JsonSchemaConverter::POINTERS)
+              pointers.first.except(Anthropic::Helpers::InputSchema::JsonSchemaConverter::NO_REF).tap do
+                pointers << _1
+              end
+            else
+              ref_path = String.new
+              ref = {"$ref": ref_path}
+              stored = {
+                Anthropic::Helpers::InputSchema::JsonSchemaConverter::POINTERS => [ref]
+              }
+              defs.store(type, stored)
+              schema = blk.call
+              ref_path.replace("#/$defs/#{path.join('/')}")
+              stored.update(schema)
+              ref
+            end
+          end
+
+          # @api private
+          #
+          # @param type [Anthropic::Helpers::InputSchema::JsonSchemaConverter, Class]
+          #
+          # @return [Hash{Symbol=>Object}]
+          def to_json_schema(type)
+            defs = {}
+            state = {defs: defs, path: []}
+            schema = Anthropic::Helpers::InputSchema::JsonSchemaConverter.to_json_schema_inner(
+              type,
+              state: state
+            )
+            reused_defs = {}
+            defs.each_value do |acc|
+              sch = acc.except(Anthropic::Helpers::InputSchema::JsonSchemaConverter::POINTERS)
+              pointers = acc.fetch(Anthropic::Helpers::InputSchema::JsonSchemaConverter::POINTERS)
+
+              no_refs, refs = pointers.partition do
+                _1.delete(Anthropic::Helpers::InputSchema::JsonSchemaConverter::NO_REF)
+              end
+
+              case refs
+              in [ref]
+                ref.replace(ref.except(:$ref).merge(sch))
+              in [_, ref, *]
+                reused_defs.store(ref.fetch(:$ref), sch)
+                refs.each do
+                  next if (meta = _1.except(:$ref)).empty?
+                  # JSON Schema does not allow keyword properties to be defined alongside a $ref.
+                  # If we have a keyword property associated with a $ref, it must be wrapped in an allOf.
+                  _1.replace(allOf: [_1.slice(:$ref), meta])
+                end
+              else
+              end
+              no_refs.each { _1.replace(_1.except(:$ref).merge(sch)) }
+            end
+
+            xformed = reused_defs.transform_keys { _1.delete_prefix("#/$defs/") }
+            xformed.empty? ? schema : {"$defs": xformed}.update(schema)
+          end
+
+          # @api private
+          #
+          # @param type [Anthropic::Helpers::InputSchema::JsonSchemaConverter, Class]
+          #
+          # @param state [Hash{Symbol=>Object}]
+          #
+          #   @option state [Hash{Object=>String}] :defs
+          #
+          #   @option state [Array<String>] :path
+          #
+          # @return [Hash{Symbol=>Object}]
+          def to_json_schema_inner(type, state:)
+            case type
+            in {"$ref": String}
+              return type
+            in Anthropic::Helpers::InputSchema::JsonSchemaConverter
+              return type.to_json_schema_inner(state: state)
+            in Class
+              case type
+              in -> { _1 <= NilClass }
+                return {type: "null"}
+              in -> { _1 <= Integer }
+                return {type: "integer"}
+              in -> { _1 <= Float }
+                return {type: "number"}
+              in -> { _1 <= Symbol || _1 <= String }
+                return {type: "string"}
+              else
+              end
+            in _ if Anthropic::Internal::Util.primitive?(type)
+              return {const: type.is_a?(Symbol) ? type.to_s : type}
+            else
+            end
+
+            models = %w[
+              NilClass
+              String
+              Symbol
+              Integer
+              Float
+              Anthropic::Boolean
+              Anthropic::ArrayOf
+              Anthropic::EnumOf
+              Anthropic::UnionOf
+              Anthropic::BaseModel
+            ]
+            # rubocop:disable Layout/LineLength
+            message = "#{type} does not implement the #{Anthropic::Helpers::InputSchema::JsonSchemaConverter} interface. Please use one of the supported types: #{models}"
+            # rubocop:enable Layout/LineLength
+            raise ArgumentError.new(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/input_schema/parsed_json.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      # @abstract
+      #
+      # Like Anthropic::Internal::Type::Unknown, but for parsed JSON values, which can be incomplete or malformed.
+      class ParsedJson < Anthropic::Internal::Type::Unknown
+        class << self
+          # @api private
+          #
+          # No coercion needed for Unknown type.
+          #
+          # @param value [Object]
+          #
+          # @param state [Hash{Symbol=>Object}] .
+          #
+          #   @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(value, state:)
+            (state[:error] = value) if value.is_a?(StandardError)
+
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/input_schema/property_mapping.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      # rubocop:disable Style/MutableConstant
+      PROPERTY_MAPPING = {
+        # Numeric properties:
+        minimum: :minimum,
+        maximum: :maximum,
+        exclusive_minimum: :exclusiveMinimum,
+        exclusive_maximum: :exclusiveMaximum,
+        multiple_of: :multipleOf,
+
+        # String properties:
+        min_length: :minLength,
+        max_length: :maxLength,
+        pattern: :pattern,
+        format: :format,
+        content_media_type: :contentMediaType,
+        content_encoding: :contentEncoding,
+
+        # Array properties:
+        min_items: :minItems,
+        max_items: :maxItems,
+        unique_items: :uniqueItems,
+        prefix_items: :prefixItems,
+        contains: :contains,
+        min_contains: :minContains,
+        max_contains: :maxContains,
+
+        # Object properties:
+        pattern_properties: :patternProperties,
+        dependent_schemas: :dependentSchemas,
+        dependent_required: :dependentRequired,
+        property_names: :propertyNames,
+
+        # Metadata:
+        default: :default,
+        examples: :examples,
+
+        doc: :description
+      }
+      # rubocop:enable Style/MutableConstant
+    end
+  end
+end

data/lib/anthropic/helpers/input_schema/union_of.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      # @generic Member
+      #
+      # @example
+      #   example = Anthropic::UnionOf[Float, Anthropic::ArrayOf[Integer]]
+      class UnionOf
+        include Anthropic::Internal::Type::Union
+        include Anthropic::Helpers::InputSchema::JsonSchemaConverter
+
+        # @api private
+        #
+        # @param state [Hash{Symbol=>Object}]
+        #
+        #   @option state [Hash{Object=>String}] :defs
+        #
+        #   @option state [Array<String>] :path
+        #
+        # @return [Hash{Symbol=>Object}]
+        def to_json_schema_inner(state:)
+          Anthropic::Helpers::InputSchema::JsonSchemaConverter.cache_def!(state, type: self) do
+            path = state.fetch(:path)
+            mergeable_keys = {[:anyOf] => 0, [:type] => 0}
+            schemas = variants.to_enum.with_index.map do
+              new_state = {**state, path: [*path, "?.#{_2}"]}
+              Anthropic::Helpers::InputSchema::JsonSchemaConverter.to_json_schema_inner(
+                _1,
+                state: new_state
+              )
+            end
+
+            schemas.each do |schema|
+              mergeable_keys.each_key { mergeable_keys[_1] += 1 if schema.keys == _1 }
+            end
+            mergeable = mergeable_keys.any? { _1.last == schemas.length }
+            mergeable ? Anthropic::Internal::Util.deep_merge(*schemas, concat: true) : {anyOf: schemas}
+          end
+        end
+
+        private_class_method :new
+
+        def self.[](...) = new(...)
+
+        # @param variants [Array<generic<Member>>]
+        def initialize(*variants)
+          variants.each do |v|
+            v.is_a?(Proc) ? variant(v) : variant(-> { v })
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/input_schema.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    # Helpers for the structured output API.
+    #
+    # see https://platform.Anthropic.com/docs/guides/structured-outputs
+    # see https://json-schema.org
+    #
+    # Based on the DSL in {Anthropic::Internal::Type}, but currently only support the limited subset of JSON schema types used in structured output APIs.
+    #
+    # Supported types: {NilClass} {String} {Symbol} {Integer} {Float} {Anthropic::Boolean}, {Anthropic::EnumOf}, {Anthropic::UnionOf}, {Anthropic::ArrayOf}, {Anthropic::BaseModel}
+    module InputSchema
+    end
+  end
+end