anthropic 1.6.0 → 1.8.0

data/lib/anthropic.rb

@@ -67,6 +67,14 @@ require_relative "anthropic/models/base64_pdf_source"
 require_relative "anthropic/models/beta/beta_base64_image_source"
 require_relative "anthropic/models/beta/beta_base64_pdf_block"
 require_relative "anthropic/models/beta/beta_base64_pdf_source"
+require_relative "anthropic/models/beta/beta_bash_code_execution_output_block"
+require_relative "anthropic/models/beta/beta_bash_code_execution_output_block_param"
+require_relative "anthropic/models/beta/beta_bash_code_execution_result_block"
+require_relative "anthropic/models/beta/beta_bash_code_execution_result_block_param"
+require_relative "anthropic/models/beta/beta_bash_code_execution_tool_result_block"
+require_relative "anthropic/models/beta/beta_bash_code_execution_tool_result_block_param"
+require_relative "anthropic/models/beta/beta_bash_code_execution_tool_result_error"
+require_relative "anthropic/models/beta/beta_bash_code_execution_tool_result_error_param"
 require_relative "anthropic/models/beta/beta_cache_control_ephemeral"
 require_relative "anthropic/models/beta/beta_cache_creation"
 require_relative "anthropic/models/beta/beta_citation_char_location"
@@ -86,6 +94,7 @@ require_relative "anthropic/models/beta/beta_code_execution_output_block_param"
 require_relative "anthropic/models/beta/beta_code_execution_result_block"
 require_relative "anthropic/models/beta/beta_code_execution_result_block_param"
 require_relative "anthropic/models/beta/beta_code_execution_tool_20250522"
+require_relative "anthropic/models/beta/beta_code_execution_tool_20250825"
 require_relative "anthropic/models/beta/beta_code_execution_tool_result_block"
 require_relative "anthropic/models/beta/beta_code_execution_tool_result_block_content"
 require_relative "anthropic/models/beta/beta_code_execution_tool_result_block_param"
@@ -138,6 +147,16 @@ require_relative "anthropic/models/beta/beta_text_block_param"
 require_relative "anthropic/models/beta/beta_text_citation"
 require_relative "anthropic/models/beta/beta_text_citation_param"
 require_relative "anthropic/models/beta/beta_text_delta"
+require_relative "anthropic/models/beta/beta_text_editor_code_execution_create_result_block"
+require_relative "anthropic/models/beta/beta_text_editor_code_execution_create_result_block_param"
+require_relative "anthropic/models/beta/beta_text_editor_code_execution_str_replace_result_block"
+require_relative "anthropic/models/beta/beta_text_editor_code_execution_str_replace_result_block_param"
+require_relative "anthropic/models/beta/beta_text_editor_code_execution_tool_result_block"
+require_relative "anthropic/models/beta/beta_text_editor_code_execution_tool_result_block_param"
+require_relative "anthropic/models/beta/beta_text_editor_code_execution_tool_result_error"
+require_relative "anthropic/models/beta/beta_text_editor_code_execution_tool_result_error_param"
+require_relative "anthropic/models/beta/beta_text_editor_code_execution_view_result_block"
+require_relative "anthropic/models/beta/beta_text_editor_code_execution_view_result_block_param"
 require_relative "anthropic/models/beta/beta_thinking_block"
 require_relative "anthropic/models/beta/beta_thinking_block_param"
 require_relative "anthropic/models/beta/beta_thinking_config_disabled"
@@ -214,6 +233,7 @@ require_relative "anthropic/models/beta_permission_error"
 require_relative "anthropic/models/beta_rate_limit_error"
 require_relative "anthropic/models/billing_error"
 require_relative "anthropic/models/cache_control_ephemeral"
+require_relative "anthropic/models/cache_creation"
 require_relative "anthropic/models/citation_char_location"
 require_relative "anthropic/models/citation_char_location_param"
 require_relative "anthropic/models/citation_content_block_location"
