anthropic 1.76.0 → 1.77.0

data/rbi/anthropic/models/model_capabilities.rbi

@@ -22,7 +22,10 @@ module Anthropic
       sig { params(citations: Anthropic::CapabilitySupport::OrHash).void }
       attr_writer :citations
 
-      # Whether the model supports code execution tools.
+      # Whether code that the model runs in the code execution tool can call the
+      # request's other tools, as in programmatic tool calling and dynamic filtering for
+      # web search and web fetch. Support for the code execution tool itself is in
+      # `server_tools.code_execution`.
       sig { returns(Anthropic::CapabilitySupport) }
       attr_reader :code_execution
 
@@ -61,6 +64,18 @@ module Anthropic
       sig { params(pdf_input: Anthropic::CapabilitySupport::OrHash).void }
       attr_writer :pdf_input
 
+      # Whether this model supports the web search and code execution server tools.
+      # `supported` is true when the model supports at least one of the tools. A
+      # supported tool can still be rejected for your organization, for example when an
+      # admin has turned web search off.
+      sig { returns(Anthropic::ServerToolsCapability) }
+      attr_reader :server_tools
+
+      sig do
+        params(server_tools: Anthropic::ServerToolsCapability::OrHash).void
+      end
+      attr_writer :server_tools
+
       # Whether the model supports structured output / JSON mode / strict tool schemas.
       sig { returns(Anthropic::CapabilitySupport) }
       attr_reader :structured_outputs
@@ -87,6 +102,7 @@ module Anthropic
           effort: Anthropic::EffortCapability::OrHash,
           image_input: Anthropic::CapabilitySupport::OrHash,
           pdf_input: Anthropic::CapabilitySupport::OrHash,
+          server_tools: Anthropic::ServerToolsCapability::OrHash,
           structured_outputs: Anthropic::CapabilitySupport::OrHash,
           thinking: Anthropic::ThinkingCapability::OrHash
         ).returns(T.attached_class)
@@ -96,7 +112,10 @@ module Anthropic
         batch:,
         # Whether the model supports citation generation.
         citations:,
-        # Whether the model supports code execution tools.
+        # Whether code that the model runs in the code execution tool can call the
+        # request's other tools, as in programmatic tool calling and dynamic filtering for
+        # web search and web fetch. Support for the code execution tool itself is in
+        # `server_tools.code_execution`.
         code_execution:,
         # Context management support and available strategies.
         context_management:,
@@ -106,6 +125,11 @@ module Anthropic
         image_input:,
         # Whether the model accepts PDF content blocks.
         pdf_input:,
+        # Whether this model supports the web search and code execution server tools.
+        # `supported` is true when the model supports at least one of the tools. A
+        # supported tool can still be rejected for your organization, for example when an
+        # admin has turned web search off.
+        server_tools:,
         # Whether the model supports structured output / JSON mode / strict tool schemas.
         structured_outputs:,
         # Thinking capability and supported type configurations.
@@ -123,6 +147,7 @@ module Anthropic
             effort: Anthropic::EffortCapability,
             image_input: Anthropic::CapabilitySupport,
             pdf_input: Anthropic::CapabilitySupport,
+            server_tools: Anthropic::ServerToolsCapability,
             structured_outputs: Anthropic::CapabilitySupport,
             thinking: Anthropic::ThinkingCapability
           }

data/rbi/anthropic/models/model_info.rbi

@@ -29,10 +29,34 @@ module Anthropic
       sig { returns(Time) }
       attr_accessor :created_at
 
+      # RFC 3339 datetime string representing the time of the model's most recent
+      # deprecation. Populated for `deprecated` and `retired` models; `null` while the
+      # model is `active`.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :deprecated_at
+
       # A human-readable name for the model.
       sig { returns(String) }
       attr_accessor :display_name
 
+      # The model's current lifecycle stage.
+      #
+      # - `active`: The model is available for use, open to new adopters, and not
+      #   scheduled for retirement.
+      # - `deprecated`: The model remains callable for organizations with existing
+      #   access, but is headed for retirement and closed to new adopters.
+      # - `retired`: The model is no longer available for use; inference requests naming
+      #   it fail. It remains in the catalogue as the historical record of its
+      #   retirement.
+      sig { returns(Anthropic::ModelInfo::Lifecycle::TaggedSymbol) }
+      attr_accessor :lifecycle
+
+      # The model line this model belongs to, such as `opus` for both Claude Opus 4.5
+      # and Claude Opus 4.6. More lines may be added. `null` when the model belongs to
+      # no line; do not infer a line from the `id`.
+      sig { returns(T.nilable(Anthropic::ModelLine::TaggedSymbol)) }
+      attr_accessor :line
+
       # Maximum input context window size in tokens for this model.
       sig { returns(T.nilable(Integer)) }
       attr_accessor :max_input_tokens
