stagehand 0.0.3 → 3.5.2

data/lib/stagehand/models/session_start_response.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Stagehand
+  module Models
+    # @see Stagehand::Resources::Sessions#start
+    class SessionStartResponse < Stagehand::Internal::Type::BaseModel
+      # @!attribute data
+      #
+      #   @return [Stagehand::Models::SessionStartResponse::Data]
+      required :data, -> { Stagehand::Models::SessionStartResponse::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::SessionStartResponse::Data]
+      #
+      #   @param success [Boolean] Indicates whether the request was successful
+
+      # @see Stagehand::Models::SessionStartResponse#data
+      class Data < Stagehand::Internal::Type::BaseModel
+        # @!attribute available
+        #
+        #   @return [Boolean]
+        required :available, Stagehand::Internal::Type::Boolean
+
+        # @!attribute session_id
+        #   Unique Browserbase session identifier
+        #
+        #   @return [String]
+        required :session_id, String, api_name: :sessionId
+
+        # @!attribute cdp_url
+        #   CDP WebSocket URL for connecting to the Browserbase cloud browser (present when
+        #   available)
+        #
+        #   @return [String, nil]
+        optional :cdp_url, String, api_name: :cdpUrl, nil?: true
+
+        # @!method initialize(available:, session_id:, cdp_url: nil)
+        #   Some parameter documentations has been truncated, see
+        #   {Stagehand::Models::SessionStartResponse::Data} for more details.
+        #
+        #   @param available [Boolean]
+        #
+        #   @param session_id [String] Unique Browserbase session identifier
+        #
+        #   @param cdp_url [String, nil] CDP WebSocket URL for connecting to the Browserbase cloud browser (present when
+      end
+    end
+  end
+end

data/lib/stagehand/models/stream_event.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Stagehand
+  module Models
+    class StreamEvent < Stagehand::Internal::Type::BaseModel
+      # @!attribute id
+      #   Unique identifier for this event
+      #
+      #   @return [String]
+      required :id, String
+
+      # @!attribute data
+      #
+      #   @return [Stagehand::Models::StreamEvent::Data::StreamEventSystemDataOutput, Stagehand::Models::StreamEvent::Data::StreamEventLogDataOutput]
+      required :data, union: -> { Stagehand::StreamEvent::Data }
+
+      # @!attribute type
+      #   Type of stream event - system events or log messages
+      #
+      #   @return [Symbol, Stagehand::Models::StreamEvent::Type]
+      required :type, enum: -> { Stagehand::StreamEvent::Type }
+
+      # @!method initialize(id:, data:, type:)
+      #   Server-Sent Event emitted during streaming responses. Events are sent as
+      #   `data: <JSON>\n\n`. Key order: data (with status first), type, id.
+      #
+      #   @param id [String] Unique identifier for this event
+      #
+      #   @param data [Stagehand::Models::StreamEvent::Data::StreamEventSystemDataOutput, Stagehand::Models::StreamEvent::Data::StreamEventLogDataOutput]
+      #
+      #   @param type [Symbol, Stagehand::Models::StreamEvent::Type] Type of stream event - system events or log messages
+
+      # @see Stagehand::Models::StreamEvent#data
+      module Data
+        extend Stagehand::Internal::Type::Union
+
+        variant -> { Stagehand::StreamEvent::Data::StreamEventSystemDataOutput }
+
+        variant -> { Stagehand::StreamEvent::Data::StreamEventLogDataOutput }
+
+        class StreamEventSystemDataOutput < Stagehand::Internal::Type::BaseModel
+          # @!attribute status
+          #   Current status of the streaming operation
+          #
+          #   @return [Symbol, Stagehand::Models::StreamEvent::Data::StreamEventSystemDataOutput::Status]
+          required :status, enum: -> { Stagehand::StreamEvent::Data::StreamEventSystemDataOutput::Status }
+
+          # @!attribute error
+          #   Error message (present when status is 'error')
+          #
+          #   @return [String, nil]
+          optional :error, String
+
+          # @!attribute result
+          #   Operation result (present when status is 'finished')
+          #
+          #   @return [Object, nil]
+          optional :result, Stagehand::Internal::Type::Unknown
+
+          # @!method initialize(status:, error: nil, result: nil)
+          #   @param status [Symbol, Stagehand::Models::StreamEvent::Data::StreamEventSystemDataOutput::Status] Current status of the streaming operation
+          #
+          #   @param error [String] Error message (present when status is 'error')
+          #
+          #   @param result [Object] Operation result (present when status is 'finished')
+
+          # Current status of the streaming operation
+          #
+          # @see Stagehand::Models::StreamEvent::Data::StreamEventSystemDataOutput#status
+          module Status
+            extend Stagehand::Internal::Type::Enum
+
+            STARTING = :starting
+            CONNECTED = :connected
+            RUNNING = :running
+            FINISHED = :finished
+            ERROR = :error
+
+            # @!method self.values
+            #   @return [Array<Symbol>]
+          end
+        end
+
+        class StreamEventLogDataOutput < Stagehand::Internal::Type::BaseModel
+          # @!attribute message
+          #   Log message from the operation
+          #
+          #   @return [String]
+          required :message, String
+
+          # @!attribute status
+          #
+          #   @return [Symbol, :running]
+          required :status, const: :running
+
+          # @!method initialize(message:, status: :running)
+          #   @param message [String] Log message from the operation
+          #
+          #   @param status [Symbol, :running]
+        end
+
+        # @!method self.variants
+        #   @return [Array(Stagehand::Models::StreamEvent::Data::StreamEventSystemDataOutput, Stagehand::Models::StreamEvent::Data::StreamEventLogDataOutput)]
+      end
+
+      # Type of stream event - system events or log messages
+      #
+      # @see Stagehand::Models::StreamEvent#type
+      module Type
+        extend Stagehand::Internal::Type::Enum
+
+        SYSTEM = :system
+        LOG = :log
+
+        # @!method self.values
+        #   @return [Array<Symbol>]
+      end
+    end
+  end
+end

