stagehand 0.0.4 → 3.6.0

data/sig/stagehand/internal/type/unknown.rbs

@@ -0,0 +1,26 @@
+module Stagehand
+  module Internal
+    module Type
+      class Unknown
+        extend Stagehand::Internal::Type::Converter
+        extend Stagehand::Internal::Util::SorbetRuntimeSupport
+
+        def self.===: (top other) -> bool
+
+        def self.==: (top other) -> bool
+
+        def self.coerce: (
+          top value,
+          state: Stagehand::Internal::Type::Converter::coerce_state
+        ) -> top
+
+        def self.dump: (
+          top value,
+          state: Stagehand::Internal::Type::Converter::dump_state
+        ) -> top
+
+        def self.to_sorbet_type: -> top
+      end
+    end
+  end
+end

data/sig/stagehand/internal/util.rbs

@@ -0,0 +1,185 @@
+module Stagehand
+  module Internal
+    module Util
+      extend Stagehand::Internal::Util::SorbetRuntimeSupport
+
+      def self?.monotonic_secs: -> Float
+
+      def self?.walk_namespaces: (
+        Module | Class ns
+      ) -> Enumerable[(Module | Class)]
+
+      def self?.arch: -> String
+
+      def self?.os: -> String
+
+      def self?.primitive?: (top input) -> bool
+
+      def self?.coerce_boolean: (String | bool input) -> (bool | top)
+
+      def self?.coerce_boolean!: (String | bool input) -> bool?
+
+      def self?.coerce_integer: (String | Integer input) -> (Integer | top)
+
+      def self?.coerce_float: (String | Integer | Float input) -> (Float | top)
+
+      def self?.coerce_hash: (top input) -> (::Hash[top, top] | top)
+
+      def self?.coerce_hash!: (top input) -> ::Hash[top, top]?
+
+      def self?.deep_merge_lr: (top lhs, top rhs, ?concat: bool) -> top
+
+      def self?.deep_merge: (
+        *::Array[top] values,
+        ?sentinel: top?,
+        ?concat: bool
+      ) -> top
+
+      def self?.dig: (
+        ::Hash[Symbol, top] | ::Array[top] | top data,
+        (Symbol
+        | Integer
+        | ::Array[(Symbol | Integer)]
+        | (^(top arg0) -> top))? pick
+      ) {
+        -> top?
+      } -> top?
+
+      def self?.uri_origin: (URI::Generic uri) -> String
+
+      def self?.interpolate_path: (String | ::Array[String] path) -> String
+
+      def self?.decode_query: (String? query) -> ::Hash[String, ::Array[String]]
+
+      def self?.encode_query: (
+        ::Hash[String, (::Array[String] | String)?]? query
+      ) -> String?
+
+      type parsed_uri =
+        {
+          scheme: String?,
+          host: String?,
+          port: Integer?,
+          path: String?,
+          query: ::Hash[String, ::Array[String]]
+        }
+
+      def self?.parse_uri: (
+        URI::Generic | String url
+      ) -> Stagehand::Internal::Util::parsed_uri
+
+      def self?.unparse_uri: (
+        Stagehand::Internal::Util::parsed_uri parsed
+      ) -> URI::Generic
+
+      def self?.join_parsed_uri: (
+        Stagehand::Internal::Util::parsed_uri lhs,
+        Stagehand::Internal::Util::parsed_uri rhs
+      ) -> URI::Generic
+
+      def self?.normalized_headers: (
+        *::Hash[String, (String
+        | Integer
+        | ::Array[(String | Integer)?])?] headers
+      ) -> ::Hash[String, String]
+
+      class ReadIOAdapter
+        def close?: -> bool?
+
+        def close: -> void
+
+        private def read_enum: (Integer? max_len) -> String
+
+        def read: (?Integer? max_len, ?String? out_string) -> String?
+
+        def initialize: (
+          String | Pathname | StringIO | Enumerable[String] src
+        ) {
+          (String arg0) -> void
+        } -> void
+      end
+
+      def self?.writable_enum: {
+        (Enumerator::Yielder y) -> void
+      } -> Enumerable[String]
+
+      JSON_CONTENT: Regexp
+      JSONL_CONTENT: Regexp
+
+      def self?.write_multipart_content: (
+        Enumerator::Yielder y,
+        val: top,
+        closing: ::Array[^-> void],
+        ?content_type: String?
+      ) -> void
+
+      def self?.write_multipart_chunk: (
+        Enumerator::Yielder y,
+        boundary: String,
+        key: Symbol | String,
+        val: top,
+        closing: ::Array[^-> void]
+      ) -> void
+
+      def self?.encode_multipart_streaming: (
+        top body
+      ) -> [String, Enumerable[String]]
+
+      def self?.encode_content: (
+        ::Hash[String, String] headers,
+        top body
+      ) -> top
+
+      def self?.force_charset!: (String content_type, text: String) -> void
+
+      def self?.decode_content: (
+        ::Hash[String, String] headers,
+        stream: Enumerable[String],
+        ?suppress_error: bool
+      ) -> top
+
+      def self?.fused_enum: (
+        Enumerable[top] enum,
+        ?external: bool
+      ) {
+        -> void
+      } -> Enumerable[top]
+
+      def self?.close_fused!: (Enumerable[top]? enum) -> void
+
+      def self?.chain_fused: (
+        Enumerable[top]? enum
+      ) {
+        (Enumerator::Yielder arg0) -> void
+      } -> Enumerable[top]
+
+      type server_sent_event =
+        { event: String?, data: String?, id: String?, retry: Integer? }
+
+      def self?.decode_lines: (Enumerable[String] enum) -> Enumerable[String]
+
+      def self?.decode_sse: (
+        Enumerable[String] lines
+      ) -> Enumerable[Stagehand::Internal::Util::server_sent_event]
+
+      module SorbetRuntimeSupport
+        class MissingSorbetRuntimeError < ::RuntimeError
+        end
+
+        private def sorbet_runtime_constants: -> ::Hash[Symbol, top]
+
+        def const_missing: (Symbol name) -> void
+
+        def sorbet_constant_defined?: (Symbol name) -> bool
+
+        def define_sorbet_constant!: (Symbol name) { -> top } -> void
+
+        def to_sorbet_type: -> top
+
+        def self.to_sorbet_type: (
+          Stagehand::Internal::Util::SorbetRuntimeSupport | top `type`
+        ) -> top
+      end
+    end
+  end
+end

