anthropic 1.13.0 → 1.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 402cad94c15427670184c0922d15aa743631c9cf0178a2bd7d1a54fd515e138a
-  data.tar.gz: 89e7ff9f5a7072a3380a749286be91d0da71eb0067310ab558086496cd9264f3
+  metadata.gz: bd00e27834064b69a4c340776b3a6dcc50be9cde619c86fca93663c421cb7dff
+  data.tar.gz: 8a07090aaa4fc943673bba3a67411ef3d2dede001e8a597487c6be61b17a6d36
 SHA512:
-  metadata.gz: 9439dd79ab1f200590ea63e60e27f444a51566fb75988b8b6a32cde0d20d404dd7e85b5bd77d94c21ec0ff77684df53f59d610063bb834e222ec1d267490d0f1
-  data.tar.gz: 998aca515a29223d30c4bd7f3c240e99c476a354eb40a3b2131feb62404893e3428ecf47d72bb188ff847af5f56125b87ec27bce90b03f69fb2cc8dc5d6d0ac5
+  metadata.gz: f50ad464f5deeaf0be1635ca3fe270b82efd88332c145472ca653048b3e970925b531f9e652401d8f5cfe6e055083e540aadd2f3f6ae18b743acb2e58c0a513c
+  data.tar.gz: 0706ceb70895b9cfedf683a8edbc183a73b45234c62531c15a281860891de1ed2160245f104a3f4f752eb7d82235de0d6ade340bdf66e1a5de99801cf755a951

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 # Changelog
 