data/lib/stagehand/models.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Stagehand
+  [Stagehand::Internal::Type::BaseModel, *Stagehand::Internal::Type::BaseModel.subclasses].each do |cls|
+    cls.define_sorbet_constant!(:OrHash) { T.type_alias { T.any(cls, Stagehand::Internal::AnyHash) } }
+  end
+
+  Stagehand::Internal::Util.walk_namespaces(Stagehand::Models).each do |mod|
+    case mod
+    in Stagehand::Internal::Type::Enum | Stagehand::Internal::Type::Union
+      mod.constants.each do |name|
+        case mod.const_get(name)
+        in true | false
+          mod.define_sorbet_constant!(:TaggedBoolean) { T.type_alias { T::Boolean } }
+          mod.define_sorbet_constant!(:OrBoolean) { T.type_alias { T::Boolean } }
+        in Integer
+          mod.define_sorbet_constant!(:TaggedInteger) { T.type_alias { Integer } }
+          mod.define_sorbet_constant!(:OrInteger) { T.type_alias { Integer } }
+        in Float
+          mod.define_sorbet_constant!(:TaggedFloat) { T.type_alias { Float } }
+          mod.define_sorbet_constant!(:OrFloat) { T.type_alias { Float } }
+        in Symbol
+          mod.define_sorbet_constant!(:TaggedSymbol) { T.type_alias { Symbol } }
+          mod.define_sorbet_constant!(:OrSymbol) { T.type_alias { T.any(Symbol, String) } }
+        else
+        end
+      end
+    else
+    end
+  end
+
+  Stagehand::Internal::Util.walk_namespaces(Stagehand::Models)
+                           .lazy
+                           .grep(Stagehand::Internal::Type::Union)
+                           .each do |mod|
+    const = :Variants
+    next if mod.sorbet_constant_defined?(const)
+
+    mod.define_sorbet_constant!(const) { T.type_alias { mod.to_sorbet_type } }
+  end
+
+  Action = Stagehand::Models::Action
+
+  ModelConfig = Stagehand::Models::ModelConfig
+
+  SessionActParams = Stagehand::Models::SessionActParams
+
+  SessionEndParams = Stagehand::Models::SessionEndParams
+
+  SessionExecuteParams = Stagehand::Models::SessionExecuteParams
+
+  SessionExtractParams = Stagehand::Models::SessionExtractParams
+
+  SessionNavigateParams = Stagehand::Models::SessionNavigateParams
+
+  SessionObserveParams = Stagehand::Models::SessionObserveParams
+
+  SessionReplayParams = Stagehand::Models::SessionReplayParams
+
+  SessionStartParams = Stagehand::Models::SessionStartParams
+
+  StreamEvent = Stagehand::Models::StreamEvent
+end

data/lib/stagehand/request_options.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Stagehand
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < Stagehand::Internal::Type::BaseModel
+    # @api private
+    #
+    # @param opts [Stagehand::RequestOptions, Hash{Symbol=>Object}]
+    #
+    # @raise [ArgumentError]
+    def self.validate!(opts)
+      case opts
+      in Stagehand::RequestOptions | Hash
+        opts.to_h.each_key do |k|
+          unless fields.include?(k)
+            raise ArgumentError.new("Request `opts` keys must be one of #{fields.keys}, got #{k.inspect}")
+          end
+        end
+      else
+        raise ArgumentError.new("Request `opts` must be a Hash or RequestOptions, got #{opts.inspect}")
+      end
+    end
+
+    # @!attribute idempotency_key
+    #   Idempotency key to send with request and all associated retries. Will only be
+    #   sent for write requests.
+    #
+    #   @return [String, nil]
+    optional :idempotency_key, String
+
+    # @!attribute extra_query
+    #   Extra query params to send with the request. These are `.merge`’d into any
+    #   `query` given at the client level.
+    #
+    #   @return [Hash{String=>Array<String>, String, nil}, nil]
+    optional :extra_query, Stagehand::Internal::Type::HashOf[Stagehand::Internal::Type::ArrayOf[String]]
+
+    # @!attribute extra_headers
+    #   Extra headers to send with the request. These are `.merged`’d into any
+    #   `extra_headers` given at the client level.
+    #
+    #   @return [Hash{String=>String, nil}, nil]
+    optional :extra_headers, Stagehand::Internal::Type::HashOf[String, nil?: true]
+
+    # @!attribute extra_body
+    #   Extra data to send with the request. These are deep merged into any data
+    #   generated as part of the normal request.
+    #
+    #   @return [Object, nil]
+    optional :extra_body, Stagehand::Internal::Type::HashOf[Stagehand::Internal::Type::Unknown]
+
+    # @!attribute max_retries
+    #   Maximum number of retries to attempt after a failed initial request.
+    #
+    #   @return [Integer, nil]
+    optional :max_retries, Integer
+
+    # @!attribute timeout
+    #   Request timeout in seconds.
+    #
+    #   @return [Float, nil]
+    optional :timeout, Float
+
+    # @!method initialize(values = {})
+    #   Returns a new instance of RequestOptions.
+    #
+    #   @param values [Hash{Symbol=>Object}]
+
+    define_sorbet_constant!(:OrHash) do
+      T.type_alias { T.any(Stagehand::RequestOptions, Stagehand::Internal::AnyHash) }
+    end
+  end
+end