data/sig/stagehand/internal.rbs

@@ -0,0 +1,9 @@
+module Stagehand
+  module Internal
+    extend Stagehand::Internal::Util::SorbetRuntimeSupport
+
+    type file_input = Pathname | StringIO | IO | String | Stagehand::FilePart
+
+    OMIT: Object
+  end
+end

data/sig/stagehand/models/action.rbs

@@ -0,0 +1,46 @@
+module Stagehand
+  module Models
+    type action =
+      {
+        description: String,
+        selector: String,
+        arguments: ::Array[String],
+        backend_node_id: Float,
+        method_: String
+      }
+
+    class Action < Stagehand::Internal::Type::BaseModel
+      attr_accessor description: String
+
+      attr_accessor selector: String
+
+      attr_reader arguments: ::Array[String]?
+
+      def arguments=: (::Array[String]) -> ::Array[String]
+
+      attr_reader backend_node_id: Float?
+
+      def backend_node_id=: (Float) -> Float
+
+      attr_reader method_: String?
+
+      def method_=: (String) -> String
+
+      def initialize: (
+        description: String,
+        selector: String,
+        ?arguments: ::Array[String],
+        ?backend_node_id: Float,
+        ?method_: String
+      ) -> void
+
+      def to_hash: -> {
+        description: String,
+        selector: String,
+        arguments: ::Array[String],
+        backend_node_id: Float,
+        method_: String
+      }
+    end
+  end
+end

data/sig/stagehand/models/model_config.rbs

@@ -0,0 +1,56 @@
+module Stagehand
+  module Models
+    type model_config =
+      {
+        model_name: String,
+        api_key: String,
+        base_url: String,
+        provider: Stagehand::Models::ModelConfig::provider
+      }
+
+    class ModelConfig < Stagehand::Internal::Type::BaseModel
+      attr_accessor model_name: String
+
+      attr_reader api_key: String?
+
+      def api_key=: (String) -> String
+
+      attr_reader base_url: String?
+
+      def base_url=: (String) -> String
+
+      attr_reader provider: Stagehand::Models::ModelConfig::provider?
+
+      def provider=: (
+        Stagehand::Models::ModelConfig::provider
+      ) -> Stagehand::Models::ModelConfig::provider
+
+      def initialize: (
+        model_name: String,
+        ?api_key: String,
+        ?base_url: String,
+        ?provider: Stagehand::Models::ModelConfig::provider
+      ) -> void
+
+      def to_hash: -> {
+        model_name: String,
+        api_key: String,
+        base_url: String,
+        provider: Stagehand::Models::ModelConfig::provider
+      }
+
+      type provider = :openai | :anthropic | :google | :microsoft
+
+      module Provider
+        extend Stagehand::Internal::Type::Enum
+
+        OPENAI: :openai
+        ANTHROPIC: :anthropic
+        GOOGLE: :google
+        MICROSOFT: :microsoft
+
+        def self?.values: -> ::Array[Stagehand::Models::ModelConfig::provider]
+      end
+    end
+  end
+end

