stagehand 0.0.3 → 3.5.2

data/lib/stagehand/models/session_extract_params.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Stagehand
+  module Models
+    # @see Stagehand::Resources::Sessions#extract
+    #
+    # @see Stagehand::Resources::Sessions#extract_streaming
+    class SessionExtractParams < Stagehand::Internal::Type::BaseModel
+      extend Stagehand::Internal::Type::RequestParameters::Converter
+      include Stagehand::Internal::Type::RequestParameters
+
+      # @!attribute frame_id
+      #   Target frame ID for the extraction
+      #
+      #   @return [String, nil]
+      optional :frame_id, String, api_name: :frameId, nil?: true
+
+      # @!attribute instruction
+      #   Natural language instruction for what to extract
+      #
+      #   @return [String, nil]
+      optional :instruction, String
+
+      # @!attribute options
+      #
+      #   @return [Stagehand::Models::SessionExtractParams::Options, nil]
+      optional :options, -> { Stagehand::SessionExtractParams::Options }
+
+      # @!attribute schema
+      #   JSON Schema defining the structure of data to extract
+      #
+      #   @return [Hash{Symbol=>Object}, nil]
+      optional :schema, Stagehand::Internal::Type::HashOf[Stagehand::Internal::Type::Unknown]
+
+      # @!attribute x_stream_response
+      #   Whether to stream the response via SSE
+      #
+      #   @return [Symbol, Stagehand::Models::SessionExtractParams::XStreamResponse, nil]
+      optional :x_stream_response, enum: -> { Stagehand::SessionExtractParams::XStreamResponse }
+
+      # @!method initialize(frame_id: nil, instruction: nil, options: nil, schema: nil, x_stream_response: nil, request_options: {})
+      #   @param frame_id [String, nil] Target frame ID for the extraction
+      #
+      #   @param instruction [String] Natural language instruction for what to extract
+      #
+      #   @param options [Stagehand::Models::SessionExtractParams::Options]
+      #
+      #   @param schema [Hash{Symbol=>Object}] JSON Schema defining the structure of data to extract
+      #
+      #   @param x_stream_response [Symbol, Stagehand::Models::SessionExtractParams::XStreamResponse] Whether to stream the response via SSE
+      #
+      #   @param request_options [Stagehand::RequestOptions, Hash{Symbol=>Object}]
+
+      class Options < Stagehand::Internal::Type::BaseModel
+        # @!attribute model
+        #   Model configuration object or model name string (e.g., 'openai/gpt-5-nano')
+        #
+        #   @return [Stagehand::Models::ModelConfig, String, nil]
+        optional :model, union: -> { Stagehand::SessionExtractParams::Options::Model }
+
+        # @!attribute selector
+        #   CSS selector to scope extraction to a specific element
+        #
+        #   @return [String, nil]
+        optional :selector, String
+
+        # @!attribute timeout
+        #   Timeout in ms for the extraction
+        #
+        #   @return [Float, nil]
+        optional :timeout, Float
+
+        # @!method initialize(model: nil, selector: nil, timeout: nil)
+        #   @param model [Stagehand::Models::ModelConfig, String] Model configuration object or model name string (e.g., 'openai/gpt-5-nano')
+        #
+        #   @param selector [String] CSS selector to scope extraction to a specific element
+        #
+        #   @param timeout [Float] Timeout in ms for the extraction
+
+        # Model configuration object or model name string (e.g., 'openai/gpt-5-nano')
+        #
+        # @see Stagehand::Models::SessionExtractParams::Options#model
+        module Model
+          extend Stagehand::Internal::Type::Union
+
+          variant -> { Stagehand::ModelConfig }
+
+          variant String
+
+          # @!method self.variants
+          #   @return [Array(Stagehand::Models::ModelConfig, String)]
+        end
+      end
+
+      # Whether to stream the response via SSE
+      module XStreamResponse
+        extend Stagehand::Internal::Type::Enum
+
+        TRUE = :true
+        FALSE = :false
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/stagehand/models/session_extract_response.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Stagehand
+  module Models
+    # @see Stagehand::Resources::Sessions#extract
+    #
+    # @see Stagehand::Resources::Sessions#extract_streaming
+    class SessionExtractResponse < Stagehand::Internal::Type::BaseModel
+      # @!attribute data
+      #
+      #   @return [Stagehand::Models::SessionExtractResponse::Data]
+      required :data, -> { Stagehand::Models::SessionExtractResponse::Data }
+
+      # @!attribute success
+      #   Indicates whether the request was successful
+      #
+      #   @return [Boolean]
+      required :success, Stagehand::Internal::Type::Boolean
+
+      # @!method initialize(data:, success:)
+      #   @param data [Stagehand::Models::SessionExtractResponse::Data]
+      #
+      #   @param success [Boolean] Indicates whether the request was successful
+
+      # @see Stagehand::Models::SessionExtractResponse#data
+      class Data < Stagehand::Internal::Type::BaseModel
+        # @!attribute result
+        #   Extracted data matching the requested schema
+        #
+        #   @return [Object]
+        required :result, Stagehand::Internal::Type::Unknown
+
+        # @!attribute action_id
+        #   Action ID for tracking
+        #
+        #   @return [String, nil]
+        optional :action_id, String, api_name: :actionId
+
+        # @!method initialize(result:, action_id: nil)
+        #   @param result [Object] Extracted data matching the requested schema
+        #
+        #   @param action_id [String] Action ID for tracking
+      end
+    end
+  end
+end

