anthropic 1.48.2 → 1.49.0

data/rbi/anthropic/middleware.rbi

@@ -0,0 +1,338 @@
+# typed: strong
+
+module Anthropic
+  # The per-attempt request object a middleware sees.
+  class APIRequest
+    MEMBERS = T.let(T.unsafe(nil), T::Array[Symbol])
+
+    sig { returns(Symbol) }
+    attr_reader :method
+
+    sig { returns(URI::Generic) }
+    attr_reader :url
+
+    sig { returns(T::Hash[String, String]) }
+    attr_reader :headers
+
+    sig { returns(T.nilable(T.anything)) }
+    attr_reader :body
+
+    sig do
+      returns(
+        T.nilable(
+          T::Class[
+            Anthropic::Internal::Type::BaseStream[
+              T.anything,
+              Anthropic::Internal::Type::BaseModel
+            ]
+          ]
+        )
+      )
+    end
+    attr_reader :stream
+
+    sig { returns(T.nilable(Anthropic::Internal::Type::Converter::Input)) }
+    attr_reader :cast_to
+
+    sig do
+      returns(
+        T.nilable(
+          T.any(
+            Symbol,
+            Integer,
+            T::Array[T.any(Symbol, Integer)],
+            T.proc.params(arg0: T.anything).returns(T.anything)
+          )
+        )
+      )
+    end
+    attr_reader :unwrap
+
+    sig { returns(T::Hash[Symbol, T.anything]) }
+    attr_reader :options
+
+    sig { returns(Integer) }
+    attr_reader :retry_count
+
+    sig { returns(T::Hash[Symbol, T.anything]) }
+    attr_reader :metadata
+
+    sig { returns(T::Boolean) }
+    def streaming?
+    end
+
+    sig { returns(T::Boolean) }
+    def retry?
+    end
+
+    sig { returns(Float) }
+    def timeout
+    end
+
+    sig do
+      params(
+        method: Symbol,
+        url: URI::Generic,
+        headers: T::Hash[String, String],
+        body: T.nilable(T.anything),
+        stream:
+          T.nilable(
+            T::Class[
+              Anthropic::Internal::Type::BaseStream[
+                T.anything,
+                Anthropic::Internal::Type::BaseModel
+              ]
+            ]
+          ),
+        cast_to: T.nilable(Anthropic::Internal::Type::Converter::Input),
+        unwrap:
+          T.nilable(
+            T.any(
+              Symbol,
+              Integer,
+              T::Array[T.any(Symbol, Integer)],
+              T.proc.params(arg0: T.anything).returns(T.anything)
+            )
+          ),
+        options: T::Hash[Symbol, T.anything],
+        retry_count: Integer,
+        metadata: T::Hash[Symbol, T.anything]
+      ).returns(T.attached_class)
+    end
+    def self.new(
+      method:,
+      url:,
+      headers:,
+      body:,
+      stream:,
+      cast_to:,
+      unwrap:,
+      options:,
+      retry_count:,
+      metadata:
+    )
+    end
+
+    sig do
+      params(
+        method: Symbol,
+        url: URI::Generic,
+        headers: T::Hash[String, String],
+        body: T.nilable(T.anything),
+        stream:
+          T.nilable(
+            T::Class[
+              Anthropic::Internal::Type::BaseStream[
+                T.anything,
+                Anthropic::Internal::Type::BaseModel
+              ]
+            ]
+          ),
+        cast_to: T.nilable(Anthropic::Internal::Type::Converter::Input),
+        unwrap:
+          T.nilable(
+            T.any(
+              Symbol,
+              Integer,
+              T::Array[T.any(Symbol, Integer)],
+              T.proc.params(arg0: T.anything).returns(T.anything)
+            )
+          ),
+        options: T::Hash[Symbol, T.anything],
+        retry_count: Integer,
+        metadata: T::Hash[Symbol, T.anything]
+      ).returns(T.self_type)
+    end
+    def with(
+      method: self.method,
+      url: self.url,
+      headers: self.headers,
+      body: self.body,
+      stream: self.stream,
+      cast_to: self.cast_to,
+      unwrap: self.unwrap,
+      options: self.options,
+      retry_count: self.retry_count,
+      metadata: self.metadata
+    )
+    end
+
+    sig { returns(T::Hash[Symbol, T.anything]) }
+    def to_h
+    end
+  end
+
+  class APIResponse
+    class ConsumedBodyError < Anthropic::Errors::Error
+    end
+
+    sig { returns(Integer) }
+    attr_reader :status
+
+    sig { returns(T::Hash[String, String]) }
+    attr_reader :headers
+
+    sig { returns(T.nilable(Net::HTTPResponse)) }
+    attr_reader :raw
+
+    sig { returns(T.nilable(Anthropic::APIRequest)) }
+    attr_reader :request
+
+    # @api private
+    sig do
+      params(
+        status: Integer,
+        raw: Net::HTTPResponse,
+        stream: T::Enumerable[String],
+        request: T.nilable(Anthropic::APIRequest)
+      ).returns(T.attached_class)
+    end
+    def self.wrap(status, raw, stream, request: nil)
+    end
+
+    sig do
+      params(
+        status: Integer,
+        headers: T::Hash[String, String],
+        body: T.nilable(T.any(T::Enumerable[String], String)),
+        raw: T.nilable(Net::HTTPResponse),
+        streaming: T.nilable(T::Boolean),
+        request: T.nilable(Anthropic::APIRequest)
+      ).returns(T.attached_class)
+    end
+    def self.new(
+      status:,
+      headers: {},
+      body: nil,
+      raw: nil,
+      streaming: nil,
+      request: nil
+    )
+    end
+
+    sig { returns(T::Enumerable[String]) }
+    def body
+    end
+
+    sig { returns(T::Boolean) }
+    def streaming?
+    end
+
+    sig { returns(T::Boolean) }
+    def retryable?
+    end
+
+    sig { params(force: T::Boolean).returns(T.self_type) }
+    def buffer!(force: false)
+    end
+
+    sig do
+      params(
+        streaming: T::Boolean,
+        blk:
+          T
+            .proc
+            .params(upstream: T::Enumerable[String])
+            .returns(T::Enumerable[String])
+      ).returns(Anthropic::APIResponse)
+    end
+    def wrap_body(streaming: streaming?, &blk)
+    end
+
+    sig { returns(T.anything) }
+    def parse
+    end
+
+    # @api private
+    sig do
+      returns(
+        [
+          Integer,
+          T.nilable(Net::HTTPResponse),
+          T::Hash[String, String],
+          T::Enumerable[String]
+        ]
+      )
+    end
+    def to_tuple
+    end
+  end
+
+  module Middleware
+    extend T::Helpers
+
+    abstract!
+
+    # Optional mixin naming the middleware contract — `include` it in a
+    # middleware class and implement `#call`. The SDK accepts any
+    # `#call(req, nxt)` object, so this is for discovery and type-checking.
+    sig do
+      abstract
+        .params(
+          request: Anthropic::APIRequest,
+          nxt:
+            T
+              .proc
+              .params(request: Anthropic::APIRequest)
+              .returns(Anthropic::APIResponse)
+        )
+        .returns(Anthropic::APIResponse)
+    end
+    def call(request, nxt)
+    end
+
+    # `(req, nxt) -> APIResponse` callable. `nxt` is itself `(req) -> APIResponse`.
+    Callable =
+      T.type_alias do
+        T
+          .proc
+          .params(
+            req: Anthropic::APIRequest,
+            nxt:
+              T
+                .proc
+                .params(req: Anthropic::APIRequest)
+                .returns(Anthropic::APIResponse)
+          )
+          .returns(Anthropic::APIResponse)
+      end
+
+    # A single chain entry — a {Callable} lambda, an object including
+    # {Anthropic::Middleware}, or any other object responding to
+    # `#call(req, nxt)`.
+    Entry =
+      T.type_alias do
+        T.any(Anthropic::Middleware, Anthropic::Middleware::Callable)
+      end
+
+    # The `middleware:` constructor option — a single entry or an array of them.
+    EntryOrArray =
+      T.type_alias do
+        T.any(
+          Anthropic::Middleware::Entry,
+          T::Array[Anthropic::Middleware::Entry]
+        )
+      end
+
+    class << self
+      # @api private
+      sig do
+        params(
+          list: T::Array[T.anything],
+          terminal:
+            T
+              .proc
+              .params(req: Anthropic::APIRequest)
+              .returns(Anthropic::APIResponse)
+        ).returns(
+          T
+            .proc
+            .params(req: Anthropic::APIRequest)
+            .returns(Anthropic::APIResponse)
+        )
+      end
+      def build_chain(list, terminal)
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_advisor_tool_20260301.rbi