@@ -338,3 +358,13 @@ require_relative "anthropic/resources/completions"
 require_relative "anthropic/resources/messages"
 require_relative "anthropic/resources/messages/batches"
 require_relative "anthropic/resources/models"
+require_relative "anthropic/helpers/input_schema"
+require_relative "anthropic/helpers/input_schema/property_mapping"
+require_relative "anthropic/helpers/input_schema/json_schema_converter"
+require_relative "anthropic/helpers/input_schema/base_model"
+require_relative "anthropic/helpers/input_schema/array_of"
+require_relative "anthropic/helpers/input_schema/boolean"
+require_relative "anthropic/helpers/input_schema/enum_of"
+require_relative "anthropic/helpers/input_schema/union_of"
+require_relative "anthropic/helpers/input_schema/parsed_json"
+require_relative "anthropic/input_schema"

data/rbi/anthropic/errors.rbi

@@ -59,10 +59,10 @@ module Anthropic
     end
 
     class APIConnectionError < Anthropic::Errors::APIError
-      sig { void }
+      sig { returns(NilClass) }
       attr_accessor :status
 
-      sig { void }
+      sig { returns(NilClass) }
       attr_accessor :body
 
       # @api private

data/rbi/anthropic/helpers/input_schema/array_of.rbi

@@ -0,0 +1,16 @@
+# typed: strong
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      class ArrayOf < Anthropic::Internal::Type::ArrayOf
+        include Anthropic::Helpers::InputSchema::JsonSchemaConverter
+
+        Elem = type_member(:out)
+
+        sig { returns(String) }
+        attr_reader :description
+      end
+    end
+  end
+end

data/rbi/anthropic/helpers/input_schema/base_model.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+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 `response_format` parameter set to use structured output (e.g., JSON).
+      #
+      # See {examples/input_schemas.rb} for a complete example of use
+      class BaseModel < Anthropic::Internal::Type::BaseModel
+        extend Anthropic::Helpers::InputSchema::JsonSchemaConverter
+
+        class << self
+          sig { params(doc: T.nilable(String)).void }
+          attr_writer :doc
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/helpers/input_schema/boolean.rbi

@@ -0,0 +1,11 @@
+# typed: strong
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      class Boolean < Anthropic::Internal::Type::Boolean
+        extend Anthropic::Helpers::InputSchema::JsonSchemaConverter
+      end
+    end
+  end
+end

data/rbi/anthropic/helpers/input_schema/enum_of.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      # @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
+
+        sig do
+          params(
+            values: T.any(NilClass, T::Boolean, Integer, Float, Symbol)
+          ).returns(T.attached_class)
+        end
+        def self.[](*values)
+        end
+
+        sig do
+          returns(T::Array[T.any(NilClass, T::Boolean, Integer, Float, Symbol)])
+        end
+        attr_reader :values
+      end
+    end
+  end
+end

