anthropic 1.0.0 → 1.1.0

data/rbi/anthropic/models/beta/beta_code_execution_result_block_param.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaCodeExecutionResultBlockParam = Beta::BetaCodeExecutionResultBlockParam
+
+    module Beta
+      class BetaCodeExecutionResultBlockParam < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaCodeExecutionResultBlockParam,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(T::Array[Anthropic::Beta::BetaCodeExecutionOutputBlockParam])
+        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::BetaCodeExecutionOutputBlockParam::OrHash
+              ],
+            return_code: Integer,
+            stderr: String,
+            stdout: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          content:,
+          return_code:,
+          stderr:,
+          stdout:,
+          type: :code_execution_result
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              content:
+                T::Array[Anthropic::Beta::BetaCodeExecutionOutputBlockParam],
+              return_code: Integer,
+              stderr: String,
+              stdout: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_code_execution_tool_20250522.rbi

@@ -0,0 +1,72 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaCodeExecutionTool20250522 = Beta::BetaCodeExecutionTool20250522
+
+    module Beta
+      class BetaCodeExecutionTool20250522 < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaCodeExecutionTool20250522,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        # Name of the tool.
+        #
+        # This is how the tool will be called by the model and in `tool_use` blocks.
+        sig { returns(Symbol) }
+        attr_accessor :name
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Create a cache control breakpoint at this content block.
+        sig { returns(T.nilable(Anthropic::Beta::BetaCacheControlEphemeral)) }
+        attr_reader :cache_control
+
+        sig do
+          params(
+            cache_control:
+              T.nilable(Anthropic::Beta::BetaCacheControlEphemeral::OrHash)
+          ).void
+        end
+        attr_writer :cache_control
+
+        sig do
+          params(
+            cache_control:
+              T.nilable(Anthropic::Beta::BetaCacheControlEphemeral::OrHash),
+            name: Symbol,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Create a cache control breakpoint at this content block.
+          cache_control: nil,
+          # Name of the tool.
+          #
+          # This is how the tool will be called by the model and in `tool_use` blocks.
+          name: :code_execution,
+          type: :code_execution_20250522
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              name: Symbol,
+              type: Symbol,
+              cache_control:
+                T.nilable(Anthropic::Beta::BetaCacheControlEphemeral)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_code_execution_tool_result_block.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaCodeExecutionToolResultBlock = Beta::BetaCodeExecutionToolResultBlock
+
+    module Beta
+      class BetaCodeExecutionToolResultBlock < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaCodeExecutionToolResultBlock,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            Anthropic::Beta::BetaCodeExecutionToolResultBlockContent::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::BetaCodeExecutionToolResultError::OrHash,
+                Anthropic::Beta::BetaCodeExecutionResultBlock::OrHash
+              ),
+            tool_use_id: String,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(content:, tool_use_id:, type: :code_execution_tool_result)
+        end
+
+        sig do
+          override.returns(
+            {
+              content:
+                Anthropic::Beta::BetaCodeExecutionToolResultBlockContent::Variants,
+              tool_use_id: String,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_code_execution_tool_result_block_content.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaCodeExecutionToolResultBlockContent =
+      Beta::BetaCodeExecutionToolResultBlockContent
+
+    module Beta
+      module BetaCodeExecutionToolResultBlockContent
+        extend Anthropic::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaCodeExecutionToolResultError,
+              Anthropic::Beta::BetaCodeExecutionResultBlock
+            )
+          end
+
+        sig do
+          override.returns(
+            T::Array[
+              Anthropic::Beta::BetaCodeExecutionToolResultBlockContent::Variants
+            ]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_code_execution_tool_result_block_param.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaCodeExecutionToolResultBlockParam =
+      Beta::BetaCodeExecutionToolResultBlockParam
+
+    module Beta
+      class BetaCodeExecutionToolResultBlockParam < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaCodeExecutionToolResultBlockParam,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T.any(
+              Anthropic::Beta::BetaCodeExecutionToolResultErrorParam,
+              Anthropic::Beta::BetaCodeExecutionResultBlockParam
+            )
+          )
+        end
+        attr_accessor :content
+
+        sig { returns(String) }
+        attr_accessor :tool_use_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Create a cache control breakpoint at this content block.
+        sig { returns(T.nilable(Anthropic::Beta::BetaCacheControlEphemeral)) }
+        attr_reader :cache_control
+
+        sig do
+          params(
+            cache_control:
+              T.nilable(Anthropic::Beta::BetaCacheControlEphemeral::OrHash)
+          ).void
+        end
+        attr_writer :cache_control
+
+        sig do
+          params(
+            content:
+              T.any(
+                Anthropic::Beta::BetaCodeExecutionToolResultErrorParam::OrHash,
+                Anthropic::Beta::BetaCodeExecutionResultBlockParam::OrHash
+              ),
+            tool_use_id: String,
+            cache_control:
+              T.nilable(Anthropic::Beta::BetaCacheControlEphemeral::OrHash),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          content:,
+          tool_use_id:,
+          # Create a cache control breakpoint at this content block.
+          cache_control: nil,
+          type: :code_execution_tool_result
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              content:
+                T.any(
+                  Anthropic::Beta::BetaCodeExecutionToolResultErrorParam,
+                  Anthropic::Beta::BetaCodeExecutionResultBlockParam
+                ),
+              tool_use_id: String,
+              type: Symbol,
+              cache_control:
+                T.nilable(Anthropic::Beta::BetaCacheControlEphemeral)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_code_execution_tool_result_block_param_content.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaCodeExecutionToolResultBlockParamContent =
+      Beta::BetaCodeExecutionToolResultBlockParamContent
+
+    module Beta
+      module BetaCodeExecutionToolResultBlockParamContent
+        extend Anthropic::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaCodeExecutionToolResultErrorParam,
+              Anthropic::Beta::BetaCodeExecutionResultBlockParam
+            )
+          end
+
+        sig do
+          override.returns(
+            T::Array[
+              Anthropic::Beta::BetaCodeExecutionToolResultBlockParamContent::Variants
+            ]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_code_execution_tool_result_error.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaCodeExecutionToolResultError = Beta::BetaCodeExecutionToolResultError
+
+    module Beta
+      class BetaCodeExecutionToolResultError < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaCodeExecutionToolResultError,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            Anthropic::Beta::BetaCodeExecutionToolResultErrorCode::TaggedSymbol
+          )
+        end
+        attr_accessor :error_code
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            error_code:
+              Anthropic::Beta::BetaCodeExecutionToolResultErrorCode::OrSymbol,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(error_code:, type: :code_execution_tool_result_error)
+        end
+
+        sig do
+          override.returns(
+            {
+              error_code:
+                Anthropic::Beta::BetaCodeExecutionToolResultErrorCode::TaggedSymbol,
+              type: Symbol
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_code_execution_tool_result_error_code.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaCodeExecutionToolResultErrorCode =
+      Beta::BetaCodeExecutionToolResultErrorCode
+
+    module Beta
+      module BetaCodeExecutionToolResultErrorCode
+        extend Anthropic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Anthropic::Beta::BetaCodeExecutionToolResultErrorCode)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        INVALID_TOOL_INPUT =
+          T.let(
+            :invalid_tool_input,
+            Anthropic::Beta::BetaCodeExecutionToolResultErrorCode::TaggedSymbol
+          )
+        UNAVAILABLE =
+          T.let(
+            :unavailable,
+            Anthropic::Beta::BetaCodeExecutionToolResultErrorCode::TaggedSymbol
+          )
+        TOO_MANY_REQUESTS =
+          T.let(
+            :too_many_requests,
+            Anthropic::Beta::BetaCodeExecutionToolResultErrorCode::TaggedSymbol
+          )
+        EXECUTION_TIME_EXCEEDED =
+          T.let(
+            :execution_time_exceeded,
+            Anthropic::Beta::BetaCodeExecutionToolResultErrorCode::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Anthropic::Beta::BetaCodeExecutionToolResultErrorCode::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_code_execution_tool_result_error_param.rbi

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

data/rbi/anthropic/models/beta/beta_container.rbi

@@ -0,0 +1,39 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaContainer = Beta::BetaContainer
+
+    module Beta
+      class BetaContainer < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Anthropic::Beta::BetaContainer, Anthropic::Internal::AnyHash)
+          end
+
+        # Identifier for the container used in this request
+        sig { returns(String) }
+        attr_accessor :id
+
+        # The time at which the container will expire.
+        sig { returns(Time) }
+        attr_accessor :expires_at
+
+        # Information about the container used in the request (for the code execution
+        # tool)
+        sig { params(id: String, expires_at: Time).returns(T.attached_class) }
+        def self.new(
+          # Identifier for the container used in this request
+          id:,
+          # The time at which the container will expire.
+          expires_at:
+        )
+        end
+
+        sig { override.returns({ id: String, expires_at: Time }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_container_upload_block.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaContainerUploadBlock = Beta::BetaContainerUploadBlock
+
+    module Beta
+      class BetaContainerUploadBlock < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaContainerUploadBlock,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :file_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Response model for a file uploaded to the container.
+        sig { params(file_id: String, type: Symbol).returns(T.attached_class) }
+        def self.new(file_id:, type: :container_upload)
+        end
+
+        sig { override.returns({ file_id: String, type: Symbol }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_container_upload_block_param.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaContainerUploadBlockParam = Beta::BetaContainerUploadBlockParam
+
+    module Beta
+      class BetaContainerUploadBlockParam < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaContainerUploadBlockParam,
+              Anthropic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :file_id
+
+        sig { returns(Symbol) }
+        attr_accessor :type
+
+        # Create a cache control breakpoint at this content block.
+        sig { returns(T.nilable(Anthropic::Beta::BetaCacheControlEphemeral)) }
+        attr_reader :cache_control
+
+        sig do
+          params(
+            cache_control:
+              T.nilable(Anthropic::Beta::BetaCacheControlEphemeral::OrHash)
+          ).void
+        end
+        attr_writer :cache_control
+
+        # A content block that represents a file to be uploaded to the container Files
+        # uploaded via this block will be available in the container's input directory.
+        sig do
+          params(
+            file_id: String,
+            cache_control:
+              T.nilable(Anthropic::Beta::BetaCacheControlEphemeral::OrHash),
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          file_id:,
+          # Create a cache control breakpoint at this content block.
+          cache_control: nil,
+          type: :container_upload
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              file_id: String,
+              type: Symbol,
+              cache_control:
+                T.nilable(Anthropic::Beta::BetaCacheControlEphemeral)
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_content_block.rbi

@@ -5,6 +5,7 @@ module Anthropic
     BetaContentBlock = Beta::BetaContentBlock
 
     module Beta
+      # Response model for a file uploaded to the container.
       module BetaContentBlock
         extend Anthropic::Internal::Type::Union
 
@@ -15,6 +16,10 @@ module Anthropic
               Anthropic::Beta::BetaToolUseBlock,
               Anthropic::Beta::BetaServerToolUseBlock,
               Anthropic::Beta::BetaWebSearchToolResultBlock,
+              Anthropic::Beta::BetaCodeExecutionToolResultBlock,
+              Anthropic::Beta::BetaMCPToolUseBlock,
+              Anthropic::Beta::BetaMCPToolResultBlock,
+              Anthropic::Beta::BetaContainerUploadBlock,
               Anthropic::Beta::BetaThinkingBlock,
               Anthropic::Beta::BetaRedactedThinkingBlock
             )