@@ -189,7 +189,8 @@ module Anthropic
         # Values: direct: The model can call this tool directly. code_execution_20250825:
         # The tool can be called from the code execution environment (v1).
         # code_execution_20260120: The tool can be called from the code execution
-        # environment (v2 with persistence).
+        # environment (v2 with persistence). code_execution_20260521: The tool can be
+        # called from the code execution environment (v2 with persistence).
         module AllowedCaller
           extend Anthropic::Internal::Type::Enum
 
@@ -217,6 +218,11 @@ module Anthropic
               :code_execution_20260120,
               Anthropic::Beta::BetaAdvisorTool20260301::AllowedCaller::TaggedSymbol
             )
+          CODE_EXECUTION_20260521 =
+            T.let(
+              :code_execution_20260521,
+              Anthropic::Beta::BetaAdvisorTool20260301::AllowedCaller::TaggedSymbol
+            )
 
           sig do
             override.returns(

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

@@ -126,7 +126,8 @@ module Anthropic
         # Values: direct: The model can call this tool directly. code_execution_20250825:
         # The tool can be called from the code execution environment (v1).
         # code_execution_20260120: The tool can be called from the code execution
-        # environment (v2 with persistence).
+        # environment (v2 with persistence). code_execution_20260521: The tool can be
+        # called from the code execution environment (v2 with persistence).
         module AllowedCaller
           extend Anthropic::Internal::Type::Enum
 
@@ -154,6 +155,11 @@ module Anthropic
               :code_execution_20260120,
               Anthropic::Beta::BetaCodeExecutionTool20250522::AllowedCaller::TaggedSymbol
             )