data/sig/stagehand/models/session_act_params.rbs

@@ -0,0 +1,111 @@
+module Stagehand
+  module Models
+    type session_act_params =
+      {
+        input: Stagehand::Models::SessionActParams::input,
+        frame_id: String?,
+        options: Stagehand::SessionActParams::Options,
+        x_stream_response: Stagehand::Models::SessionActParams::x_stream_response
+      }
+      & Stagehand::Internal::Type::request_parameters
+
+    class SessionActParams < Stagehand::Internal::Type::BaseModel
+      extend Stagehand::Internal::Type::RequestParameters::Converter
+      include Stagehand::Internal::Type::RequestParameters
+
+      attr_accessor input: Stagehand::Models::SessionActParams::input
+
+      attr_accessor frame_id: String?
+
+      attr_reader options: Stagehand::SessionActParams::Options?
+
+      def options=: (
+        Stagehand::SessionActParams::Options
+      ) -> Stagehand::SessionActParams::Options
+
+      attr_reader x_stream_response: Stagehand::Models::SessionActParams::x_stream_response?
+
+      def x_stream_response=: (
+        Stagehand::Models::SessionActParams::x_stream_response
+      ) -> Stagehand::Models::SessionActParams::x_stream_response
+
+      def initialize: (
+        input: Stagehand::Models::SessionActParams::input,
+        ?frame_id: String?,
+        ?options: Stagehand::SessionActParams::Options,
+        ?x_stream_response: Stagehand::Models::SessionActParams::x_stream_response,
+        ?request_options: Stagehand::request_opts
+      ) -> void
+
+      def to_hash: -> {
+        input: Stagehand::Models::SessionActParams::input,
+        frame_id: String?,
+        options: Stagehand::SessionActParams::Options,
+        x_stream_response: Stagehand::Models::SessionActParams::x_stream_response,
+        request_options: Stagehand::RequestOptions
+      }
+
+      type input = String | Stagehand::Action
+
+      module Input
+        extend Stagehand::Internal::Type::Union
+
+        def self?.variants: -> ::Array[Stagehand::Models::SessionActParams::input]
+      end
+
+      type options =
+        {
+          model: Stagehand::Models::SessionActParams::Options::model,
+          timeout: Float,
+          variables: ::Hash[Symbol, String]
+        }
+
+      class Options < Stagehand::Internal::Type::BaseModel
+        attr_reader model: Stagehand::Models::SessionActParams::Options::model?
+
+        def model=: (
+          Stagehand::Models::SessionActParams::Options::model
+        ) -> Stagehand::Models::SessionActParams::Options::model
+
+        attr_reader timeout: Float?
+
+        def timeout=: (Float) -> Float
+
+        attr_reader variables: ::Hash[Symbol, String]?
+
+        def variables=: (::Hash[Symbol, String]) -> ::Hash[Symbol, String]
+
+        def initialize: (
+          ?model: Stagehand::Models::SessionActParams::Options::model,
+          ?timeout: Float,
+          ?variables: ::Hash[Symbol, String]
+        ) -> void
+
+        def to_hash: -> {
+          model: Stagehand::Models::SessionActParams::Options::model,
+          timeout: Float,
+          variables: ::Hash[Symbol, String]
+        }
+
+        type model = Stagehand::ModelConfig | String
+
+        module Model
+          extend Stagehand::Internal::Type::Union
+
+          def self?.variants: -> ::Array[Stagehand::Models::SessionActParams::Options::model]
+        end
+      end
+
+      type x_stream_response = :true | :false
+
+      module XStreamResponse
+        extend Stagehand::Internal::Type::Enum
+
+        TRUE: :true
+        FALSE: :false
+
+        def self?.values: -> ::Array[Stagehand::Models::SessionActParams::x_stream_response]
+      end
+    end
+  end
+end

data/sig/stagehand/models/session_act_response.rbs

