stagehand 0.0.4 → 3.5.2

data/rbi/stagehand/models/session_navigate_params.rbi

@@ -0,0 +1,240 @@
+# typed: strong
+
+module Stagehand
+  module Models
+    class SessionNavigateParams < Stagehand::Internal::Type::BaseModel
+      extend Stagehand::Internal::Type::RequestParameters::Converter
+      include Stagehand::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Stagehand::SessionNavigateParams, Stagehand::Internal::AnyHash)
+        end
+
+      # URL to navigate to
+      sig { returns(String) }
+      attr_accessor :url
+
+      # Target frame ID for the navigation
+      sig { returns(T.nilable(String)) }
+      attr_accessor :frame_id
+
+      sig { returns(T.nilable(Stagehand::SessionNavigateParams::Options)) }
+      attr_reader :options
+
+      sig do
+        params(options: Stagehand::SessionNavigateParams::Options::OrHash).void
+      end
+      attr_writer :options
+
+      # Whether to stream the response via SSE
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :stream_response
+
+      sig { params(stream_response: T::Boolean).void }
+      attr_writer :stream_response
+
+      # Whether to stream the response via SSE
+      sig do
+        returns(
+          T.nilable(Stagehand::SessionNavigateParams::XStreamResponse::OrSymbol)
+        )
+      end
+      attr_reader :x_stream_response
+
+      sig do
+        params(
+          x_stream_response:
+            Stagehand::SessionNavigateParams::XStreamResponse::OrSymbol
+        ).void
+      end
+      attr_writer :x_stream_response
+
+      sig do
+        params(
+          url: String,
+          frame_id: T.nilable(String),
+          options: Stagehand::SessionNavigateParams::Options::OrHash,
+          stream_response: T::Boolean,
+          x_stream_response:
+            Stagehand::SessionNavigateParams::XStreamResponse::OrSymbol,
+          request_options: Stagehand::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # URL to navigate to
+        url:,
+        # Target frame ID for the navigation
+        frame_id: nil,
+        options: nil,
+        # Whether to stream the response via SSE
+        stream_response: nil,
+        # Whether to stream the response via SSE
+        x_stream_response: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            url: String,
+            frame_id: T.nilable(String),
+            options: Stagehand::SessionNavigateParams::Options,
+            stream_response: T::Boolean,
+            x_stream_response:
+              Stagehand::SessionNavigateParams::XStreamResponse::OrSymbol,
+            request_options: Stagehand::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Options < Stagehand::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Stagehand::SessionNavigateParams::Options,
+              Stagehand::Internal::AnyHash
+            )
+          end
+
+        # Referer header to send with the request
+        sig { returns(T.nilable(String)) }
+        attr_reader :referer
+
+        sig { params(referer: String).void }
+        attr_writer :referer
+
+        # Timeout in ms for the navigation
+        sig { returns(T.nilable(Float)) }
+        attr_reader :timeout
+
+        sig { params(timeout: Float).void }
+        attr_writer :timeout
+
+        # When to consider navigation complete
+        sig do
+          returns(
+            T.nilable(
+              Stagehand::SessionNavigateParams::Options::WaitUntil::OrSymbol
+            )
+          )
+        end
+        attr_reader :wait_until
+
+        sig do
+          params(
+            wait_until:
+              Stagehand::SessionNavigateParams::Options::WaitUntil::OrSymbol
+          ).void
+        end
+        attr_writer :wait_until
+
+        sig do
+          params(
+            referer: String,
+            timeout: Float,
+            wait_until:
+              Stagehand::SessionNavigateParams::Options::WaitUntil::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Referer header to send with the request
+          referer: nil,
+          # Timeout in ms for the navigation
+          timeout: nil,
+          # When to consider navigation complete
+          wait_until: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              referer: String,
+              timeout: Float,
+              wait_until:
+                Stagehand::SessionNavigateParams::Options::WaitUntil::OrSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # When to consider navigation complete
+        module WaitUntil
+          extend Stagehand::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(
+                Symbol,
+                Stagehand::SessionNavigateParams::Options::WaitUntil
+              )
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          LOAD =
+            T.let(
+              :load,
+              Stagehand::SessionNavigateParams::Options::WaitUntil::TaggedSymbol
+            )
+          DOMCONTENTLOADED =
+            T.let(
+              :domcontentloaded,
+              Stagehand::SessionNavigateParams::Options::WaitUntil::TaggedSymbol
+            )
+          NETWORKIDLE =
+            T.let(
+              :networkidle,
+              Stagehand::SessionNavigateParams::Options::WaitUntil::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Stagehand::SessionNavigateParams::Options::WaitUntil::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      # Whether to stream the response via SSE
+      module XStreamResponse
+        extend Stagehand::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Stagehand::SessionNavigateParams::XStreamResponse)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRUE =
+          T.let(
+            :true,
+            Stagehand::SessionNavigateParams::XStreamResponse::TaggedSymbol
+          )
+        FALSE =
+          T.let(
+            :false,
+            Stagehand::SessionNavigateParams::XStreamResponse::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Stagehand::SessionNavigateParams::XStreamResponse::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/stagehand/models/session_navigate_response.rbi

@@ -0,0 +1,91 @@
+# typed: strong
+
+module Stagehand
+  module Models
+    class SessionNavigateResponse < Stagehand::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Stagehand::Models::SessionNavigateResponse,
+            Stagehand::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Stagehand::Models::SessionNavigateResponse::Data) }
+      attr_reader :data
+
+      sig do
+        params(
+          data: Stagehand::Models::SessionNavigateResponse::Data::OrHash
+        ).void
+      end
+      attr_writer :data
+
+      # Indicates whether the request was successful
+      sig { returns(T::Boolean) }
+      attr_accessor :success
+
+      sig do
+        params(
+          data: Stagehand::Models::SessionNavigateResponse::Data::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        data:,
+        # Indicates whether the request was successful
+        success:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: Stagehand::Models::SessionNavigateResponse::Data,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Stagehand::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Stagehand::Models::SessionNavigateResponse::Data,
+              Stagehand::Internal::AnyHash
+            )
+          end
+
+        # Navigation response (Playwright Response object or null)
+        sig { returns(T.anything) }
+        attr_accessor :result
+
+        # Action ID for tracking
+        sig { returns(T.nilable(String)) }
+        attr_reader :action_id
+
+        sig { params(action_id: String).void }
+        attr_writer :action_id
+
+        sig do
+          params(result: T.anything, action_id: String).returns(
+            T.attached_class
+          )
+        end
+        def self.new(
+          # Navigation response (Playwright Response object or null)
+          result:,
+          # Action ID for tracking
+          action_id: nil
+        )
+        end
+
+        sig { override.returns({ result: T.anything, action_id: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/stagehand/models/session_observe_params.rbi

@@ -0,0 +1,198 @@
+# typed: strong
+
+module Stagehand
+  module Models
+    class SessionObserveParams < Stagehand::Internal::Type::BaseModel
+      extend Stagehand::Internal::Type::RequestParameters::Converter
+      include Stagehand::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Stagehand::SessionObserveParams, Stagehand::Internal::AnyHash)
+        end
+
+      # Target frame ID for the observation
+      sig { returns(T.nilable(String)) }
+      attr_accessor :frame_id
+
+      # Natural language instruction for what actions to find
+      sig { returns(T.nilable(String)) }
+      attr_reader :instruction
+
+      sig { params(instruction: String).void }
+      attr_writer :instruction
+
+      sig { returns(T.nilable(Stagehand::SessionObserveParams::Options)) }
+      attr_reader :options
+
+      sig do
+        params(options: Stagehand::SessionObserveParams::Options::OrHash).void
+      end
+      attr_writer :options
+
+      # Whether to stream the response via SSE
+      sig do
+        returns(
+          T.nilable(Stagehand::SessionObserveParams::XStreamResponse::OrSymbol)
+        )
+      end
+      attr_reader :x_stream_response
+
+      sig do
+        params(
+          x_stream_response:
+            Stagehand::SessionObserveParams::XStreamResponse::OrSymbol
+        ).void
+      end
+      attr_writer :x_stream_response
+
+      sig do
+        params(
+          frame_id: T.nilable(String),
+          instruction: String,
+          options: Stagehand::SessionObserveParams::Options::OrHash,
+          x_stream_response:
+            Stagehand::SessionObserveParams::XStreamResponse::OrSymbol,
+          request_options: Stagehand::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Target frame ID for the observation
+        frame_id: nil,
+        # Natural language instruction for what actions to find
+        instruction: nil,
+        options: nil,
+        # Whether to stream the response via SSE
+        x_stream_response: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            frame_id: T.nilable(String),
+            instruction: String,
+            options: Stagehand::SessionObserveParams::Options,
+            x_stream_response:
+              Stagehand::SessionObserveParams::XStreamResponse::OrSymbol,
+            request_options: Stagehand::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Options < Stagehand::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Stagehand::SessionObserveParams::Options,
+              Stagehand::Internal::AnyHash
+            )
+          end
+
+        # Model configuration object or model name string (e.g., 'openai/gpt-5-nano')
+        sig { returns(T.nilable(T.any(Stagehand::ModelConfig, String))) }
+        attr_reader :model
+
+        sig do
+          params(model: T.any(Stagehand::ModelConfig::OrHash, String)).void
+        end
+        attr_writer :model
+
+        # CSS selector to scope observation to a specific element
+        sig { returns(T.nilable(String)) }
+        attr_reader :selector
+
+        sig { params(selector: String).void }
+        attr_writer :selector
+
+        # Timeout in ms for the observation
+        sig { returns(T.nilable(Float)) }
+        attr_reader :timeout
+
+        sig { params(timeout: Float).void }
+        attr_writer :timeout
+
+        sig do
+          params(
+            model: T.any(Stagehand::ModelConfig::OrHash, String),
+            selector: String,
+            timeout: Float
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Model configuration object or model name string (e.g., 'openai/gpt-5-nano')
+          model: nil,
+          # CSS selector to scope observation to a specific element
+          selector: nil,
+          # Timeout in ms for the observation
+          timeout: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              model: T.any(Stagehand::ModelConfig, String),
+              selector: String,
+              timeout: Float
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Model configuration object or model name string (e.g., 'openai/gpt-5-nano')
+        module Model
+          extend Stagehand::Internal::Type::Union
+
+          Variants = T.type_alias { T.any(Stagehand::ModelConfig, String) }
+
+          sig do
+            override.returns(
+              T::Array[
+                Stagehand::SessionObserveParams::Options::Model::Variants
+              ]
+            )
+          end
+          def self.variants
+          end
+        end
+      end
+
+      # Whether to stream the response via SSE
+      module XStreamResponse
+        extend Stagehand::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Stagehand::SessionObserveParams::XStreamResponse)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        TRUE =
+          T.let(
+            :true,
+            Stagehand::SessionObserveParams::XStreamResponse::TaggedSymbol
+          )
+        FALSE =
+          T.let(
+            :false,
+            Stagehand::SessionObserveParams::XStreamResponse::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Stagehand::SessionObserveParams::XStreamResponse::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/stagehand/models/session_observe_response.rbi

@@ -0,0 +1,184 @@
+# typed: strong
+
+module Stagehand
+  module Models
+    class SessionObserveResponse < Stagehand::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Stagehand::Models::SessionObserveResponse,
+            Stagehand::Internal::AnyHash
+          )
+        end
+
+      sig { returns(Stagehand::Models::SessionObserveResponse::Data) }
+      attr_reader :data
+
+      sig do
+        params(
+          data: Stagehand::Models::SessionObserveResponse::Data::OrHash
+        ).void
+      end
+      attr_writer :data
+
+      # Indicates whether the request was successful
+      sig { returns(T::Boolean) }
+      attr_accessor :success
+
+      sig do
+        params(
+          data: Stagehand::Models::SessionObserveResponse::Data::OrHash,
+          success: T::Boolean
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        data:,
+        # Indicates whether the request was successful
+        success:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: Stagehand::Models::SessionObserveResponse::Data,
+            success: T::Boolean
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < Stagehand::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Stagehand::Models::SessionObserveResponse::Data,
+              Stagehand::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T::Array[Stagehand::Models::SessionObserveResponse::Data::Result]
+          )
+        end
+        attr_accessor :result
+
+        # Action ID for tracking
+        sig { returns(T.nilable(String)) }
+        attr_reader :action_id
+
+        sig { params(action_id: String).void }
+        attr_writer :action_id
+
+        sig do
+          params(
+            result:
+              T::Array[
+                Stagehand::Models::SessionObserveResponse::Data::Result::OrHash
+              ],
+            action_id: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          result:,
+          # Action ID for tracking
+          action_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              result:
+                T::Array[
+                  Stagehand::Models::SessionObserveResponse::Data::Result
+                ],
+              action_id: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Result < Stagehand::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Stagehand::Models::SessionObserveResponse::Data::Result,
+                Stagehand::Internal::AnyHash
+              )
+            end
+
+          # Human-readable description of the action
+          sig { returns(String) }
+          attr_accessor :description
+
+          # CSS selector or XPath for the element
+          sig { returns(String) }
+          attr_accessor :selector
+
+          # Arguments to pass to the method
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_reader :arguments
+
+          sig { params(arguments: T::Array[String]).void }
+          attr_writer :arguments
+
+          # Backend node ID for the element
+          sig { returns(T.nilable(Float)) }
+          attr_reader :backend_node_id
+
+          sig { params(backend_node_id: Float).void }
+          attr_writer :backend_node_id
+
+          # The method to execute (click, fill, etc.)
+          sig { returns(T.nilable(String)) }
+          attr_reader :method_
+
+          sig { params(method_: String).void }
+          attr_writer :method_
+
+          # Action object returned by observe and used by act
+          sig do
+            params(
+              description: String,
+              selector: String,
+              arguments: T::Array[String],
+              backend_node_id: Float,
+              method_: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Human-readable description of the action
+            description:,
+            # CSS selector or XPath for the element
+            selector:,
+            # Arguments to pass to the method
+            arguments: nil,
+            # Backend node ID for the element
+            backend_node_id: nil,
+            # The method to execute (click, fill, etc.)
+            method_: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                description: String,
+                selector: String,
+                arguments: T::Array[String],
+                backend_node_id: Float,
+                method_: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end