+          CODE_EXECUTION_20260521 =
+            T.let(
+              :code_execution_20260521,
+              Anthropic::Beta::BetaCodeExecutionTool20250522::AllowedCaller::TaggedSymbol
+            )
 
           sig do
             override.returns(

data/rbi/anthropic/models/beta/beta_code_execution_tool_20250825.rbi

@@ -126,7 +126,8 @@ module Anthropic
         # Values: direct: The model can call this tool directly. code_execution_20250825:
         # The tool can be called from the code execution environment (v1).
         # code_execution_20260120: The tool can be called from the code execution
-        # environment (v2 with persistence).
+        # environment (v2 with persistence). code_execution_20260521: The tool can be
+        # called from the code execution environment (v2 with persistence).
         module AllowedCaller
           extend Anthropic::Internal::Type::Enum
 
@@ -154,6 +155,11 @@ module Anthropic
               :code_execution_20260120,
               Anthropic::Beta::BetaCodeExecutionTool20250825::AllowedCaller::TaggedSymbol
             )
+          CODE_EXECUTION_20260521 =
+            T.let(
+              :code_execution_20260521,
+              Anthropic::Beta::BetaCodeExecutionTool20250825::AllowedCaller::TaggedSymbol
+            )
 
           sig do
             override.returns(

data/rbi/anthropic/models/beta/beta_code_execution_tool_20260120.rbi

@@ -128,7 +128,8 @@ module Anthropic
         # Values: direct: The model can call this tool directly. code_execution_20250825:
         # The tool can be called from the code execution environment (v1).
         # code_execution_20260120: The tool can be called from the code execution
-        # environment (v2 with persistence).
+        # environment (v2 with persistence). code_execution_20260521: The tool can be
+        # called from the code execution environment (v2 with persistence).
         module AllowedCaller
           extend Anthropic::Internal::Type::Enum
 
@@ -156,6 +157,11 @@ module Anthropic
               :code_execution_20260120,
               Anthropic::Beta::BetaCodeExecutionTool20260120::AllowedCaller::TaggedSymbol
             )