@@ -41,6 +65,14 @@ module Anthropic
       sig { returns(T.nilable(Integer)) }
       attr_accessor :max_tokens
 
+      # RFC 3339 datetime string representing the model's currently scheduled retirement
+      # date. The schedule can be revised until retirement occurs; `null` while the
+      # model is `active` or while no retirement is scheduled. A past date on a
+      # `deprecated` model means retirement is overdue, not that it has occurred:
+      # `lifecycle` is the retirement signal.
+      sig { returns(T.nilable(Time)) }
+      attr_accessor :retires_at
+
       # Object type.
       #
       # For Models, this is always `"model"`.
@@ -52,9 +84,13 @@ module Anthropic
           id: String,
           capabilities: T.nilable(Anthropic::ModelCapabilities::OrHash),
           created_at: Time,
+          deprecated_at: T.nilable(Time),
           display_name: String,
+          lifecycle: Anthropic::ModelInfo::Lifecycle::OrSymbol,
+          line: T.nilable(Anthropic::ModelLine::OrSymbol),
           max_input_tokens: T.nilable(Integer),
           max_tokens: T.nilable(Integer),
+          retires_at: T.nilable(Time),
           type: Symbol
         ).returns(T.attached_class)
       end
@@ -67,12 +103,36 @@ module Anthropic
         # RFC 3339 datetime string representing the time at which the model was released.
         # May be set to an epoch value if the release date is unknown.
         created_at:,
+        # RFC 3339 datetime string representing the time of the model's most recent
+        # deprecation. Populated for `deprecated` and `retired` models; `null` while the
+        # model is `active`.
+        deprecated_at:,
         # A human-readable name for the model.
         display_name:,
+        # The model's current lifecycle stage.
+        #
+        # - `active`: The model is available for use, open to new adopters, and not
+        #   scheduled for retirement.
+        # - `deprecated`: The model remains callable for organizations with existing
+        #   access, but is headed for retirement and closed to new adopters.
+        # - `retired`: The model is no longer available for use; inference requests naming
+        #   it fail. It remains in the catalogue as the historical record of its
+        #   retirement.
+        lifecycle:,
+        # The model line this model belongs to, such as `opus` for both Claude Opus 4.5
+        # and Claude Opus 4.6. More lines may be added. `null` when the model belongs to
+        # no line; do not infer a line from the `id`.
+        line:,
         # Maximum input context window size in tokens for this model.
         max_input_tokens:,
         # Maximum value for the `max_tokens` parameter when using this model.
         max_tokens:,
+        # RFC 3339 datetime string representing the model's currently scheduled retirement
+        # date. The schedule can be revised until retirement occurs; `null` while the
+        # model is `active` or while no retirement is scheduled. A past date on a
+        # `deprecated` model means retirement is overdue, not that it has occurred:
+        # `lifecycle` is the retirement signal.
+        retires_at:,
         # Object type.
         #
         # For Models, this is always `"model"`.
@@ -86,15 +146,49 @@ module Anthropic
             id: String,
             capabilities: T.nilable(Anthropic::ModelCapabilities),
             created_at: Time,
+            deprecated_at: T.nilable(Time),
             display_name: String,
+            lifecycle: Anthropic::ModelInfo::Lifecycle::TaggedSymbol,
+            line: T.nilable(Anthropic::ModelLine::TaggedSymbol),
             max_input_tokens: T.nilable(Integer),
             max_tokens: T.nilable(Integer),
+            retires_at: T.nilable(Time),
             type: Symbol
           }
         )
       end
       def to_hash
       end
