anthropic 1.76.0 → 1.77.1

data/rbi/anthropic/models/computer_middle_click_tool_use_block.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerMiddleClickToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerMiddleClickToolUseBlock,
+            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_
+
+      # Click the middle mouse button at the specified (x, y) pixel coordinate, or the
+      # current cursor position if `coordinate` is omitted.
+      sig { returns(Anthropic::ComputerMiddleClickInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::ComputerMiddleClickInput::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::ComputerMiddleClickInput::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_:,
+        # Click the middle mouse button at the specified (x, y) pixel coordinate, or the
+        # current cursor position if `coordinate` is omitted.
+        input:,
+        name: :middle_click,
+        toolset_name: :computer,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::ComputerMiddleClickInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_mouse_move_input.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerMouseMoveInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::ComputerMouseMoveInput, Anthropic::Internal::AnyHash)
+        end
+
+      # (x, y): x pixels from the left edge, y pixels from the top edge.
+      sig { returns(T::Array[Integer]) }
+      attr_accessor :coordinate
+
+      # Move the cursor to a specified (x, y) pixel coordinate. Use this ONLY to hover
+      # without clicking; otherwise use a click action directly.
+      sig { params(coordinate: T::Array[Integer]).returns(T.attached_class) }
+      def self.new(
+        # (x, y): x pixels from the left edge, y pixels from the top edge.
+        coordinate:
+      )
+      end
+
+      sig { override.returns({ coordinate: T::Array[Integer] }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_mouse_move_tool_use_block.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerMouseMoveToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerMouseMoveToolUseBlock,
+            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 specified (x, y) pixel coordinate. Use this ONLY to hover
+      # without clicking; otherwise use a click action directly.
+      sig { returns(Anthropic::ComputerMouseMoveInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::ComputerMouseMoveInput::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::ComputerMouseMoveInput::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 specified (x, y) pixel coordinate. Use this ONLY to hover
+        # without clicking; otherwise use a click action directly.
+        input:,
+        name: :mouse_move,
+        toolset_name: :computer,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::ComputerMouseMoveInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_right_click_input.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerRightClickInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerRightClickInput,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      # (x, y): x pixels from the left edge, y pixels from the top edge.
+      sig { returns(T.nilable(T::Array[Integer])) }
+      attr_accessor :coordinate
+
+      # Optional key combination to hold down during this action (e.g. "ctrl", "shift",
+      # "ctrl+shift").
+      sig { returns(T.nilable(String)) }
+      attr_accessor :text
+
+      # Click the right mouse button at the specified (x, y) pixel coordinate, or the
+      # current cursor position if `coordinate` is omitted.
+      sig do
+        params(
+          coordinate: T.nilable(T::Array[Integer]),
+          text: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # (x, y): x pixels from the left edge, y pixels from the top edge.
+        coordinate: nil,
+        # Optional key combination to hold down during this action (e.g. "ctrl", "shift",
+        # "ctrl+shift").
+        text: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          { coordinate: T.nilable(T::Array[Integer]), text: T.nilable(String) }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_right_click_tool_use_block.rbi

@@ -0,0 +1,84 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerRightClickToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerRightClickToolUseBlock,
+            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_
+
+      # Click the right mouse button at the specified (x, y) pixel coordinate, or the
+      # current cursor position if `coordinate` is omitted.
+      sig { returns(Anthropic::ComputerRightClickInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::ComputerRightClickInput::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::ComputerRightClickInput::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_:,
+        # Click the right mouse button at the specified (x, y) pixel coordinate, or the
+        # current cursor position if `coordinate` is omitted.
+        input:,
+        name: :right_click,
+        toolset_name: :computer,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::ComputerRightClickInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_screenshot_input.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerScreenshotInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerScreenshotInput,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      # Take a screenshot of the screen.
+      sig { returns(T.attached_class) }
+      def self.new
+      end
+
+      sig { override.returns({}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_screenshot_tool_use_block.rbi

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

data/rbi/anthropic/models/computer_scroll_direction.rbi

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

data/rbi/anthropic/models/computer_scroll_input.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerScrollInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::ComputerScrollInput, Anthropic::Internal::AnyHash)
+        end
+
+      # Number of 'clicks' of the scroll wheel.
+      sig { returns(Integer) }
+      attr_accessor :scroll_amount
+
+      sig { returns(Anthropic::ComputerScrollDirection::TaggedSymbol) }
+      attr_accessor :scroll_direction
+
+      # (x, y): x pixels from the left edge, y pixels from the top edge.
+      sig { returns(T.nilable(T::Array[Integer])) }
+      attr_accessor :coordinate
+
+      # Optional key combination to hold down during this action (e.g. "ctrl", "shift",
+      # "ctrl+shift").
+      sig { returns(T.nilable(String)) }
+      attr_accessor :text
+
+      # Scroll the screen at the specified (x, y) pixel coordinate, or the current
+      # cursor position if `coordinate` is omitted. Do NOT use PageUp/PageDown to
+      # scroll.
+      sig do
+        params(
+          scroll_amount: Integer,
+          scroll_direction: Anthropic::ComputerScrollDirection::OrSymbol,
+          coordinate: T.nilable(T::Array[Integer]),
+          text: T.nilable(String)
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Number of 'clicks' of the scroll wheel.
+        scroll_amount:,
+        scroll_direction:,
+        # (x, y): x pixels from the left edge, y pixels from the top edge.
+        coordinate: nil,
+        # Optional key combination to hold down during this action (e.g. "ctrl", "shift",
+        # "ctrl+shift").
+        text: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            scroll_amount: Integer,
+            scroll_direction: Anthropic::ComputerScrollDirection::TaggedSymbol,
+            coordinate: T.nilable(T::Array[Integer]),
+            text: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_scroll_tool_use_block.rbi

@@ -0,0 +1,86 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerScrollToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerScrollToolUseBlock,
+            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 the screen at the specified (x, y) pixel coordinate, or the current
+      # cursor position if `coordinate` is omitted. Do NOT use PageUp/PageDown to
+      # scroll.
+      sig { returns(Anthropic::ComputerScrollInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::ComputerScrollInput::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::ComputerScrollInput::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 the screen at the specified (x, y) pixel coordinate, or the current
+        # cursor position if `coordinate` is omitted. Do NOT use PageUp/PageDown to
+        # scroll.
+        input:,
+        name: :scroll,
+        toolset_name: :computer,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::ComputerScrollInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end