@@ -0,0 +1,121 @@
+module Stagehand
+  module Models
+    type session_act_response =
+      { data: Stagehand::Models::SessionActResponse::Data, success: bool }
+
+    class SessionActResponse < Stagehand::Internal::Type::BaseModel
+      attr_accessor data: Stagehand::Models::SessionActResponse::Data
+
+      attr_accessor success: bool
+
+      def initialize: (
+        data: Stagehand::Models::SessionActResponse::Data,
+        success: bool
+      ) -> void
+
+      def to_hash: -> {
+        data: Stagehand::Models::SessionActResponse::Data,
+        success: bool
+      }
+
+      type data =
+        {
+          result: Stagehand::Models::SessionActResponse::Data::Result,
+          action_id: String
+        }
+
+      class Data < Stagehand::Internal::Type::BaseModel
+        attr_accessor result: Stagehand::Models::SessionActResponse::Data::Result
+
+        attr_reader action_id: String?
+
+        def action_id=: (String) -> String
+
+        def initialize: (
+          result: Stagehand::Models::SessionActResponse::Data::Result,
+          ?action_id: String
+        ) -> void
+
+        def to_hash: -> {
+          result: Stagehand::Models::SessionActResponse::Data::Result,
+          action_id: String
+        }
+
+        type result =
+          {
+            action_description: String,
+            actions: ::Array[Stagehand::Models::SessionActResponse::Data::Result::Action],
+            message: String,
+            success: bool
+          }
+
+        class Result < Stagehand::Internal::Type::BaseModel
+          attr_accessor action_description: String
+
+          attr_accessor actions: ::Array[Stagehand::Models::SessionActResponse::Data::Result::Action]
+
+          attr_accessor message: String
+
+          attr_accessor success: bool
+
+          def initialize: (
+            action_description: String,
+            actions: ::Array[Stagehand::Models::SessionActResponse::Data::Result::Action],
+            message: String,
+            success: bool
+          ) -> void
+
+          def to_hash: -> {
+            action_description: String,
+            actions: ::Array[Stagehand::Models::SessionActResponse::Data::Result::Action],
+            message: String,
+            success: bool
+          }
+
+          type action =
+            {
+              description: String,
+              selector: String,
+              arguments: ::Array[String],
+              backend_node_id: Float,
+              method_: String
+            }
+
+          class Action < Stagehand::Internal::Type::BaseModel
+            attr_accessor description: String
+
+            attr_accessor selector: String
+
+            attr_reader arguments: ::Array[String]?
+
+            def arguments=: (::Array[String]) -> ::Array[String]
+
+            attr_reader backend_node_id: Float?
+
+            def backend_node_id=: (Float) -> Float
+
+            attr_reader method_: String?
+
+            def method_=: (String) -> String
+
+            def initialize: (
+              description: String,
+              selector: String,
+              ?arguments: ::Array[String],
+              ?backend_node_id: Float,
+              ?method_: String
+            ) -> void
+
+            def to_hash: -> {
+              description: String,
+              selector: String,
+              arguments: ::Array[String],
+              backend_node_id: Float,
+              method_: String
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/sig/stagehand/models/session_end_params.rbs

@@ -0,0 +1,41 @@
+module Stagehand
+  module Models
+    type session_end_params =
+      {
+        x_stream_response: Stagehand::Models::SessionEndParams::x_stream_response
+      }
+      & Stagehand::Internal::Type::request_parameters
+
+    class SessionEndParams < Stagehand::Internal::Type::BaseModel
+      extend Stagehand::Internal::Type::RequestParameters::Converter
+      include Stagehand::Internal::Type::RequestParameters
+
+      attr_reader x_stream_response: Stagehand::Models::SessionEndParams::x_stream_response?
+
+      def x_stream_response=: (
+        Stagehand::Models::SessionEndParams::x_stream_response
+      ) -> Stagehand::Models::SessionEndParams::x_stream_response
+
+      def initialize: (
+        ?x_stream_response: Stagehand::Models::SessionEndParams::x_stream_response,
+        ?request_options: Stagehand::request_opts
+      ) -> void
+
+      def to_hash: -> {
+        x_stream_response: Stagehand::Models::SessionEndParams::x_stream_response,
+        request_options: Stagehand::RequestOptions
+      }
+
+      type x_stream_response = :true | :false
+
+      module XStreamResponse
+        extend Stagehand::Internal::Type::Enum
+
+        TRUE: :true
+        FALSE: :false
+
+        def self?.values: -> ::Array[Stagehand::Models::SessionEndParams::x_stream_response]
+      end
+    end
+  end
+end

data/sig/stagehand/models/session_end_response.rbs

@@ -0,0 +1,13 @@
+module Stagehand
+  module Models
+    type session_end_response = { success: bool }
+
+    class SessionEndResponse < Stagehand::Internal::Type::BaseModel
+      attr_accessor success: bool
+
+      def initialize: (success: bool) -> void
+
+      def to_hash: -> { success: bool }
+    end
+  end
+end