+
+      # The model's current lifecycle stage.
+      #
+      # - `active`: The model is available for use, open to new adopters, and not
+      #   scheduled for retirement.
+      # - `deprecated`: The model remains callable for organizations with existing
+      #   access, but is headed for retirement and closed to new adopters.
+      # - `retired`: The model is no longer available for use; inference requests naming
+      #   it fail. It remains in the catalogue as the historical record of its
+      #   retirement.
+      module Lifecycle
+        extend Anthropic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Anthropic::ModelInfo::Lifecycle) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACTIVE = T.let(:active, Anthropic::ModelInfo::Lifecycle::TaggedSymbol)
+        DEPRECATED =
+          T.let(:deprecated, Anthropic::ModelInfo::Lifecycle::TaggedSymbol)
+        RETIRED = T.let(:retired, Anthropic::ModelInfo::Lifecycle::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Anthropic::ModelInfo::Lifecycle::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
     end
   end
 end

data/rbi/anthropic/models/model_line.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    # A Claude model line, such as `opus` or `sonnet`. More lines may be added as new
+    # values.
+    module ModelLine
+      extend Anthropic::Internal::Type::Enum
+
+      TaggedSymbol = T.type_alias { T.all(Symbol, Anthropic::ModelLine) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      HAIKU = T.let(:haiku, Anthropic::ModelLine::TaggedSymbol)
+      SONNET = T.let(:sonnet, Anthropic::ModelLine::TaggedSymbol)
+      OPUS = T.let(:opus, Anthropic::ModelLine::TaggedSymbol)
+      FABLE = T.let(:fable, Anthropic::ModelLine::TaggedSymbol)
+      MYTHOS = T.let(:mythos, Anthropic::ModelLine::TaggedSymbol)
+
+      sig { override.returns(T::Array[Anthropic::ModelLine::TaggedSymbol]) }
+      def self.values
+      end
+    end
+  end
+end

data/rbi/anthropic/models/model_list_params.rbi

@@ -27,6 +27,24 @@ module Anthropic
       sig { params(before_id: String).void }
       attr_writer :before_id
 
+      # Filter the list to models in any of the given lifecycle stages (`active`,
+      # `deprecated`, or `retired`). Up to 3 values. When omitted, the list contains the
+      # `active` and `deprecated` models; `retired` models appear only when `retired` is
+      # requested explicitly.
+      sig do
+        returns(
+          T.nilable(T::Array[Anthropic::ModelListParams::Lifecycle::OrSymbol])
+        )
+      end
+      attr_reader :lifecycle
+
+      sig do
+        params(
+          lifecycle: T::Array[Anthropic::ModelListParams::Lifecycle::OrSymbol]
+        ).void
+      end
+      attr_writer :lifecycle
+
       # Number of items to return per page.
       #
       # Defaults to `20`. Ranges from `1` to `1000`.
@@ -67,6 +85,7 @@ module Anthropic
         params(
           after_id: String,
           before_id: String,
+          lifecycle: T::Array[Anthropic::ModelListParams::Lifecycle::OrSymbol],
           limit: Integer,
           betas: T::Array[T.any(Anthropic::AnthropicBeta::OrSymbol, String)],
           workspace_id: String,
@@ -80,6 +99,11 @@ module Anthropic
         # ID of the object to use as a cursor for pagination. When provided, returns the
         # page of results immediately before this object.
         before_id: nil,
+        # Filter the list to models in any of the given lifecycle stages (`active`,
+        # `deprecated`, or `retired`). Up to 3 values. When omitted, the list contains the
+        # `active` and `deprecated` models; `retired` models appear only when `retired` is
+        # requested explicitly.
+        lifecycle: nil,
         # Number of items to return per page.
         #
         # Defaults to `20`. Ranges from `1` to `1000`.
@@ -102,6 +126,8 @@ module Anthropic
           {
             after_id: String,
             before_id: String,
+            lifecycle:
+              T::Array[Anthropic::ModelListParams::Lifecycle::OrSymbol],
             limit: Integer,
             betas: T::Array[T.any(Anthropic::AnthropicBeta::OrSymbol, String)],
             workspace_id: String,
@@ -111,6 +137,32 @@ module Anthropic
       end
       def to_hash
       end
+
+      module Lifecycle
+        extend Anthropic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Anthropic::ModelListParams::Lifecycle) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACTIVE =
+          T.let(:active, Anthropic::ModelListParams::Lifecycle::TaggedSymbol)
+        DEPRECATED =
+          T.let(
+            :deprecated,
+            Anthropic::ModelListParams::Lifecycle::TaggedSymbol
+          )
+        RETIRED =
+          T.let(:retired, Anthropic::ModelListParams::Lifecycle::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Anthropic::ModelListParams::Lifecycle::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
     end
   end
 end

data/rbi/anthropic/models/organization/federation/federation_rule.rbi

@@ -75,8 +75,9 @@ module Anthropic
           sig { returns(String) }
           attr_accessor :oauth_scope
 
-          # Identity that tokens minted via this rule act as. Currently always a
-          # `service_account` target.
+          # What this rule targets. Check `type` before reading the other fields. Tokens
+          # minted via a rule whose target `type` is `service_account` act as that service
+          # account.
           sig do
             returns(Anthropic::Organization::Federation::ServiceAccountTarget)
           end
@@ -172,8 +173,9 @@ module Anthropic
             name:,
             # Space-separated OAuth scopes granted on the minted token.
             oauth_scope:,
-            # Identity that tokens minted via this rule act as. Currently always a
-            # `service_account` target.
+            # What this rule targets. Check `type` before reading the other fields. Tokens
+            # minted via a rule whose target `type` is `service_account` act as that service
+            # account.
             target:,
             # Lifetime in seconds of access tokens minted via this rule. Minted tokens are
             # capped at `max(60, min(this value, 2 × remaining assertion validity))` seconds.

data/rbi/anthropic/models/organization/workspace_list_params.rbi

@@ -38,6 +38,13 @@ module Anthropic
         sig { params(include_archived: T::Boolean).void }
         attr_writer :include_archived
 
+        # Whether to include the organization's default Workspace in the response
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :include_default
+
+        sig { params(include_default: T::Boolean).void }
+        attr_writer :include_default
+
         # Number of items to return per page.
         #
         # Defaults to `20`. Ranges from `1` to `1000`.
@@ -52,6 +59,7 @@ module Anthropic
             after_id: String,
             before_id: String,
             include_archived: T::Boolean,
+            include_default: T::Boolean,
             limit: Integer,
             request_options: Anthropic::RequestOptions::OrHash
           ).returns(T.attached_class)
@@ -65,6 +73,8 @@ module Anthropic
           before_id: nil,
           # Whether to include Workspaces that have been archived in the response
           include_archived: nil,
+          # Whether to include the organization's default Workspace in the response
+          include_default: nil,
           # Number of items to return per page.
           #
           # Defaults to `20`. Ranges from `1` to `1000`.
@@ -79,6 +89,7 @@ module Anthropic
               after_id: String,
               before_id: String,
               include_archived: T::Boolean,
+              include_default: T::Boolean,
               limit: Integer,
               request_options: Anthropic::RequestOptions
             }

data/rbi/anthropic/models/server_tools_capability.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ServerToolsCapability < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::ServerToolsCapability, Anthropic::Internal::AnyHash)
+        end
+
+      # Whether the model supports the code execution tool: true when the model supports
+      # at least one version of the tool, not necessarily every version.
+      sig { returns(Anthropic::CapabilitySupport) }
+      attr_reader :code_execution
+
+      sig { params(code_execution: Anthropic::CapabilitySupport::OrHash).void }
+      attr_writer :code_execution
+
+      # Whether this capability is supported by the model.
+      sig { returns(T::Boolean) }
+      attr_accessor :supported
+
+      # Whether the model supports the web search tool: true when the model supports at
+      # least one version of the tool, not necessarily every version.
+      sig { returns(Anthropic::CapabilitySupport) }
+      attr_reader :web_search
+
+      sig { params(web_search: Anthropic::CapabilitySupport::OrHash).void }
+      attr_writer :web_search
+
+      # Web search and code execution tool support, with one entry per tool.
+      sig do
+        params(
+          code_execution: Anthropic::CapabilitySupport::OrHash,
+          supported: T::Boolean,
+          web_search: Anthropic::CapabilitySupport::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Whether the model supports the code execution tool: true when the model supports
+        # at least one version of the tool, not necessarily every version.
+        code_execution:,
+        # Whether this capability is supported by the model.
+        supported:,
+        # Whether the model supports the web search tool: true when the model supports at
+        # least one version of the tool, not necessarily every version.
+        web_search:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            code_execution: Anthropic::CapabilitySupport,
+            supported: T::Boolean,
+            web_search: Anthropic::CapabilitySupport
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/thinking_types.rbi

@@ -8,31 +8,50 @@ module Anthropic
           T.any(Anthropic::ThinkingTypes, Anthropic::Internal::AnyHash)
         end
 
-      # Whether the model supports thinking with type 'adaptive' (auto).
+      # Whether the model accepts thinking with type 'adaptive' (the model decides
+      # whether and how much to think).
       sig { returns(Anthropic::CapabilitySupport) }
       attr_reader :adaptive
 
       sig { params(adaptive: Anthropic::CapabilitySupport::OrHash).void }
       attr_writer :adaptive
 
-      # Whether the model supports thinking with type 'enabled'.
+      # Whether the model accepts thinking with type 'disabled' (thinking turned off).
+      # False exactly when a request that sends it gets a 400 from this model. True on a
+      # model that does not support thinking.
+      sig { returns(Anthropic::CapabilitySupport) }
+      attr_reader :disabled
+
+      sig { params(disabled: Anthropic::CapabilitySupport::OrHash).void }
+      attr_writer :disabled
+
+      # Whether the model accepts thinking with type 'enabled' (extended thinking with a
+      # caller-set `budget_tokens`).
       sig { returns(Anthropic::CapabilitySupport) }
       attr_reader :enabled
 
       sig { params(enabled: Anthropic::CapabilitySupport::OrHash).void }
       attr_writer :enabled
 
-      # Supported thinking type configurations.
+      # Which `thinking.type` values the model accepts on requests. Read each key on its
+      # own: for example, `enabled` can be false while `disabled` is true.
       sig do
         params(
           adaptive: Anthropic::CapabilitySupport::OrHash,
+          disabled: Anthropic::CapabilitySupport::OrHash,
           enabled: Anthropic::CapabilitySupport::OrHash
         ).returns(T.attached_class)
       end
       def self.new(
-        # Whether the model supports thinking with type 'adaptive' (auto).
+        # Whether the model accepts thinking with type 'adaptive' (the model decides
+        # whether and how much to think).
         adaptive:,
-        # Whether the model supports thinking with type 'enabled'.
+        # Whether the model accepts thinking with type 'disabled' (thinking turned off).
+        # False exactly when a request that sends it gets a 400 from this model. True on a
+        # model that does not support thinking.
+        disabled:,
+        # Whether the model accepts thinking with type 'enabled' (extended thinking with a
+        # caller-set `budget_tokens`).
         enabled:
       )
       end
@@ -41,6 +60,7 @@ module Anthropic
         override.returns(
           {
             adaptive: Anthropic::CapabilitySupport,
+            disabled: Anthropic::CapabilitySupport,
             enabled: Anthropic::CapabilitySupport
           }
         )

data/rbi/anthropic/models/tool_use_caller.rbi

@@ -0,0 +1,63 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    # Which party invoked the tool call: the model directly, or a server tool on its
+    # behalf.
+    module ToolUseCaller
+      extend Anthropic::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Anthropic::DirectCaller,
+            Anthropic::ServerToolCaller,
+            Anthropic::ServerToolCaller20260120
+          )
+        end
+
+      module Type
+        extend Anthropic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Anthropic::ToolUseCaller::Type) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        DIRECT = T.let(:direct, Anthropic::ToolUseCaller::Type::TaggedSymbol)
+        CODE_EXECUTION_20250825 =
+          T.let(
+            :code_execution_20250825,
+            Anthropic::ToolUseCaller::Type::TaggedSymbol
+          )
+        CODE_EXECUTION_20260120 =
+          T.let(
+            :code_execution_20260120,
+            Anthropic::ToolUseCaller::Type::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Anthropic::ToolUseCaller::Type::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      sig { override.returns(T::Array[Anthropic::ToolUseCaller::Variants]) }
+      def self.variants
+      end
+
+      # Creates a new instance of the variant class whose `type` matches the given
+      # value, passing the remaining arguments to its constructor.
+      sig do
+        params(
+          type: Anthropic::ToolUseCaller::Type::OrSymbol,
+          tool_id: String
+        ).returns(Anthropic::ToolUseCaller::Variants)
+      end
+      def self.new(type:, tool_id: nil)
+      end
+    end
+  end
+end

data/rbi/anthropic/models/toolset_tool_use_block.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module ToolsetToolUseBlock
+      extend Anthropic::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserToolUseBlock::Variants,
+            Anthropic::ComputerToolUseBlock::Variants,
+            Anthropic::ToolUseBlock
+          )
+        end
+
+      sig do
+        override.returns(T::Array[Anthropic::ToolsetToolUseBlock::Variants])
+      end
+      def self.variants
+      end
+    end
+  end
+end