anthropic 1.76.0 → 1.77.0

data/rbi/anthropic/models/computer_key_input.rbi

@@ -0,0 +1,42 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerKeyInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::ComputerKeyInput, Anthropic::Internal::AnyHash)
+        end
+
+      # The key or key-combination to press.
+      sig { returns(String) }
+      attr_accessor :text
+
+      # Number of times to repeat the key press. Default is 1.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :repeat
+
+      # Press a key or key-combination on the keyboard. Use "+" to combine modifiers
+      # with a key (e.g. "ctrl+s", "alt+Tab", "ctrl+shift+Escape"). Key names are
+      # case-insensitive; common names like "Return", "Tab", "Escape", "Up", "Down",
+      # "Left", "Right", "Home", "End", "Page_Up", "Page_Down", "Delete", "BackSpace"
+      # are supported.
+      sig do
+        params(text: String, repeat: T.nilable(Integer)).returns(
+          T.attached_class
+        )
+      end
+      def self.new(
+        # The key or key-combination to press.
+        text:,
+        # Number of times to repeat the key press. Default is 1.
+        repeat: nil
+      )
+      end
+
+      sig { override.returns({ text: String, repeat: T.nilable(Integer) }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_key_tool_use_block.rbi

@@ -0,0 +1,90 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerKeyToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerKeyToolUseBlock,
+            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-combination on the keyboard. Use "+" to combine modifiers
+      # with a key (e.g. "ctrl+s", "alt+Tab", "ctrl+shift+Escape"). Key names are
+      # case-insensitive; common names like "Return", "Tab", "Escape", "Up", "Down",
+      # "Left", "Right", "Home", "End", "Page_Up", "Page_Down", "Delete", "BackSpace"
+      # are supported.
+      sig { returns(Anthropic::ComputerKeyInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::ComputerKeyInput::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::ComputerKeyInput::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-combination on the keyboard. Use "+" to combine modifiers
+        # with a key (e.g. "ctrl+s", "alt+Tab", "ctrl+shift+Escape"). Key names are
+        # case-insensitive; common names like "Return", "Tab", "Escape", "Up", "Down",
+        # "Left", "Right", "Home", "End", "Page_Up", "Page_Down", "Delete", "BackSpace"
+        # are supported.
+        input:,
+        name: :key,
+        toolset_name: :computer,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::ComputerKeyInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_left_click_drag_input.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerLeftClickDragInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerLeftClickDragInput,
+            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
+
+      # (x, y): x pixels from the left edge, y pixels from the top edge.
+      sig { returns(T::Array[Integer]) }
+      attr_accessor :start_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 and drag the cursor from `start_coordinate` to `coordinate`.
+      sig do
+        params(
+          coordinate: T::Array[Integer],
+          start_coordinate: 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:,
+        # (x, y): x pixels from the left edge, y pixels from the top edge.
+        start_coordinate:,
+        # Optional key combination to hold down during this action (e.g. "ctrl", "shift",
+        # "ctrl+shift").
+        text: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            coordinate: T::Array[Integer],
+            start_coordinate: T::Array[Integer],
+            text: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_left_click_drag_tool_use_block.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerLeftClickDragToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerLeftClickDragToolUseBlock,
+            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 and drag the cursor from `start_coordinate` to `coordinate`.
+      sig { returns(Anthropic::ComputerLeftClickDragInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::ComputerLeftClickDragInput::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::ComputerLeftClickDragInput::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 and drag the cursor from `start_coordinate` to `coordinate`.
+        input:,
+        name: :left_click_drag,
+        toolset_name: :computer,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::ComputerLeftClickDragInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_left_click_input.rbi

@@ -0,0 +1,46 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerLeftClickInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Anthropic::ComputerLeftClickInput, 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 left 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_left_click_tool_use_block.rbi

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

data/rbi/anthropic/models/computer_left_mouse_down_input.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerLeftMouseDownInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerLeftMouseDownInput,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      # Press and hold the left mouse button at the current cursor position.
+      sig { returns(T.attached_class) }
+      def self.new
+      end
+
+      sig { override.returns({}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_left_mouse_down_tool_use_block.rbi

@@ -0,0 +1,82 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerLeftMouseDownToolUseBlock < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerLeftMouseDownToolUseBlock,
+            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 and hold the left mouse button at the current cursor position.
+      sig { returns(Anthropic::ComputerLeftMouseDownInput) }
+      attr_reader :input
+
+      sig { params(input: Anthropic::ComputerLeftMouseDownInput::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::ComputerLeftMouseDownInput::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 and hold the left mouse button at the current cursor position.
+        input:,
+        name: :left_mouse_down,
+        toolset_name: :computer,
+        type: :tool_use
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            id: String,
+            caller_: Anthropic::ToolUseCaller::Variants,
+            input: Anthropic::ComputerLeftMouseDownInput,
+            name: Symbol,
+            toolset_name: Symbol,
+            type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_left_mouse_up_input.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerLeftMouseUpInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerLeftMouseUpInput,
+            Anthropic::Internal::AnyHash
+          )
+        end
+
+      # Release the left mouse button.
+      sig { returns(T.attached_class) }
+      def self.new
+      end
+
+      sig { override.returns({}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/anthropic/models/computer_left_mouse_up_tool_use_block.rbi

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

data/rbi/anthropic/models/computer_middle_click_input.rbi

@@ -0,0 +1,49 @@
+# typed: strong
+
+module Anthropic
+  module Models
+    class ComputerMiddleClickInput < Anthropic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Anthropic::ComputerMiddleClickInput,
+            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 middle 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