data/lib/stagehand/models/session_navigate_params.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Stagehand
+  module Models
+    # @see Stagehand::Resources::Sessions#navigate
+    class SessionNavigateParams < Stagehand::Internal::Type::BaseModel
+      extend Stagehand::Internal::Type::RequestParameters::Converter
+      include Stagehand::Internal::Type::RequestParameters
+
+      # @!attribute url
+      #   URL to navigate to
+      #
+      #   @return [String]
+      required :url, String
+
+      # @!attribute frame_id
+      #   Target frame ID for the navigation
+      #
+      #   @return [String, nil]
+      optional :frame_id, String, api_name: :frameId, nil?: true
+
+      # @!attribute options
+      #
+      #   @return [Stagehand::Models::SessionNavigateParams::Options, nil]
+      optional :options, -> { Stagehand::SessionNavigateParams::Options }
+
+      # @!attribute stream_response
+      #   Whether to stream the response via SSE
+      #
+      #   @return [Boolean, nil]
+      optional :stream_response, Stagehand::Internal::Type::Boolean, api_name: :streamResponse
+
+      # @!attribute x_stream_response
+      #   Whether to stream the response via SSE
+      #
+      #   @return [Symbol, Stagehand::Models::SessionNavigateParams::XStreamResponse, nil]
+      optional :x_stream_response, enum: -> { Stagehand::SessionNavigateParams::XStreamResponse }
+
+      # @!method initialize(url:, frame_id: nil, options: nil, stream_response: nil, x_stream_response: nil, request_options: {})
+      #   @param url [String] URL to navigate to
+      #
+      #   @param frame_id [String, nil] Target frame ID for the navigation
+      #
+      #   @param options [Stagehand::Models::SessionNavigateParams::Options]
+      #
+      #   @param stream_response [Boolean] Whether to stream the response via SSE
+      #
+      #   @param x_stream_response [Symbol, Stagehand::Models::SessionNavigateParams::XStreamResponse] Whether to stream the response via SSE
+      #
+      #   @param request_options [Stagehand::RequestOptions, Hash{Symbol=>Object}]
+
+      class Options < Stagehand::Internal::Type::BaseModel
+        # @!attribute referer
+        #   Referer header to send with the request
+        #
+        #   @return [String, nil]
+        optional :referer, String
+
+        # @!attribute timeout
+        #   Timeout in ms for the navigation
+        #
+        #   @return [Float, nil]
+        optional :timeout, Float
+
+        # @!attribute wait_until
+        #   When to consider navigation complete
+        #
+        #   @return [Symbol, Stagehand::Models::SessionNavigateParams::Options::WaitUntil, nil]
+        optional :wait_until,
+                 enum: -> { Stagehand::SessionNavigateParams::Options::WaitUntil },
+                 api_name: :waitUntil
+
+        # @!method initialize(referer: nil, timeout: nil, wait_until: nil)
+        #   @param referer [String] Referer header to send with the request
+        #
+        #   @param timeout [Float] Timeout in ms for the navigation
+        #
+        #   @param wait_until [Symbol, Stagehand::Models::SessionNavigateParams::Options::WaitUntil] When to consider navigation complete
+
+        # When to consider navigation complete
+        #
+        # @see Stagehand::Models::SessionNavigateParams::Options#wait_until
+        module WaitUntil
+          extend Stagehand::Internal::Type::Enum
+
+          LOAD = :load
+          DOMCONTENTLOADED = :domcontentloaded
+          NETWORKIDLE = :networkidle
+
+          # @!method self.values
+          #   @return [Array<Symbol>]
+        end
+      end
+
+      # Whether to stream the response via SSE
+      module XStreamResponse
+        extend Stagehand::Internal::Type::Enum
+
+        TRUE = :true
+        FALSE = :false
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/stagehand/models/session_navigate_response.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Stagehand
+  module Models
+    # @see Stagehand::Resources::Sessions#navigate
+    class SessionNavigateResponse < Stagehand::Internal::Type::BaseModel
+      # @!attribute data
+      #
+      #   @return [Stagehand::Models::SessionNavigateResponse::Data]
+      required :data, -> { Stagehand::Models::SessionNavigateResponse::Data }
+
+      # @!attribute success
+      #   Indicates whether the request was successful
+      #
+      #   @return [Boolean]
+      required :success, Stagehand::Internal::Type::Boolean
+
+      # @!method initialize(data:, success:)
+      #   @param data [Stagehand::Models::SessionNavigateResponse::Data]
+      #
+      #   @param success [Boolean] Indicates whether the request was successful
+
+      # @see Stagehand::Models::SessionNavigateResponse#data
+      class Data < Stagehand::Internal::Type::BaseModel
+        # @!attribute result
+        #   Navigation response (Playwright Response object or null)
+        #
+        #   @return [Object]
+        required :result, Stagehand::Internal::Type::Unknown
+
+        # @!attribute action_id
+        #   Action ID for tracking
+        #
+        #   @return [String, nil]
+        optional :action_id, String, api_name: :actionId
+
+        # @!method initialize(result:, action_id: nil)
+        #   @param result [Object] Navigation response (Playwright Response object or null)
+        #
+        #   @param action_id [String] Action ID for tracking
+      end
+    end
+  end
+end

