anthropic 1.76.0 → 1.77.1

data/rbi/anthropic/models/browser_scroll_to_tool_use_block.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserScrollToToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserScrollToToolUseBlock,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Which party invoked the tool call: the model directly, or a server tool on its
+      # behalf.
+      sig { returns(Anthropic::ToolUseCaller::Variants) }
+      attr_accessor :caller_
+
+      # Scroll an element into view.
+      sig { returns(Anthropic::BrowserScrollToInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserScrollToInput::OrHash).void }
+      attr_writer :input
+
+      sig { returns(Symbol) }
+      attr_accessor :name
+
+      sig { returns(Symbol) }
+      attr_accessor :toolset_name
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+          id: String,
+          caller_:
+            T.any(
+              Anthropic::DirectCaller::OrHash,
+              Anthropic::ServerToolCaller::OrHash,
+              Anthropic::ServerToolCaller20260120::OrHash
+            ),
+          input: Anthropic::BrowserScrollToInput::OrHash,
+          name: Symbol,
+          toolset_name: Symbol,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        # Which party invoked the tool call: the model directly, or a server tool on its
+        # behalf.
+        caller_:,
+        # Scroll an element into view.
+        input:,
+        name: :scroll_to,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserScrollToInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_scroll_tool_use_block.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserScrollToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserScrollToolUseBlock,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Which party invoked the tool call: the model directly, or a server tool on its
+      # behalf.
+      sig { returns(Anthropic::ToolUseCaller::Variants) }
+      attr_accessor :caller_
+
+      # Scroll at a viewport position. `target` must be a coordinate target.
+      sig { returns(Anthropic::BrowserScrollInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserScrollInput::OrHash).void }
+      attr_writer :input
+
+      sig { returns(Symbol) }
+      attr_accessor :name
+
+      sig { returns(Symbol) }
+      attr_accessor :toolset_name
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+          id: String,
+          caller_:
+            T.any(
+              Anthropic::DirectCaller::OrHash,
+              Anthropic::ServerToolCaller::OrHash,
+              Anthropic::ServerToolCaller20260120::OrHash
+            ),
+          input: Anthropic::BrowserScrollInput::OrHash,
+          name: Symbol,
+          toolset_name: Symbol,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        # Which party invoked the tool call: the model directly, or a server tool on its
+        # behalf.
+        caller_:,
+        # Scroll at a viewport position. `target` must be a coordinate target.
+        input:,
+        name: :scroll,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserScrollInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_switch_tab_input.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserSwitchTabInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::BrowserSwitchTabInput, Anthropic::Internal::AnyHash)
+        end
+
+      # The tab to switch to.
+      sig { returns(String) }
+      attr_accessor :tab_id
+
+      # Make the tab with the given tab_id the active tab — the tab that actions without
+      # a tab_id apply to.
+      sig { params(tab_id: String).returns(T.attached_class) }
+      def self.new(
+        # The tab to switch to.
+        tab_id:
+      )
+      end
+
+      sig { override.returns({ tab_id: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_switch_tab_tool_use_block.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserSwitchTabToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserSwitchTabToolUseBlock,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Which party invoked the tool call: the model directly, or a server tool on its
+      # behalf.
+      sig { returns(Anthropic::ToolUseCaller::Variants) }
+      attr_accessor :caller_
+
+      # Make the tab with the given tab_id the active tab — the tab that actions without
+      # a tab_id apply to.
+      sig { returns(Anthropic::BrowserSwitchTabInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserSwitchTabInput::OrHash).void }
+      attr_writer :input
+
+      sig { returns(Symbol) }
+      attr_accessor :name
+
+      sig { returns(Symbol) }
+      attr_accessor :toolset_name
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+          id: String,
+          caller_:
+            T.any(
+              Anthropic::DirectCaller::OrHash,
+              Anthropic::ServerToolCaller::OrHash,
+              Anthropic::ServerToolCaller20260120::OrHash
+            ),
+          input: Anthropic::BrowserSwitchTabInput::OrHash,
+          name: Symbol,
+          toolset_name: Symbol,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        # Which party invoked the tool call: the model directly, or a server tool on its
+        # behalf.
+        caller_:,
+        # Make the tab with the given tab_id the active tab — the tab that actions without
+        # a tab_id apply to.
+        input:,
+        name: :switch_tab,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserSwitchTabInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_tool_use_block.rbi

@@ -0,0 +1,226 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module BrowserToolUseBlock
+      extend Anthropic::Internal::Type::Union
+
+      Variants =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserNavigateToolUseBlock,
+            Anthropic::BrowserListTabsToolUseBlock,
+            Anthropic::BrowserNewTabToolUseBlock,
+            Anthropic::BrowserSwitchTabToolUseBlock,
+            Anthropic::BrowserCloseTabToolUseBlock,
+            Anthropic::BrowserReadPageToolUseBlock,
+            Anthropic::BrowserGetPageTextToolUseBlock,
+            Anthropic::BrowserReadConsoleToolUseBlock,
+            Anthropic::BrowserReadNetworkToolUseBlock,
+            Anthropic::BrowserFindToolUseBlock,
+            Anthropic::BrowserFormInputToolUseBlock,
+            Anthropic::BrowserFileUploadToolUseBlock,
+            Anthropic::BrowserScrollToToolUseBlock,
+            Anthropic::BrowserScreenshotToolUseBlock,
+            Anthropic::BrowserZoomToolUseBlock,
+            Anthropic::BrowserLeftClickToolUseBlock,
+            Anthropic::BrowserRightClickToolUseBlock,
+            Anthropic::BrowserMiddleClickToolUseBlock,
+            Anthropic::BrowserDoubleClickToolUseBlock,
+            Anthropic::BrowserTripleClickToolUseBlock,
+            Anthropic::BrowserHoverToolUseBlock,
+            Anthropic::BrowserLeftClickDragToolUseBlock,
+            Anthropic::BrowserLeftMouseDownToolUseBlock,
+            Anthropic::BrowserLeftMouseUpToolUseBlock,
+            Anthropic::BrowserMouseMoveToolUseBlock,
+            Anthropic::BrowserScrollToolUseBlock,
+            Anthropic::BrowserTypeToolUseBlock,
+            Anthropic::BrowserKeyToolUseBlock,
+            Anthropic::BrowserHoldKeyToolUseBlock,
+            Anthropic::BrowserWaitToolUseBlock,
+            Anthropic::BrowserJavascriptExecToolUseBlock
+          )
+        end
+
+      module Name
+        extend Anthropic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Anthropic::BrowserToolUseBlock::Name) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        NAVIGATE =
+          T.let(:navigate, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        LIST_TABS =
+          T.let(:list_tabs, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        NEW_TAB =
+          T.let(:new_tab, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        SWITCH_TAB =
+          T.let(:switch_tab, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        CLOSE_TAB =
+          T.let(:close_tab, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        READ_PAGE =
+          T.let(:read_page, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        GET_PAGE_TEXT =
+          T.let(
+            :get_page_text,
+            Anthropic::BrowserToolUseBlock::Name::TaggedSymbol
+          )
+        READ_CONSOLE =
+          T.let(
+            :read_console,
+            Anthropic::BrowserToolUseBlock::Name::TaggedSymbol
+          )
+        READ_NETWORK =
+          T.let(
+            :read_network,
+            Anthropic::BrowserToolUseBlock::Name::TaggedSymbol
+          )
+        FIND = T.let(:find, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        FORM_INPUT =
+          T.let(:form_input, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        FILE_UPLOAD =
+          T.let(
+            :file_upload,
+            Anthropic::BrowserToolUseBlock::Name::TaggedSymbol
+          )
+        SCROLL_TO =
+          T.let(:scroll_to, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        SCREENSHOT =
+          T.let(:screenshot, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        ZOOM = T.let(:zoom, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        LEFT_CLICK =
+          T.let(:left_click, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        RIGHT_CLICK =
+          T.let(
+            :right_click,
+            Anthropic::BrowserToolUseBlock::Name::TaggedSymbol
+          )
+        MIDDLE_CLICK =
+          T.let(
+            :middle_click,
+            Anthropic::BrowserToolUseBlock::Name::TaggedSymbol
+          )
+        DOUBLE_CLICK =
+          T.let(
+            :double_click,
+            Anthropic::BrowserToolUseBlock::Name::TaggedSymbol
+          )
+        TRIPLE_CLICK =
+          T.let(
+            :triple_click,
+            Anthropic::BrowserToolUseBlock::Name::TaggedSymbol
+          )
+        HOVER =
+          T.let(:hover, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        LEFT_CLICK_DRAG =
+          T.let(
+            :left_click_drag,
+            Anthropic::BrowserToolUseBlock::Name::TaggedSymbol
+          )
+        LEFT_MOUSE_DOWN =
+          T.let(
+            :left_mouse_down,
+            Anthropic::BrowserToolUseBlock::Name::TaggedSymbol
+          )
+        LEFT_MOUSE_UP =
+          T.let(
+            :left_mouse_up,
+            Anthropic::BrowserToolUseBlock::Name::TaggedSymbol
+          )
+        MOUSE_MOVE =
+          T.let(:mouse_move, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        SCROLL =
+          T.let(:scroll, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        TYPE = T.let(:type, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        KEY = T.let(:key, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        HOLD_KEY =
+          T.let(:hold_key, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        WAIT = T.let(:wait, Anthropic::BrowserToolUseBlock::Name::TaggedSymbol)
+        JAVASCRIPT_EXEC =
+          T.let(
+            :javascript_exec,
+            Anthropic::BrowserToolUseBlock::Name::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Anthropic::BrowserToolUseBlock::Name::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      sig do
+        override.returns(T::Array[Anthropic::BrowserToolUseBlock::Variants])
+      end
+      def self.variants
+      end
+
+      # Creates a new instance of the variant class whose `name` matches the given
+      # value, passing the remaining arguments to its constructor.
+      sig do
+        params(
+          name: Anthropic::BrowserToolUseBlock::Name::OrSymbol,
+          id: String,
+          caller_:
+            T.any(
+              Anthropic::DirectCaller::OrHash,
+              Anthropic::ServerToolCaller::OrHash,
+              Anthropic::ServerToolCaller20260120::OrHash
+            ),
+          input:
+            T.any(
+              Anthropic::BrowserNavigateInput::OrHash,
+              Anthropic::BrowserListTabsInput::OrHash,
+              Anthropic::BrowserNewTabInput::OrHash,
+              Anthropic::BrowserSwitchTabInput::OrHash,
+              Anthropic::BrowserCloseTabInput::OrHash,
+              Anthropic::BrowserReadPageInput::OrHash,
+              Anthropic::BrowserGetPageTextInput::OrHash,
+              Anthropic::BrowserReadConsoleInput::OrHash,
+              Anthropic::BrowserReadNetworkInput::OrHash,
+              Anthropic::BrowserFindInput::OrHash,
+              Anthropic::BrowserFormInputInput::OrHash,
+              Anthropic::BrowserFileUploadInput::OrHash,
+              Anthropic::BrowserScrollToInput::OrHash,
+              Anthropic::BrowserScreenshotInput::OrHash,
+              Anthropic::BrowserZoomInput::OrHash,
+              Anthropic::BrowserLeftClickInput::OrHash,
+              Anthropic::BrowserRightClickInput::OrHash,
+              Anthropic::BrowserMiddleClickInput::OrHash,
+              Anthropic::BrowserDoubleClickInput::OrHash,
+              Anthropic::BrowserTripleClickInput::OrHash,
+              Anthropic::BrowserHoverInput::OrHash,
+              Anthropic::BrowserLeftClickDragInput::OrHash,
+              Anthropic::BrowserLeftMouseDownInput::OrHash,
+              Anthropic::BrowserLeftMouseUpInput::OrHash,
+              Anthropic::BrowserMouseMoveInput::OrHash,
+              Anthropic::BrowserScrollInput::OrHash,
+              Anthropic::BrowserTypeInput::OrHash,
+              Anthropic::BrowserKeyInput::OrHash,
+              Anthropic::BrowserHoldKeyInput::OrHash,
+              Anthropic::BrowserWaitInput::OrHash,
+              Anthropic::BrowserJavascriptExecInput::OrHash
+            ),
+          toolset_name: Symbol,
+          type: Symbol
+        ).returns(Anthropic::BrowserToolUseBlock::Variants)
+      end
+      def self.new(
+        name:,
+        id:,
+        # Which party invoked the tool call: the model directly, or a server tool on its
+        # behalf.
+        caller_:,
+        # Navigate to a URL, or go back/forward/reload in history. The protocol may be
+        # omitted (defaults to https://).
+        input:,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_triple_click_input.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserTripleClickInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserTripleClickInput,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      # Where to act: either a viewport coordinate or an element reference.
+      sig { returns(Anthropic::BrowserClickTarget::Variants) }
+      attr_accessor :target
+
+      # Optional modifier key chord to hold for the duration of this action (e.g.
+      # "shift", "ctrl+shift", "cmd+alt").
+      sig { returns(T.nilable(String)) }
+      attr_accessor :modifiers
+
+      # Tab to act on. Defaults to the active tab when omitted.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tab_id
+
+      # Triple left-click at a viewport coordinate or on an element by reference
+      # (typically selects a line or paragraph).
+      sig do
+        params(
+          target:
+            T.any(
+              Anthropic::BrowserCoordinateTarget::OrHash,
+              Anthropic::BrowserRefTarget::OrHash
+            ),
+          modifiers: T.nilable(String),
+          tab_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Where to act: either a viewport coordinate or an element reference.
+        target:,
+        # Optional modifier key chord to hold for the duration of this action (e.g.
+        # "shift", "ctrl+shift", "cmd+alt").
+        modifiers: nil,
+        # Tab to act on. Defaults to the active tab when omitted.
+        tab_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            target: Anthropic::BrowserClickTarget::Variants,
+            modifiers: T.nilable(String),
+            tab_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_triple_click_tool_use_block.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserTripleClickToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserTripleClickToolUseBlock,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Which party invoked the tool call: the model directly, or a server tool on its
+      # behalf.
+      sig { returns(Anthropic::ToolUseCaller::Variants) }
+      attr_accessor :caller_
+
+      # Triple left-click at a viewport coordinate or on an element by reference
+      # (typically selects a line or paragraph).
+      sig { returns(Anthropic::BrowserTripleClickInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserTripleClickInput::OrHash).void }
+      attr_writer :input
+
+      sig { returns(Symbol) }
+      attr_accessor :name
+
+      sig { returns(Symbol) }
+      attr_accessor :toolset_name
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      sig do
+        params(
+          id: String,
+          caller_:
+            T.any(
+              Anthropic::DirectCaller::OrHash,
+              Anthropic::ServerToolCaller::OrHash,
+              Anthropic::ServerToolCaller20260120::OrHash
+            ),
+          input: Anthropic::BrowserTripleClickInput::OrHash,
+          name: Symbol,
+          toolset_name: Symbol,
+          type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        id:,
+        # Which party invoked the tool call: the model directly, or a server tool on its
+        # behalf.
+        caller_:,
+        # Triple left-click at a viewport coordinate or on an element by reference
+        # (typically selects a line or paragraph).
+        input:,
+        name: :triple_click,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserTripleClickInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_type_input.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserTypeInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::BrowserTypeInput, Anthropic::Internal::AnyHash)
+        end
+
+      # The text to type.
+      sig { returns(String) }
+      attr_accessor :text
+
+      # Tab to act on. Defaults to the active tab when omitted.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tab_id
+
+      # Type a literal string at the current focus.
+      sig do
+        params(text: String, tab_id: T.nilable(String)).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # The text to type.
+        text:,
+        # Tab to act on. Defaults to the active tab when omitted.
+        tab_id: nil
+      )
+      end
+
+      sig { override.returns({ text: String, tab_id: T.nilable(String) }) }
+      def to_hash
+      end
+    end
+  end
+end