data/rbi/anthropic/helpers/input_schema/json_schema_converter.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      JsonSchema = T.type_alias { Anthropic::Internal::AnyHash }
+
+      # To customize the JSON schema conversion for a type, implement the `JsonSchemaConverter` interface.
+      module JsonSchemaConverter
+        POINTER = T.let(Object.new.freeze, T.anything)
+        COUNTER = T.let(Object.new.freeze, T.anything)
+
+        Input =
+          T.type_alias do
+            T.any(
+              Anthropic::Helpers::InputSchema::JsonSchemaConverter,
+              T::Class[T.anything]
+            )
+          end
+        State =
+          T.type_alias do
+            { defs: T::Hash[Object, String], path: T::Array[String] }
+          end
+
+        # The exact JSON schema produced is subject to improvement between minor release versions.
+        sig do
+          params(
+            state: Anthropic::Helpers::InputSchema::JsonSchemaConverter::State
+          ).returns(Anthropic::Helpers::InputSchema::JsonSchema)
+        end
+        def to_json_schema_inner(state:)
+        end
+
+        # Internal helpers methods.
+        class << self
+          # @api private
+          sig do
+            params(schema: Anthropic::Helpers::InputSchema::JsonSchema).returns(
+              Anthropic::Helpers::InputSchema::JsonSchema
+            )
+          end
+          def to_nilable(schema)
+          end
+
+          # @api private
+          sig do
+            params(
+              schema: Anthropic::Helpers::InputSchema::JsonSchema,
+              meta: Anthropic::Internal::AnyHash
+            ).void
+          end
+          def assoc_meta!(schema, meta:)
+          end
+
+          # @api private
+          sig do
+            params(
+              state:
+                Anthropic::Helpers::InputSchema::JsonSchemaConverter::State,
+              type: Anthropic::Helpers::InputSchema::JsonSchemaConverter::Input,
+              blk: T.proc.returns(Anthropic::Helpers::InputSchema::JsonSchema)
+            ).void
+          end
+          def cache_def!(state, type:, &blk)
+          end
+
+          # @api private
+          sig do
+            params(
+              type: Anthropic::Helpers::InputSchema::JsonSchemaConverter::Input
+            ).returns(Anthropic::Helpers::InputSchema::JsonSchema)
+          end
+          def to_json_schema(type)
+          end
+
+          # @api private
+          sig do
+            params(
+              type: Anthropic::Helpers::InputSchema::JsonSchemaConverter::Input,
+              state: Anthropic::Helpers::InputSchema::JsonSchemaConverter::State
+            ).returns(Anthropic::Helpers::InputSchema::JsonSchema)
+          end
+          def to_json_schema_inner(type, state:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/helpers/input_schema/union_of.rbi

@@ -0,0 +1,23 @@
+# typed: strong
+
+module Anthropic
+  module Helpers
+    module InputSchema
+      # @example
+      #   example = Anthropic::UnionOf[Float, Anthropic::ArrayOf[Integer]]
+      class UnionOf
+        include Anthropic::Internal::Type::Union
+        include Anthropic::Helpers::InputSchema::JsonSchemaConverter
+
+        sig do
+          params(
+            variants:
+              Anthropic::Helpers::InputSchema::JsonSchemaConverter::Input
+          ).returns(T.attached_class)
+        end
+        def self.[](*variants)
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/helpers/structured_output.rbi

@@ -0,0 +1,16 @@
+# typed: strong
+
+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

data/rbi/anthropic/input_schema.rbi

@@ -0,0 +1,12 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Anthropic
+  # Convenience aliases for input schema classes
+  InputSchema = Anthropic::Helpers::InputSchema
+  ArrayOf = Anthropic::Helpers::InputSchema::ArrayOf
+  BaseModel = Anthropic::Helpers::InputSchema::BaseModel
+  Boolean = Anthropic::Helpers::InputSchema::Boolean
+  EnumOf = Anthropic::Helpers::InputSchema::EnumOf
+  UnionOf = Anthropic::Helpers::InputSchema::UnionOf
+end

data/rbi/anthropic/models/beta/beta_bash_code_execution_output_block.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaBashCodeExecutionOutputBlock = Beta::BetaBashCodeExecutionOutputBlock
+
+    module Beta
+      class BetaBashCodeExecutionOutputBlock < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaBashCodeExecutionOutputBlock,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :file_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig { params(file_id: String, type: Symbol).returns(T.attached_class) }
+        def self.new(file_id:, type: :bash_code_execution_output)
+        end
+
+        sig { override.returns({ file_id: String, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_bash_code_execution_output_block_param.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaBashCodeExecutionOutputBlockParam =
+      Beta::BetaBashCodeExecutionOutputBlockParam
+
+    module Beta
+      class BetaBashCodeExecutionOutputBlockParam < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaBashCodeExecutionOutputBlockParam,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :file_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig { params(file_id: String, type: Symbol).returns(T.attached_class) }
+        def self.new(file_id:, type: :bash_code_execution_output)
+        end
+
+        sig { override.returns({ file_id: String, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_bash_code_execution_result_block.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaBashCodeExecutionResultBlock = Beta::BetaBashCodeExecutionResultBlock
+
+    module Beta
+      class BetaBashCodeExecutionResultBlock < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaBashCodeExecutionResultBlock,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(T::Array[Anthropic::Beta::BetaBashCodeExecutionOutputBlock])
+        end
+        attr_accessor :content
+
+        sig { returns(Integer) }
+        attr_accessor :return_code
+
+        sig { returns(String) }
+        attr_accessor :stderr
+
+        sig { returns(String) }
+        attr_accessor :stdout
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            content:
+              T::Array[
+                Anthropic::Beta::BetaBashCodeExecutionOutputBlock::OrHash
+              ],
+            return_code: Integer,
+            stderr: String,
+            stdout: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          content:,
+          return_code:,
+          stderr:,
+          stdout:,
+          type: :bash_code_execution_result
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              content:
+                T::Array[Anthropic::Beta::BetaBashCodeExecutionOutputBlock],
+              return_code: Integer,
+              stderr: String,
+              stdout: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_bash_code_execution_result_block_param.rbi

@@ -0,0 +1,77 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaBashCodeExecutionResultBlockParam =
+      Beta::BetaBashCodeExecutionResultBlockParam
+
+    module Beta
+      class BetaBashCodeExecutionResultBlockParam < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaBashCodeExecutionResultBlockParam,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T::Array[Anthropic::Beta::BetaBashCodeExecutionOutputBlockParam]
+          )
+        end
+        attr_accessor :content
+
+        sig { returns(Integer) }
+        attr_accessor :return_code
+
+        sig { returns(String) }
+        attr_accessor :stderr
+
+        sig { returns(String) }
+        attr_accessor :stdout
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            content:
+              T::Array[
+                Anthropic::Beta::BetaBashCodeExecutionOutputBlockParam::OrHash
+              ],
+            return_code: Integer,
+            stderr: String,
+            stdout: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          content:,
+          return_code:,
+          stderr:,
+          stdout:,
+          type: :bash_code_execution_result
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              content:
+                T::Array[
+                  Anthropic::Beta::BetaBashCodeExecutionOutputBlockParam
+                ],
+              return_code: Integer,
+              stderr: String,
+              stdout: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_bash_code_execution_tool_result_block.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaBashCodeExecutionToolResultBlock =
+      Beta::BetaBashCodeExecutionToolResultBlock
+
+    module Beta
+      class BetaBashCodeExecutionToolResultBlock < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaBashCodeExecutionToolResultBlock,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            Anthropic::Beta::BetaBashCodeExecutionToolResultBlock::Content::Variants
+          )
+        end
+        attr_accessor :content
+
+        sig { returns(String) }
+        attr_accessor :tool_use_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            content:
+              T.any(
+                Anthropic::Beta::BetaBashCodeExecutionToolResultError::OrHash,
+                Anthropic::Beta::BetaBashCodeExecutionResultBlock::OrHash
+              ),
+            tool_use_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          content:,
+          tool_use_id:,
+          type: :bash_code_execution_tool_result
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              content:
+                Anthropic::Beta::BetaBashCodeExecutionToolResultBlock::Content::Variants,
+              tool_use_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Content
+          extend Anthropic::Internal::Type::Union
+
+          Variants =
+            T.type_alias do
+              T.any(
+                Anthropic::Beta::BetaBashCodeExecutionToolResultError,
+                Anthropic::Beta::BetaBashCodeExecutionResultBlock
+              )
+            end
+
+          sig do
+            override.returns(
+              T::Array[
+                Anthropic::Beta::BetaBashCodeExecutionToolResultBlock::Content::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+        end
+      end
+    end
+  end
+end