data/lib/stagehand/models/session_observe_params.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Stagehand
+  module Models
+    # @see Stagehand::Resources::Sessions#observe
+    #
+    # @see Stagehand::Resources::Sessions#observe_streaming
+    class SessionObserveParams < Stagehand::Internal::Type::BaseModel
+      extend Stagehand::Internal::Type::RequestParameters::Converter
+      include Stagehand::Internal::Type::RequestParameters
+
+      # @!attribute frame_id
+      #   Target frame ID for the observation
+      #
+      #   @return [String, nil]
+      optional :frame_id, String, api_name: :frameId, nil?: true
+
+      # @!attribute instruction
+      #   Natural language instruction for what actions to find
+      #
+      #   @return [String, nil]
+      optional :instruction, String
+
+      # @!attribute options
+      #
+      #   @return [Stagehand::Models::SessionObserveParams::Options, nil]
+      optional :options, -> { Stagehand::SessionObserveParams::Options }
+
+      # @!attribute x_stream_response
+      #   Whether to stream the response via SSE
+      #
+      #   @return [Symbol, Stagehand::Models::SessionObserveParams::XStreamResponse, nil]
+      optional :x_stream_response, enum: -> { Stagehand::SessionObserveParams::XStreamResponse }
+
+      # @!method initialize(frame_id: nil, instruction: nil, options: nil, x_stream_response: nil, request_options: {})
+      #   @param frame_id [String, nil] Target frame ID for the observation
+      #
+      #   @param instruction [String] Natural language instruction for what actions to find
+      #
+      #   @param options [Stagehand::Models::SessionObserveParams::Options]
+      #
+      #   @param x_stream_response [Symbol, Stagehand::Models::SessionObserveParams::XStreamResponse] Whether to stream the response via SSE
+      #
+      #   @param request_options [Stagehand::RequestOptions, Hash{Symbol=>Object}]
+
+      class Options < Stagehand::Internal::Type::BaseModel
+        # @!attribute model
+        #   Model configuration object or model name string (e.g., 'openai/gpt-5-nano')
+        #
+        #   @return [Stagehand::Models::ModelConfig, String, nil]
+        optional :model, union: -> { Stagehand::SessionObserveParams::Options::Model }
+
+        # @!attribute selector
+        #   CSS selector to scope observation to a specific element
+        #
+        #   @return [String, nil]
+        optional :selector, String
+
+        # @!attribute timeout
+        #   Timeout in ms for the observation
+        #
+        #   @return [Float, nil]
+        optional :timeout, Float
+
+        # @!method initialize(model: nil, selector: nil, timeout: nil)
+        #   @param model [Stagehand::Models::ModelConfig, String] Model configuration object or model name string (e.g., 'openai/gpt-5-nano')
+        #
+        #   @param selector [String] CSS selector to scope observation to a specific element
+        #
+        #   @param timeout [Float] Timeout in ms for the observation
+
+        # Model configuration object or model name string (e.g., 'openai/gpt-5-nano')
+        #
+        # @see Stagehand::Models::SessionObserveParams::Options#model
+        module Model
+          extend Stagehand::Internal::Type::Union
+
+          variant -> { Stagehand::ModelConfig }
+
+          variant String
+
+          # @!method self.variants
+          #   @return [Array(Stagehand::Models::ModelConfig, String)]
+        end
+      end
+
+      # Whether to stream the response via SSE
+      module XStreamResponse
+        extend Stagehand::Internal::Type::Enum
+
+        TRUE = :true
+        FALSE = :false
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/stagehand/models/session_observe_response.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Stagehand
+  module Models
+    # @see Stagehand::Resources::Sessions#observe
+    #
+    # @see Stagehand::Resources::Sessions#observe_streaming
+    class SessionObserveResponse < Stagehand::Internal::Type::BaseModel
+      # @!attribute data
+      #
+      #   @return [Stagehand::Models::SessionObserveResponse::Data]
+      required :data, -> { Stagehand::Models::SessionObserveResponse::Data }
+
+      # @!attribute success
+      #   Indicates whether the request was successful
+      #
+      #   @return [Boolean]
+      required :success, Stagehand::Internal::Type::Boolean
+
+      # @!method initialize(data:, success:)
+      #   @param data [Stagehand::Models::SessionObserveResponse::Data]
+      #
+      #   @param success [Boolean] Indicates whether the request was successful
+
+      # @see Stagehand::Models::SessionObserveResponse#data
+      class Data < Stagehand::Internal::Type::BaseModel
+        # @!attribute result
+        #
+        #   @return [Array<Stagehand::Models::SessionObserveResponse::Data::Result>]
+        required :result,
+                 -> { Stagehand::Internal::Type::ArrayOf[Stagehand::Models::SessionObserveResponse::Data::Result] }
+
+        # @!attribute action_id
+        #   Action ID for tracking
+        #
+        #   @return [String, nil]
+        optional :action_id, String, api_name: :actionId
+
+        # @!method initialize(result:, action_id: nil)
+        #   @param result [Array<Stagehand::Models::SessionObserveResponse::Data::Result>]
+        #
+        #   @param action_id [String] Action ID for tracking
+
+        class Result < Stagehand::Internal::Type::BaseModel
+          # @!attribute description
+          #   Human-readable description of the action
+          #
+          #   @return [String]
+          required :description, String
+
+          # @!attribute selector
+          #   CSS selector or XPath for the element
+          #
+          #   @return [String]
+          required :selector, String
+
+          # @!attribute arguments
+          #   Arguments to pass to the method
+          #
+          #   @return [Array<String>, nil]
+          optional :arguments, Stagehand::Internal::Type::ArrayOf[String]
+
+          # @!attribute backend_node_id
+          #   Backend node ID for the element
+          #
+          #   @return [Float, nil]
+          optional :backend_node_id, Float, api_name: :backendNodeId
+
+          # @!attribute method_
+          #   The method to execute (click, fill, etc.)
+          #
+          #   @return [String, nil]
+          optional :method_, String, api_name: :method
+
+          # @!method initialize(description:, selector:, arguments: nil, backend_node_id: nil, method_: nil)
+          #   Action object returned by observe and used by act
+          #
+          #   @param description [String] Human-readable description of the action
+          #
+          #   @param selector [String] CSS selector or XPath for the element
+          #
+          #   @param arguments [Array<String>] Arguments to pass to the method
+          #
+          #   @param backend_node_id [Float] Backend node ID for the element
+          #
+          #   @param method_ [String] The method to execute (click, fill, etc.)
+        end
+      end
+    end
+  end
+end

