anthropic 1.75.0 → 1.77.0

data/rbi/anthropic/models/browser_get_page_text_tool_use_block.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserGetPageTextToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserGetPageTextToolUseBlock,
+            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 page's visible text content as plain text, prioritizing article
+      # content. Suited to articles, documentation, and other text-heavy pages.
+      sig { returns(Anthropic::BrowserGetPageTextInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserGetPageTextInput::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::BrowserGetPageTextInput::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 page's visible text content as plain text, prioritizing article
+        # content. Suited to articles, documentation, and other text-heavy pages.
+        input:,
+        name: :get_page_text,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserGetPageTextInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_hold_key_input.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserHoldKeyInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::BrowserHoldKeyInput, Anthropic::Internal::AnyHash)
+        end
+
+      # Seconds to hold the key down (maximum 30).
+      sig { returns(Float) }
+      attr_accessor :duration
+
+      # The key or chord to hold.
+      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
+
+      # Hold a key or key chord down for a duration, then release it. Uses the same key
+      # names and "+" chord syntax as the key action.
+      sig do
+        params(
+          duration: Float,
+          text: String,
+          tab_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Seconds to hold the key down (maximum 30).
+        duration:,
+        # The key or chord to hold.
+        text:,
+        # Tab to act on. Defaults to the active tab when omitted.
+        tab_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { duration: Float, text: String, tab_id: T.nilable(String) }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_hold_key_tool_use_block.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserHoldKeyToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserHoldKeyToolUseBlock,
+            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_
+
+      # Hold a key or key chord down for a duration, then release it. Uses the same key
+      # names and "+" chord syntax as the key action.
+      sig { returns(Anthropic::BrowserHoldKeyInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserHoldKeyInput::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::BrowserHoldKeyInput::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_:,
+        # Hold a key or key chord down for a duration, then release it. Uses the same key
+        # names and "+" chord syntax as the key action.
+        input:,
+        name: :hold_key,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserHoldKeyInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_hover_input.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserHoverInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::BrowserHoverInput, Anthropic::Internal::AnyHash)
+        end
+
+      # Where to act: either a viewport coordinate or an element reference.
+      sig { returns(Anthropic::BrowserClickTarget::Variants) }
+      attr_accessor :target
+
+      # Tab to act on. Defaults to the active tab when omitted.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tab_id
+
+      # Move the cursor to a coordinate or element without clicking.
+      sig do
+        params(
+          target:
+            T.any(
+              Anthropic::BrowserCoordinateTarget::OrHash,
+              Anthropic::BrowserRefTarget::OrHash
+            ),
+          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:,
+        # Tab to act on. Defaults to the active tab when omitted.
+        tab_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            target: Anthropic::BrowserClickTarget::Variants,
+            tab_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_hover_tool_use_block.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserHoverToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserHoverToolUseBlock,
+            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_
+
+      # Move the cursor to a coordinate or element without clicking.
+      sig { returns(Anthropic::BrowserHoverInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserHoverInput::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::BrowserHoverInput::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_:,
+        # Move the cursor to a coordinate or element without clicking.
+        input:,
+        name: :hover,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserHoverInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_javascript_exec_input.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserJavascriptExecInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserJavascriptExecInput,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      # JavaScript to execute in the page context.
+      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
+
+      # Execute JavaScript in the page context and return the value of the last
+      # expression. The code runs with access to the DOM, `window`, and page variables.
+      # Write the expression you want evaluated — do NOT use `return`.
+      sig do
+        params(text: String, tab_id: T.nilable(String)).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # JavaScript to execute in the page context.
+        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

data/rbi/anthropic/models/browser_javascript_exec_tool_use_block.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserJavascriptExecToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserJavascriptExecToolUseBlock,
+            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_
+
+      # Execute JavaScript in the page context and return the value of the last
+      # expression. The code runs with access to the DOM, `window`, and page variables.
+      # Write the expression you want evaluated — do NOT use `return`.
+      sig { returns(Anthropic::BrowserJavascriptExecInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserJavascriptExecInput::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::BrowserJavascriptExecInput::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_:,
+        # Execute JavaScript in the page context and return the value of the last
+        # expression. The code runs with access to the DOM, `window`, and page variables.
+        # Write the expression you want evaluated — do NOT use `return`.
+        input:,
+        name: :javascript_exec,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserJavascriptExecInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_key_input.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserKeyInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::BrowserKeyInput, Anthropic::Internal::AnyHash)
+        end
+
+      # The key, chord, or space-separated sequence to press.
+      sig { returns(String) }
+      attr_accessor :text
+
+      # Number of times to repeat. Default 1.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :repeat
+
+      # Tab to act on. Defaults to the active tab when omitted.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tab_id
+
+      # Press a key or key chord. Use "+" to combine modifiers with a key (e.g.
+      # "ctrl+a", "cmd+shift+p") and space to sequence presses (e.g. "Backspace
+      # Backspace Delete"). Common names like "Return", "Tab", "Escape", "BackSpace" are
+      # supported.
+      sig do
+        params(
+          text: String,
+          repeat: T.nilable(Integer),
+          tab_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The key, chord, or space-separated sequence to press.
+        text:,
+        # Number of times to repeat. Default 1.
+        repeat: nil,
+        # Tab to act on. Defaults to the active tab when omitted.
+        tab_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            text: String,
+            repeat: T.nilable(Integer),
+            tab_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_key_tool_use_block.rbi

@@ -0,0 +1,85 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserKeyToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::BrowserKeyToolUseBlock, 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_
+
+      # Press a key or key chord. Use "+" to combine modifiers with a key (e.g.
+      # "ctrl+a", "cmd+shift+p") and space to sequence presses (e.g. "Backspace
+      # Backspace Delete"). Common names like "Return", "Tab", "Escape", "BackSpace" are
+      # supported.
+      sig { returns(Anthropic::BrowserKeyInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::BrowserKeyInput::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::BrowserKeyInput::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_:,
+        # Press a key or key chord. Use "+" to combine modifiers with a key (e.g.
+        # "ctrl+a", "cmd+shift+p") and space to sequence presses (e.g. "Backspace
+        # Backspace Delete"). Common names like "Return", "Tab", "Escape", "BackSpace" are
+        # supported.
+        input:,
+        name: :key,
+        toolset_name: :browser,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::BrowserKeyInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/browser_left_click_drag_input.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class BrowserLeftClickDragInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::BrowserLeftClickDragInput,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      # A point in the browser viewport, in viewport pixels (the same frame as a
+      # full-viewport screenshot).
+      sig { returns(Anthropic::BrowserCoordinateTarget) }
+      attr_reader :from
+
+      sig { params(from: Anthropic::BrowserCoordinateTarget::OrHash).void }
+      attr_writer :from
+
+      # 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
+
+      # Tab to act on. Defaults to the active tab when omitted.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tab_id
+
+      # Press at `from`, drag to `target`, release. Both must be coordinate targets.
+      sig do
+        params(
+          from: Anthropic::BrowserCoordinateTarget::OrHash,
+          target: Anthropic::BrowserCoordinateTarget::OrHash,
+          tab_id: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # A point in the browser viewport, in viewport pixels (the same frame as a
+        # full-viewport screenshot).
+        from:,
+        # A point in the browser viewport, in viewport pixels (the same frame as a
+        # full-viewport screenshot).
+        target:,
+        # Tab to act on. Defaults to the active tab when omitted.
+        tab_id: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            from: Anthropic::BrowserCoordinateTarget,
+            target: Anthropic::BrowserCoordinateTarget,
+            tab_id: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end