+          CODE_EXECUTION_20260521 =
+            T.let(
+              :code_execution_20260521,
+              Anthropic::Beta::BetaCodeExecutionTool20260120::AllowedCaller::TaggedSymbol
+            )
 
           sig do
             override.returns(

data/rbi/anthropic/models/beta/beta_code_execution_tool_20260521.rbi

@@ -0,0 +1,178 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    BetaCodeExecutionTool20260521 = Beta::BetaCodeExecutionTool20260521
+
+    module Beta
+      class BetaCodeExecutionTool20260521 < Anthropic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Anthropic::Beta::BetaCodeExecutionTool20260521,
+              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
+
+        sig do
+          returns(
+            T.nilable(
+              T::Array[
+                Anthropic::Beta::BetaCodeExecutionTool20260521::AllowedCaller::OrSymbol
+              ]
+            )
+          )
+        end
+        attr_reader :allowed_callers
+
+        sig do
+          params(
+            allowed_callers:
+              T::Array[
+                Anthropic::Beta::BetaCodeExecutionTool20260521::AllowedCaller::OrSymbol
+              ]
+          ).void
+        end
+        attr_writer :allowed_callers
+
+        # 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
+
+        # If true, tool will not be included in initial system prompt. Only loaded when
+        # returned via tool_reference from tool search.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :defer_loading
+
+        sig { params(defer_loading: T::Boolean).void }
+        attr_writer :defer_loading
+
+        # When true, guarantees schema validation on tool names and inputs
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :strict
+
+        sig { params(strict: T::Boolean).void }
+        attr_writer :strict
+
+        # Code execution tool with REPL state persistence.
+        sig do
+          params(
+            allowed_callers:
+              T::Array[
+                Anthropic::Beta::BetaCodeExecutionTool20260521::AllowedCaller::OrSymbol
+              ],
+            cache_control:
+              T.nilable(Anthropic::Beta::BetaCacheControlEphemeral::OrHash),
+            defer_loading: T::Boolean,
+            strict: T::Boolean,
+            name: Symbol,
+            type: Symbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          allowed_callers: nil,
+          # Create a cache control breakpoint at this content block.
+          cache_control: nil,
+          # If true, tool will not be included in initial system prompt. Only loaded when
+          # returned via tool_reference from tool search.
+          defer_loading: nil,
+          # When true, guarantees schema validation on tool names and inputs
+          strict: 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_20260521
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              name: Symbol,
+              type: Symbol,
+              allowed_callers:
+                T::Array[
+                  Anthropic::Beta::BetaCodeExecutionTool20260521::AllowedCaller::OrSymbol
+                ],
+              cache_control:
+                T.nilable(Anthropic::Beta::BetaCacheControlEphemeral),
+              defer_loading: T::Boolean,
+              strict: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Specifies who can invoke a tool.
+        #
+        # Values: direct: The model can call this tool directly. code_execution_20250825:
+        # The tool can be called from the code execution environment (v1).
+        # code_execution_20260120: The tool can be called from the code execution
+        # environment (v2 with persistence). code_execution_20260521: The tool can be
+        # called from the code execution environment (v2 with persistence).
+        module AllowedCaller
+          extend Anthropic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Anthropic::Beta::BetaCodeExecutionTool20260521::AllowedCaller
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          DIRECT =
+            T.let(
+              :direct,
+              Anthropic::Beta::BetaCodeExecutionTool20260521::AllowedCaller::TaggedSymbol
+            )
+          CODE_EXECUTION_20250825 =
+            T.let(
+              :code_execution_20250825,
+              Anthropic::Beta::BetaCodeExecutionTool20260521::AllowedCaller::TaggedSymbol
+            )
+          CODE_EXECUTION_20260120 =
+            T.let(
+              :code_execution_20260120,
+              Anthropic::Beta::BetaCodeExecutionTool20260521::AllowedCaller::TaggedSymbol
+            )
+          CODE_EXECUTION_20260521 =
+            T.let(
+              :code_execution_20260521,
+              Anthropic::Beta::BetaCodeExecutionTool20260521::AllowedCaller::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Anthropic::Beta::BetaCodeExecutionTool20260521::AllowedCaller::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/anthropic/models/beta/beta_fallback_block.rbi

@@ -32,16 +32,27 @@ module Anthropic
         sig { params(to: Anthropic::Beta::BetaFallbackInfo::OrHash).void }
         attr_writer :to
 
+        # What caused the `from` model to hand over at this hop.
+        sig { returns(Anthropic::Beta::BetaFallbackRefusalTrigger) }
+        attr_reader :trigger
+
+        sig do
+          params(
+            trigger: Anthropic::Beta::BetaFallbackRefusalTrigger::OrHash
+          ).void
+        end
+        attr_writer :trigger
+
         sig { returns(Symbol) }
         attr_accessor :type
 
         # Marks the point in `content` where one model's output gives way to the next.
         #
         # One block appears per hop where a preceding model actually ran this turn and
-        # declined. A turn routed directly by the sticky decision has no such boundary and
-        # carries no block — the signal for whether a fallback model served the response
-        # is the presence of a `fallback_message` entry in `usage.iterations`, not this
-        # block.
+        # declined. A turn where no preceding model ran and declined has no such boundary
+        # and carries no block — the signal for whether a fallback model served the
+        # response is the presence of a `fallback_message` entry in `usage.iterations`,
+        # not this block.
         #
         # The block is treated like a server-tool content block for streaming: it arrives
         # via the standard `content_block_start` / `content_block_stop` pair and carries
@@ -50,6 +61,7 @@ module Anthropic
           params(
             from: Anthropic::Beta::BetaFallbackInfo::OrHash,
             to: Anthropic::Beta::BetaFallbackInfo::OrHash,
+            trigger: Anthropic::Beta::BetaFallbackRefusalTrigger::OrHash,
             type: Symbol
           ).returns(T.attached_class)
         end
@@ -62,6 +74,8 @@ module Anthropic
           # The fallback model producing the content that follows this block. Its `model` is
           # always the canonical id.
           to:,
+          # What caused the `from` model to hand over at this hop.
+          trigger:,
           type: :fallback
         )
         end
@@ -71,6 +85,7 @@ module Anthropic
             {
               from: Anthropic::Beta::BetaFallbackInfo,
               to: Anthropic::Beta::BetaFallbackInfo,
+              trigger: Anthropic::Beta::BetaFallbackRefusalTrigger,
               type: Symbol
             }
           )