data/lib/stagehand/models/session_replay_params.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Stagehand
+  module Models
+    # @see Stagehand::Resources::Sessions#replay
+    class SessionReplayParams < Stagehand::Internal::Type::BaseModel
+      extend Stagehand::Internal::Type::RequestParameters::Converter
+      include Stagehand::Internal::Type::RequestParameters
+
+      # @!attribute x_stream_response
+      #   Whether to stream the response via SSE
+      #
+      #   @return [Symbol, Stagehand::Models::SessionReplayParams::XStreamResponse, nil]
+      optional :x_stream_response, enum: -> { Stagehand::SessionReplayParams::XStreamResponse }
+
+      # @!method initialize(x_stream_response: nil, request_options: {})
+      #   @param x_stream_response [Symbol, Stagehand::Models::SessionReplayParams::XStreamResponse] Whether to stream the response via SSE
+      #
+      #   @param request_options [Stagehand::RequestOptions, Hash{Symbol=>Object}]
+
+      # Whether to stream the response via SSE
+      module XStreamResponse
+        extend Stagehand::Internal::Type::Enum
+
+        TRUE = :true
+        FALSE = :false
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/stagehand/models/session_replay_response.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Stagehand
+  module Models
+    # @see Stagehand::Resources::Sessions#replay
+    class SessionReplayResponse < Stagehand::Internal::Type::BaseModel
+      # @!attribute data
+      #
+      #   @return [Stagehand::Models::SessionReplayResponse::Data]
+      required :data, -> { Stagehand::Models::SessionReplayResponse::Data }
+
+      # @!attribute success
+      #   Indicates whether the request was successful
+      #
+      #   @return [Boolean]
+      required :success, Stagehand::Internal::Type::Boolean
+
+      # @!method initialize(data:, success:)
+      #   @param data [Stagehand::Models::SessionReplayResponse::Data]
+      #
+      #   @param success [Boolean] Indicates whether the request was successful
+
+      # @see Stagehand::Models::SessionReplayResponse#data
+      class Data < Stagehand::Internal::Type::BaseModel
+        # @!attribute pages
+        #
+        #   @return [Array<Stagehand::Models::SessionReplayResponse::Data::Page>, nil]
+        optional :pages,
+                 -> { Stagehand::Internal::Type::ArrayOf[Stagehand::Models::SessionReplayResponse::Data::Page] }
+
+        # @!method initialize(pages: nil)
+        #   @param pages [Array<Stagehand::Models::SessionReplayResponse::Data::Page>]
+
+        class Page < Stagehand::Internal::Type::BaseModel
+          # @!attribute actions
+          #
+          #   @return [Array<Stagehand::Models::SessionReplayResponse::Data::Page::Action>, nil]
+          optional :actions,
+                   -> { Stagehand::Internal::Type::ArrayOf[Stagehand::Models::SessionReplayResponse::Data::Page::Action] }
+
+          # @!method initialize(actions: nil)
+          #   @param actions [Array<Stagehand::Models::SessionReplayResponse::Data::Page::Action>]
+
+          class Action < Stagehand::Internal::Type::BaseModel
+            # @!attribute method_
+            #
+            #   @return [String, nil]
+            optional :method_, String, api_name: :method
+
+            # @!attribute token_usage
+            #
+            #   @return [Stagehand::Models::SessionReplayResponse::Data::Page::Action::TokenUsage, nil]
+            optional :token_usage,
+                     -> { Stagehand::Models::SessionReplayResponse::Data::Page::Action::TokenUsage },
+                     api_name: :tokenUsage
+
+            # @!method initialize(method_: nil, token_usage: nil)
+            #   @param method_ [String]
+            #   @param token_usage [Stagehand::Models::SessionReplayResponse::Data::Page::Action::TokenUsage]
+
+            # @see Stagehand::Models::SessionReplayResponse::Data::Page::Action#token_usage
+            class TokenUsage < Stagehand::Internal::Type::BaseModel
+              # @!attribute cached_input_tokens
+              #
+              #   @return [Float, nil]
+              optional :cached_input_tokens, Float, api_name: :cachedInputTokens
+
+              # @!attribute input_tokens
+              #
+              #   @return [Float, nil]
+              optional :input_tokens, Float, api_name: :inputTokens
+
+              # @!attribute output_tokens
+              #
+              #   @return [Float, nil]
+              optional :output_tokens, Float, api_name: :outputTokens
+
+              # @!attribute reasoning_tokens
+              #
+              #   @return [Float, nil]
+              optional :reasoning_tokens, Float, api_name: :reasoningTokens
+
+              # @!attribute time_ms
+              #
+              #   @return [Float, nil]
+              optional :time_ms, Float, api_name: :timeMs
+
+              # @!method initialize(cached_input_tokens: nil, input_tokens: nil, output_tokens: nil, reasoning_tokens: nil, time_ms: nil)
+              #   @param cached_input_tokens [Float]
+              #   @param input_tokens [Float]
+              #   @param output_tokens [Float]
+              #   @param reasoning_tokens [Float]
+              #   @param time_ms [Float]
+            end
+          end
+        end
+      end
+    end
+  end
+end