+## 1.14.0 (2025-11-07)
+
+Full Changelog: [v1.13.0...v1.14.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.13.0...v1.14.0)
+
+### Features
+
+* run-tools implementation ([#714](https://github.com/anthropics/anthropic-sdk-ruby/issues/714)) ([5cf7298](https://github.com/anthropics/anthropic-sdk-ruby/commit/5cf72982d25f97052cb87270293434e16a330818))
+
+
+### Bug Fixes
+
+* better thread safety via early initializing SSL store during HTTP client creation ([3a9531c](https://github.com/anthropics/anthropic-sdk-ruby/commit/3a9531c5b46da4d77647b14a3e8b20e3713c6da3))
+
+
+### Chores
+
+* **client:** send user-agent header ([57b22be](https://github.com/anthropics/anthropic-sdk-ruby/commit/57b22bebbc1b5c1bf676103c997e0aabdc065838))
+* **internal:** codegen related update ([15188e3](https://github.com/anthropics/anthropic-sdk-ruby/commit/15188e3963c05e4594d449a0ef871f9ae6b41ed3))
+
 ## 1.13.0 (2025-10-29)
 
 Full Changelog: [v1.12.0...v1.13.0](https://github.com/anthropics/anthropic-sdk-ruby/compare/v1.12.0...v1.13.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.13.0"
+gem "anthropic", "~> 1.14.0"
 ```
 
 <!-- x-release-please-end -->
@@ -79,6 +79,36 @@ end
 
 Streaming with `anthropic.messages.stream(...)` exposes [various helpers for your convenience](helpers.md) including accumulation & SDK-specific events.
 
+### Input Schema & Tool Calling
+
+We have helper mechanisms to define structured data classes for tools and let Claude automatically execute them.
+
+Please refer to [helpers.md](helpers.md) for more detailed usage information.
+
+```ruby
+class CalculatorInput < Anthropic::BaseModel
+  required :lhs, Float
+  required :rhs, Float
+  required :operator, Anthropic::InputSchema::EnumOf[:+, :-, :*, :/]
+end
+
+class Calculator < Anthropic::BaseTool
+  input_schema CalculatorInput
+
+  def call(expr)
+    expr.lhs.public_send(expr.operator, expr.rhs)
+  end
+end
+
+# Automatically handles tool execution loop
+client.beta.messages.tool_runner(
+  model: "claude-sonnet-4-5-20250929",
+  max_tokens: 1024,
+  messages: [{role: "user", content: "What's 15 * 7?"}],
+  tools: [Calculator.new]
+).each_message { puts _1.content }
+```
+
 ### Pagination
 
 List methods in the Anthropic API are paginated.

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

@@ -68,12 +68,15 @@ module Anthropic
             super(name_sym, type_info, spec)
           end
 
+          # @return [String]
           attr_reader :doc_string
 
+          # @api public
+          #
           # @param description [String]
-          def doc(description)
-            @doc_string = description
-          end
+          def description(description) = (@doc_string = description)
+
+          alias_method :doc, :description
 
           private def process_field_args(args)
             # Only accept hash format for descriptions.

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

@@ -51,7 +51,7 @@ module Anthropic
               {anyOf: [schema, {type: null}]}
             in {anyOf: schemas}
               null = {type: null}
-              schemas.any? { _1 == null || _1 == {type: ["null"]} } ? schema : {anyOf: [*schemas, 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}
@@ -63,7 +63,12 @@ module Anthropic
           #
           # @param schema [Hash{Symbol=>Object}]
           def assoc_meta!(schema, meta:)
-            xformed = meta.transform_keys(Anthropic::Helpers::InputSchema::PROPERTY_MAPPING)
+            xformed = meta.transform_keys(doc: :description) do
+              _1.to_s.gsub(/_\w/, &:upcase).tr("_", "").to_sym
+            end
+            if schema.key?(:$ref) && !xformed.empty?
+              schema.merge!(Anthropic::Helpers::InputSchema::JsonSchemaConverter::NO_REF => true)
+            end
             schema.merge!(xformed)
           end
 
@@ -138,7 +143,8 @@ module Anthropic
             end
 
             xformed = reused_defs.transform_keys { _1.delete_prefix("#/$defs/") }
-            xformed.empty? ? schema : {"$defs": xformed}.update(schema)
+            unconformed = xformed.empty? ? schema : {"$defs": xformed}.update(schema)
+            unconformed.tap { Anthropic::Helpers::InputSchema::SupportedSchemas.transform_schema!(_1) }
           end
 
           # @api private

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      module SupportedSchemas
+        class << self
+          # @api private
+          #
+          # @param x [Object]
+          #
+          # @yieldparam [Object]
+          private def walk_once(x, &blk)
+            seen = Set.new
+            rec = ->(x) do
+              return unless seen.add?(x)
+
+              blk.call(x)
+              case x
+              in Hash
+                x.each_value(&rec)
+              in Array
+                x.each(&rec)
+              else
+              end
+            end
+
+            rec.call(x)
+          end
+
+          # @api private
+          #
+          # @param schema [Hash{Symbol=>Object}]
+          #
+          # @return [String]
+          private def describe!(schema, unsupported:)
+            [:$defs, :default].each { unsupported.delete(_1) }
+
+            doc = unsupported.delete(:description)
+            return if unsupported.empty?
+
+            addendum = unsupported.map { "#{_1}=#{_2.to_json}" }.join(",")
+            unsupported.each_key { schema.delete(_1) }
+
+            schema[:description] =
+              [
+                doc,
+                "Please also conform to these set of constraints: #{addendum}"
+              ].compact.join("\n")
+          end
+
+          # @api private
+          #
+          # @param schema [Hash{Symbol=>Object}]
+          #
+          # @return [Hash{Symbol=>Object}]
+          def transform_schema!(schema)
+            defs = schema[:$defs].to_h
+
+            # rubocop:disable Metrics/BlockLength
+            xform = ->(s) do
+              case s
+              in {type: "string" | ["string", "null"], format: "date-time" | "time" | "date" | "duration" | "email" | "hostname" | "uri" | "ipv4" | "ipv6" | "uuid"} | {type: "array", minItems: 0 | 1}
+                # these are the currently supported cases
+                next
+
+              in {oneOf: Array => schemas, **rest}
+                {anyOf: schemas, **rest}
+
+              in {allOf: Array => schemas}
+                derefed = schemas.lazy.grep(Hash).map do
+                  ref = _1[:$ref].to_s.delete_prefix("#/$defs/")
+                  defs.fetch(ref, _1)
+                end
+                merged = {}.merge!(*derefed)
+                if (doc = xform.call(merged))
+                  merged.store(:$ref, true)
+
+                  schemas.reject! do |s|
+                    next unless s.is_a?(Hash)
+                    s.delete(:description)
+                    s.select! { merged.key?(_1) }
+                    s.empty?
+                  end
+                  schemas << {description: doc}
+                end
+              in {type: "integer" | "number" | "string" | ["integer", "null"] | ["number", "null"] | ["string", "null"], **unsupported}
+                describe!(s, unsupported: unsupported.except(:enum))
+              in {type: "array",  **unsupported}
+                describe!(s, unsupported: unsupported.except(:items))
+              in {type: "object", **unsupported}
+                unsupported.delete(:additionalProperties) if unsupported[:additionalProperties] == false
+                describe!(s, unsupported: unsupported.except(:required, :properties))
+              else
+              end
+            end
+            # rubocop:enable Metrics/BlockLength
+
+            walk_once(schema, &xform)
+            schema
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -33,7 +33,9 @@ module Anthropic
             end
 
             schemas.each do |schema|
-              mergeable_keys.each_key { mergeable_keys[_1] += 1 if schema.keys == _1 }
+              mergeable_keys.each_key do
+                mergeable_keys[_1] += 1 if schema.keys == _1 && schema[_1].is_a?(Array)
+              end
             end
             mergeable = mergeable_keys.any? { _1.last == schemas.length }
             mergeable ? Anthropic::Internal::Util.deep_merge(*schemas, concat: true) : {anyOf: schemas}

data/lib/anthropic/helpers/messages.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Anthropic
+  module Helpers
+    module Messages
+      class << self
+        # @api private
+        #
+        # Extract tool models from the request and convert them to JSON Schema
+        # Returns a hash mapping tool name to Ruby model.
+        #
+        # @param data [Hash{Sybmol=>Object}]
+        #
+        # @param strict [Boolean, nil]
+        #
+        # @return [Hash{String=>Class}, Hash{String=>Class}]
+        def distill_input_schema_models!(data, strict:)
+          tools = {}
+          models = {}
+
+          case data
+          in {tools: Array => tool_array}
+            # rubocop:disable Metrics/BlockLength
+            mapped = tool_array.map do |tool|
+              case tool
+              # Direct tool class:
+              in Anthropic::Helpers::InputSchema::JsonSchemaConverter
+                classname = tool.is_a?(Anthropic::Helpers::Tools::BaseTool) ? tool.class.name : tool.name
+                name = classname
+                       .split("::")
+                       .last
+                       .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                       .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                       .downcase
+                description =
+                  case tool
+                  in Anthropic::Helpers::Tools::BaseTool
+                    tool.class.doc_string || name
+                  in Class if tool <= Anthropic::Helpers::InputSchema::BaseModel
+                    tool.doc_string || name
+                  else
+                    name
+                  end
+
+                tools.store(name, tool)
+                input_schema = Anthropic::Helpers::InputSchema::JsonSchemaConverter.to_json_schema(tool)
+                {name:, description:, input_schema:}.tap { _1.update(strict:) if strict }
+              # Tool with explicit name/description and BaseModel as input_schema:
+              in {name: String => name,
+                  input_schema: Anthropic::Helpers::InputSchema::JsonSchemaConverter => tool,
+                  **rest}
+                tools.store(name, tool)
+                input_schema = Anthropic::Helpers::InputSchema::JsonSchemaConverter.to_json_schema(tool)
+                rest.merge(name:, input_schema:).tap { _1.update(strict:) if strict }
+              else
+                # Any other format (pass through unchanged)
+                # This includes raw JSON schemas and any other tool definitions.
+                tool
+              end
+            end
+            tool_array.replace(mapped)
+          else
+          end
+          # rubocop:enable Metrics/BlockLength
+
+          [tools, models]
+        end
+
+        # @api private
+        #
+        # @param raw [Hash{Sybmol=>Object}]
+        #
+        # @param tools [Hash{String=>Class}]
+        #
+        # @param models [Hash{String=>Class}]
+        #
+        # @return [Hash{Sybmol=>Object}]
+        def parse_input_schemas!(raw, tools:, models:)
+          raw[:content]&.each do |content|
+            case content
+            in {type: "tool_use", name:, input:} if (tool = tools[name])
+              begin
+                coerced = Anthropic::Internal::Type::Converter.coerce(tool, input)
+
+                content.store(:parsed, coerced)
+              rescue StandardError => e
+                content.store(:parsed, {error: e.message})
+              end
+            in {type: "text", text:} if (model = models.first&.last)
+              begin
+                json = JSON.parse(text, symbolize_names: true)
+                coerced = Anthropic::Internal::Type::Converter.coerce(model, json)
+
+                content.store(:parsed, coerced)
+              rescue StandardError => e
+                content.store(:parsed, {error: e.message})
+              end
+            else
+            end
+          end
+
+          raw
+        end
+      end
+    end
+  end
+end

data/lib/anthropic/helpers/streaming/message_stream.rb

@@ -60,10 +60,10 @@ module Anthropic
         #
         # Returns the complete accumulated Message object after stream completion.
         #
-        # @return [Anthropic::Models::Message]
+        # @return [Anthropic::Models::Message, Anthropic::Models::Beta::BetaMessage]
         def accumulated_message
           until_done
-          parse_tool_uses!(@accumated_message_snapshot) if @tool_models.any?
+          parse_tool_uses!(@accumated_message_snapshot)
           @accumated_message_snapshot
         end
 
@@ -76,18 +76,7 @@ module Anthropic
         # @return [String]
         def accumulated_text
           message = accumulated_message
-          text_blocks = []
-          message.content.each do |block|
-            if block.type == :text
-              text_blocks << block.text
-            end
-          end
-
-          if text_blocks.empty?
-            raise RuntimeError.new("Expected to have received at least 1 text block")
-          end
-
-          text_blocks.join
+          message.content.map { _1.type == :text ? _1.text : nil }.join
         end
 
         # @api private
@@ -99,7 +88,10 @@ module Anthropic
         #
         # @return [Anthropic::Models::Message] updated message snapshot with event applied
         private def accumulate_event(event:, current_snapshot:)
-          unless event in Anthropic::Models::RawMessageStreamEvent
+          case event
+          in Anthropic::Models::RawMessageStreamEvent | Anthropic::Models::BetaRawMessageStreamEvent
+            nil
+          else
             message = "Expected event to be a variant of RawMessageStreamEvent, got #{event.class}"
             raise ArgumentError.new(message)
           end
@@ -112,36 +104,37 @@ module Anthropic
           end
 
           case event
-          in Anthropic::Models::RawMessageStartEvent
-            # Use the converter to create a new, isolated copy of the message object.
+          in Anthropic::Models::RawMessageStartEvent # Use the converter to create a new, isolated copy of the message object.
             # This ensures proper type validation and prevents shared object references
             # that could lead to unintended mutations during streaming accumulation.
             # Matches the Python SDK's approach of explicitly constructing Message objects.
             return Anthropic::Internal::Type::Converter.coerce(Anthropic::Models::Message, event.message)
-          in Anthropic::Models::RawContentBlockStartEvent
+          in Anthropic::Models::BetaRawMessageStartEvent
+            return Anthropic::Internal::Type::Converter.coerce(Anthropic::Models::BetaMessage, event.message)
+          in Anthropic::Models::RawContentBlockStartEvent | Anthropic::Models::BetaRawContentBlockStartEvent
             current_snapshot.content = (current_snapshot.content || []) + [event.content_block]
-          in Anthropic::Models::RawContentBlockDeltaEvent
+          in Anthropic::Models::RawContentBlockDeltaEvent | Anthropic::Models::BetaRawContentBlockDeltaEvent
             content = current_snapshot.content[event.index]
 
             case (delta = event.delta)
-            in Anthropic::Models::TextDelta if content.type == :text
+            in Anthropic::Models::TextDelta | Anthropic::Models::BetaTextDelta if content.type == :text
               content.text += delta.text
-            in Anthropic::Models::InputJSONDelta if content.type == :tool_use
-              json_buf = content.json_buf.to_s
+            in Anthropic::Models::InputJSONDelta | Anthropic::Models::BetaInputJSONDelta if content.type == :tool_use
+              json_buf = content._json_buf.to_s
               json_buf += delta.partial_json
 
               content.input = json_buf
-              content.json_buf = json_buf
-            in Anthropic::Models::CitationsDelta if content.type == :text
+              content._json_buf = json_buf
+            in Anthropic::Models::CitationsDelta | Anthropic::Models::BetaCitationsDelta if content.type == :text
               content.citations ||= []
               content.citations << delta.citation
-            in Anthropic::Models::ThinkingDelta if content.type == :thinking
+            in Anthropic::Models::ThinkingDelta | Anthropic::Models::BetaThinkingDelta if content.type == :thinking
               content.thinking += delta.thinking
-            in Anthropic::Models::SignatureDelta if content.type == :thinking
+            in Anthropic::Models::SignatureDelta | Anthropic::Models::BetaSignatureDelta if content.type == :thinking
               content.signature = delta.signature
             else
             end
-          in Anthropic::Models::RawMessageDeltaEvent
+          in Anthropic::Models::RawMessageDeltaEvent | Anthropic::Models::BetaRawMessageDeltaEvent
             current_snapshot.stop_reason = event.delta.stop_reason
             current_snapshot.stop_sequence = event.delta.stop_sequence
             current_snapshot.usage.output_tokens = event.usage.output_tokens
@@ -166,51 +159,51 @@ module Anthropic
           events_to_yield = []
 
           case event
-          in Anthropic::Models::RawMessageStopEvent
+          in Anthropic::Models::RawMessageStopEvent | Anthropic::Models::BetaRawMessageStopEvent
             events_to_yield << MessageStopEvent.new(
               type: :message_stop,
               message: message_snapshot
             )
-          in Anthropic::Models::RawContentBlockDeltaEvent
+          in Anthropic::Models::RawContentBlockDeltaEvent | Anthropic::Models::BetaRawContentBlockDeltaEvent
             events_to_yield << event
             content_block = message_snapshot.content[event.index]
 
             case (delta = event.delta)
-            in Anthropic::Models::TextDelta if content_block.type == :text
+            in Anthropic::Models::TextDelta | Anthropic::Models::BetaTextDelta if content_block.type == :text
               events_to_yield << Anthropic::Streaming::TextEvent.new(
                 type: :text,
                 text: delta.text,
                 snapshot: content_block.text
               )
-            in Anthropic::Models::InputJSONDelta if content_block.type == :tool_use
+            in Anthropic::Models::InputJSONDelta | Anthropic::Models::BetaInputJSONDelta if content_block.type == :tool_use
               events_to_yield << Anthropic::Streaming::InputJsonEvent.new(
                 type: :input_json,
                 partial_json: delta.partial_json,
                 snapshot: content_block.input
               )
-            in Anthropic::Models::CitationsDelta if content_block.type == :text
+            in Anthropic::Models::CitationsDelta | Anthropic::Models::BetaCitationsDelta if content_block.type == :text
               events_to_yield << Anthropic::Streaming::CitationEvent.new(
                 type: :citation,
                 citation: delta.citation,
                 snapshot: content_block.citations || []
               )
-            in Anthropic::Models::ThinkingDelta if content_block.type == :thinking
+            in Anthropic::Models::ThinkingDelta | Anthropic::Models::BetaThinkingDelta if content_block.type == :thinking
               events_to_yield << Anthropic::Streaming::ThinkingEvent.new(
                 type: :thinking,
                 thinking: delta.thinking,
                 snapshot: content_block.thinking
               )
-            in Anthropic::Models::SignatureDelta if content_block.type == :thinking
+            in Anthropic::Models::SignatureDelta | Anthropic::Models::BetaSignatureDelta if content_block.type == :thinking
               events_to_yield << Anthropic::Streaming::SignatureEvent.new(
                 type: :signature,
                 signature: content_block.signature
               )
             else
             end
-          in Anthropic::Models::RawContentBlockStopEvent
+          in Anthropic::Models::RawContentBlockStopEvent | Anthropic::Models::BetaRawContentBlockStopEvent
             content_block = message_snapshot.content[event.index]
 
-            events_to_yield << ContentBlockStopEvent.new(
+            events_to_yield << Anthropic::Streaming::ContentBlockStopEvent.new(
               type: :content_block_stop,
               index: event.index,
               content_block: content_block
@@ -232,21 +225,33 @@ module Anthropic
         private def parse_tool_uses!(message)
           return message unless message&.content
 
+          # rubocop:disable Metrics/BlockLength
           message.content.each_with_index do |content, index|
             next unless content.type == :tool_use
 
-            next unless (model = @tool_models[content.name])
+            next unless (tool = @tools[content.name])
 
             parsed =
               begin
-                parsed_input = content.input.is_a?(String) ? JSON.parse(content.input) : content.input
+                parsed_input = if content.input.is_a?(String)
+                  JSON.parse(content.input, symbolize_names: true)
+                else
+                  content.input
+                end
 
-                Anthropic::Internal::Type::Converter.coerce(model, parsed_input)
+                Anthropic::Internal::Type::Converter.coerce(tool, parsed_input)
               rescue StandardError => e
                 e
               end
 
-            message.content[index] = Anthropic::Models::ToolUseBlock.new(
+            cls =
+              case content
+              in Anthropic::ContentBlock
+                Anthropic::Models::ToolUseBlock
+              else
+                Anthropic::Models::BetaToolUseBlock
+              end
+            message.content[index] = cls.new(
               id: content.id,
               input: content.input,
               name: content.name,
@@ -254,6 +259,7 @@ module Anthropic
               parsed: parsed
             )
           end
+          # rubocop:enable Metrics/BlockLength
 
           message
         end
@@ -261,14 +267,19 @@ module Anthropic
         # @api private
         #
         # @param raw_stream [Anthropic::Internal::Type::BaseStream]
-        # @param tool_models [Hash{String=>Class}] Mapping of tool names to model classes
-        def initialize(raw_stream:, tool_models: {})
+        #
+        # @param tools [Hash{String=>Class}] Mapping of tool names to model classes
+        #
+        # @param models [Hash{String=>Class}] Mapping of tool names to model classes
+        def initialize(raw_stream:, tools: {}, models: {})
           # The underlying Server-Sent Event stream from the Anthropic API.
           @raw_stream = raw_stream
           # Accumulated message state that builds up as events are processed.
           @accumated_message_snapshot = nil
           # Mapping of tool names to model classes for parsing.
-          @tool_models = tool_models
+          @tools = tools
+          # Mapping of tool names to model classes for parsing.
+          @models = models
           # Lazy enumerable that transforms raw events into consumable events.
           @iterator = iterator
           @status = raw_stream.status

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