anthropic 1.76.0 → 1.77.0

data/rbi/anthropic/models/browser_read_network_tool_use_block.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserReadNetworkToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserReadNetworkToolUseBlock,
+            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_
+
+      # Return the network requests (method, URL, status, MIME type, timing) recorded
+      # since the driver attached to the tab and since the last read, one line per
+      # entry. An empty result does not mean no traffic for a tab that predates attach.
+      sig { returns(Anthropic::BrowserReadNetworkInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserReadNetworkInput::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::BrowserReadNetworkInput::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_:,
+        # Return the network requests (method, URL, status, MIME type, timing) recorded
+        # since the driver attached to the tab and since the last read, one line per
+        # entry. An empty result does not mean no traffic for a tab that predates attach.
+        input:,
+        name: :read_network,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserReadNetworkInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_read_page_filter.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module BrowserReadPageFilter
+      extend Anthropic::Internal::Type::Enum
+
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, Anthropic::BrowserReadPageFilter) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      ALL = T.let(:all, Anthropic::BrowserReadPageFilter::TaggedSymbol)
+      INTERACTIVE =
+        T.let(:interactive, Anthropic::BrowserReadPageFilter::TaggedSymbol)
+
+      sig do
+        override.returns(
+          T::Array[Anthropic::BrowserReadPageFilter::TaggedSymbol]
+        )
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_read_page_input.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserReadPageInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::BrowserReadPageInput, Anthropic::Internal::AnyHash)
+        end
+
+      # Maximum tree depth. Default 15.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :depth
+
+      # Which elements to include. Omitted: every visible element. "interactive":
+      # interactive elements only. "all": additionally includes off-viewport elements.
+      sig { returns(T.nilable(Anthropic::BrowserReadPageFilter::TaggedSymbol)) }
+      attr_accessor :filter
+
+      # Element reference to read a subtree from. Omit to read from the page root.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :ref
+
+      # Tab to act on. Defaults to the active tab when omitted.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tab_id
+
+      # Return a structured accessibility tree of the page (or the subtree rooted at
+      # `ref`), with element references like [ref_7] that can be used as targets on
+      # later actions. Output is capped at 50,000 characters — narrow with `ref` or a
+      # smaller `depth` when exceeded.
+      sig do
+        params(
+          depth: T.nilable(Integer),
+          filter: T.nilable(Anthropic::BrowserReadPageFilter::OrSymbol),
+          ref: T.nilable(String),
+          tab_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Maximum tree depth. Default 15.
+        depth: nil,
+        # Which elements to include. Omitted: every visible element. "interactive":
+        # interactive elements only. "all": additionally includes off-viewport elements.
+        filter: nil,
+        # Element reference to read a subtree from. Omit to read from the page root.
+        ref: nil,
+        # Tab to act on. Defaults to the active tab when omitted.
+        tab_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            depth: T.nilable(Integer),
+            filter: T.nilable(Anthropic::BrowserReadPageFilter::TaggedSymbol),
+            ref: T.nilable(String),
+            tab_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_read_page_tool_use_block.rbi

@@ -0,0 +1,88 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserReadPageToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserReadPageToolUseBlock,
+            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_
+
+      # Return a structured accessibility tree of the page (or the subtree rooted at
+      # `ref`), with element references like [ref_7] that can be used as targets on
+      # later actions. Output is capped at 50,000 characters — narrow with `ref` or a
+      # smaller `depth` when exceeded.
+      sig { returns(Anthropic::BrowserReadPageInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserReadPageInput::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::BrowserReadPageInput::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_:,
+        # Return a structured accessibility tree of the page (or the subtree rooted at
+        # `ref`), with element references like [ref_7] that can be used as targets on
+        # later actions. Output is capped at 50,000 characters — narrow with `ref` or a
+        # smaller `depth` when exceeded.
+        input:,
+        name: :read_page,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserReadPageInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_ref_target.rbi

@@ -0,0 +1,36 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserRefTarget < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::BrowserRefTarget, Anthropic::Internal::AnyHash)
+        end
+
+      # An element reference (e.g. "ref_7") returned by a prior `read_page` or `find`
+      # result.
+      sig { returns(String) }
+      attr_accessor :ref
+
+      sig { returns(Symbol) }
+      attr_accessor :type
+
+      # An element on the page, identified by a reference from a prior `read_page` or
+      # `find` result. References are scoped to the tab that produced them and become
+      # stale after navigation or a major re-render.
+      sig { params(ref: String, type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # An element reference (e.g. "ref_7") returned by a prior `read_page` or `find`
+        # result.
+        ref:,
+        type: :ref
+      )
+      end
+
+      sig { override.returns({ ref: String, type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_right_click_input.rbi

@@ -0,0 +1,60 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserRightClickInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::BrowserRightClickInput, 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
+
+      # Right-click at a viewport coordinate or on an element by reference.
+      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_right_click_tool_use_block.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserRightClickToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserRightClickToolUseBlock,
+            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_
+
+      # Right-click at a viewport coordinate or on an element by reference.
+      sig { returns(Anthropic::BrowserRightClickInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserRightClickInput::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::BrowserRightClickInput::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_:,
+        # Right-click at a viewport coordinate or on an element by reference.
+        input:,
+        name: :right_click,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserRightClickInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_screenshot_input.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserScreenshotInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::BrowserScreenshotInput, Anthropic::Internal::AnyHash)
+        end
+
+      # Tab to act on. Defaults to the active tab when omitted.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tab_id
+
+      # Capture the current browser viewport.
+      sig { params(tab_id: T.nilable(String)).returns(T.attached_class) }
+      def self.new(
+        # Tab to act on. Defaults to the active tab when omitted.
+        tab_id: nil
+      )
+      end
+
+      sig { override.returns({ tab_id: T.nilable(String) }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_screenshot_tool_use_block.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserScreenshotToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserScreenshotToolUseBlock,
+            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_
+
+      # Capture the current browser viewport.
+      sig { returns(Anthropic::BrowserScreenshotInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserScreenshotInput::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::BrowserScreenshotInput::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_:,
+        # Capture the current browser viewport.
+        input:,
+        name: :screenshot,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserScreenshotInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_scroll_direction.rbi

@@ -0,0 +1,26 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    module BrowserScrollDirection
+      extend Anthropic::Internal::Type::Enum
+
+      TaggedSymbol =
+        T.type_alias { T.all(Symbol, Anthropic::BrowserScrollDirection) }
+      OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+      UP = T.let(:up, Anthropic::BrowserScrollDirection::TaggedSymbol)
+      DOWN = T.let(:down, Anthropic::BrowserScrollDirection::TaggedSymbol)
+      LEFT = T.let(:left, Anthropic::BrowserScrollDirection::TaggedSymbol)
+      RIGHT = T.let(:right, Anthropic::BrowserScrollDirection::TaggedSymbol)
+
+      sig do
+        override.returns(
+          T::Array[Anthropic::BrowserScrollDirection::TaggedSymbol]
+        )
+      end
+      def self.values
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_scroll_input.rbi

@@ -0,0 +1,65 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserScrollInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::BrowserScrollInput, Anthropic::Internal::AnyHash)
+        end
+
+      sig { returns(Anthropic::BrowserScrollDirection::TaggedSymbol) }
+      attr_accessor :scroll_direction
+
+      # A point in the browser viewport, in viewport pixels (the same frame as a
+      # full-viewport screenshot).
+      sig { returns(Anthropic::BrowserCoordinateTarget) }
+      attr_reader :target
+
+      sig { params(target: Anthropic::BrowserCoordinateTarget::OrHash).void }
+      attr_writer :target
+
+      # Scroll-wheel notches (1–10). Default 3.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :scroll_amount
+
+      # Tab to act on. Defaults to the active tab when omitted.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tab_id
+
+      # Scroll at a viewport position. `target` must be a coordinate target.
+      sig do
+        params(
+          scroll_direction: Anthropic::BrowserScrollDirection::OrSymbol,
+          target: Anthropic::BrowserCoordinateTarget::OrHash,
+          scroll_amount: T.nilable(Integer),
+          tab_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        scroll_direction:,
+        # A point in the browser viewport, in viewport pixels (the same frame as a
+        # full-viewport screenshot).
+        target:,
+        # Scroll-wheel notches (1–10). Default 3.
+        scroll_amount: nil,
+        # Tab to act on. Defaults to the active tab when omitted.
+        tab_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            scroll_direction: Anthropic::BrowserScrollDirection::TaggedSymbol,
+            target: Anthropic::BrowserCoordinateTarget,
+            scroll_amount: T.nilable(Integer),
+            tab_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_scroll_to_input.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserScrollToInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::BrowserScrollToInput, Anthropic::Internal::AnyHash)
+        end
+
+      # An element on the page, identified by a reference from a prior `read_page` or
+      # `find` result. References are scoped to the tab that produced them and become
+      # stale after navigation or a major re-render.
+      sig { returns(Anthropic::BrowserRefTarget) }
+      attr_reader :target
+
+      sig { params(target: Anthropic::BrowserRefTarget::OrHash).void }
+      attr_writer :target
+
+      # Tab to act on. Defaults to the active tab when omitted.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tab_id
+
+      # Scroll an element into view.
+      sig do
+        params(
+          target: Anthropic::BrowserRefTarget::OrHash,
+          tab_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # An element on the page, identified by a reference from a prior `read_page` or
+        # `find` result. References are scoped to the tab that produced them and become
+        # stale after navigation or a major re-render.
+        target:,
+        # Tab to act on. Defaults to the active tab when omitted.
+        tab_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { target: Anthropic::BrowserRefTarget, tab_id: T.nilable(String) }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end