riveter-sdk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 908379b467d0f1129dc3794df97bd927aeb3cdbdaaadd3146fe96c887f2835b9
+  data.tar.gz: a23f012aaad173284d2759f1754de5bc5cf50d1225e437445774e3bc723245bc
+SHA512:
+  metadata.gz: 38b1aac5504c3eac8c6256a0e559c02d4b5e526fb9a55de1d41214eeb0306be245c4dc991abbc17600fdabf11fc66dd96fb94383a23937575330c8c76bebcdb5
+  data.tar.gz: a3e028f0a9e5db8842770b970c94a77b1525b0480b1564ca3e63dd30804e1a45eb2c9eabc0aee475b3496b35394ae599398d6965bc8afbd7fcaaa5c98f72818b

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Cody
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,95 @@
+# riveter-sdk
+
+Official Ruby SDK for the [Riveter API](https://docs.riveterhq.com) — enrich data,
+build datasets, scrape pages, and run web searches.
+
+Requires Ruby 3.1+. Zero runtime dependencies (stdlib `Net::HTTP`).
+
+## Install
+
+```bash
+gem install riveter-sdk
+```
+
+Or in a Gemfile:
+
+```ruby
+gem "riveter-sdk", require: "riveter"
+```
+
+## Quickstart
+
+```ruby
+require "riveter"
+
+# Reads ENV["RIVETER_API_KEY"] when api_key: is not passed.
+# Get a key at https://app.riveterhq.com/settings/api
+riveter = Riveter::Client.new(api_key: "YOUR_API_KEY")
+
+run = riveter.enrich(
+  prompt: "Research each company",
+  attributes: ["CEO", "Employee Count"],
+  input: { "Company" => ["Apple", "Google"] }
+)
+
+result = riveter.runs.wait_for_result(run.id)
+puts result.output
+```
+
+## The run lifecycle
+
+Every async kickoff (`enrich`, `datasets.build`, `extractions.run`, ...) returns a run.
+
+```ruby
+riveter.runs.get(run.id)                           # status + progress
+riveter.runs.result(run.id, wait: 50)              # output (long-polls up to 50s)
+riveter.runs.wait_for_result(run.id, timeout: 600) # poll until finished
+riveter.runs.stop(run.id)                          # stop early
+```
+
+List runs with automatic pagination:
+
+```ruby
+riveter.runs.list(status: "success").auto_paging_each do |run|
+  puts run.id
+end
+```
+
+## Surface
+
+- `riveter.enrich(...)`, `riveter.quick_search(...)`, `riveter.scrape(...)`, `riveter.account`
+- `riveter.runs` — `get`, `result`, `stop`, `list`, `summary`, `wait_for_result`
+- `riveter.enrichments` — `list`, `create`, `get`, `update`, `build_dataset`
+- `riveter.datasets` — `build`, `extend_dataset`
+- `riveter.configured_datasets` — `build`
+- `riveter.extractions` — `create`, `get`, `run`
+- `riveter.monitors` — `create`, `list`, `get`, `update`, `runs`
+
+Responses are lightweight model objects; fields the SDK does not know yet stay reachable
+via `#raw` / `#[]`.
+
+## Errors and retries
+
+API failures raise `Riveter::APIError` with `#status`, `#type` (`not_found`,
+`insufficient_credits`, ...), `#message`, and optional `#details`. Network failures raise
+`Riveter::APIConnectionError` / `Riveter::APITimeoutError`. 429s are retried automatically
+using the `X-RateLimit-Reset` header; 5xx and network failures are retried for GETs.
+Configure with `max_retries:` and `timeout:`.
+
+## Options
+
+```ruby
+Riveter::Client.new(
+  api_key: "...",                           # default: ENV["RIVETER_API_KEY"]
+  base_url: "https://api.riveterhq.com/v1", # default: ENV["RIVETER_BASE_URL"], then this
+  timeout: 60,                              # keep above 50 for `wait` long-polls
+  max_retries: 2
+)
+```
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec
+```

data/lib/riveter/client.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "uri"
+
+module Riveter
+  # Client for the Riveter API. https://docs.riveterhq.com
+  class Client
+    DEFAULT_BASE_URL = "https://api.riveterhq.com/v1"
+
+    attr_reader :base_url, :timeout, :max_retries,
+                :runs, :enrichments, :datasets, :configured_datasets,
+                :extractions, :monitors
+
+    # api_key falls back to ENV["RIVETER_API_KEY"]; base_url falls back to
+    # ENV["RIVETER_BASE_URL"], then production. timeout (seconds) must exceed
+    # the 50s `wait` long-poll. max_retries covers 429s (any method) and
+    # 5xx/network failures (GETs only).
+    def initialize(api_key: nil, base_url: nil, timeout: 60, max_retries: 2)
+      @api_key = api_key || ENV.fetch("RIVETER_API_KEY", nil)
+      if @api_key.nil? || @api_key.empty?
+        raise Error, "Missing API key: pass api_key: or set RIVETER_API_KEY " \
+                     "(get one at https://app.riveterhq.com/settings/api)"
+      end
+
+      @base_url = (base_url || ENV.fetch("RIVETER_BASE_URL", nil) || DEFAULT_BASE_URL).sub(%r{/+\z}, "")
+      @timeout = timeout
+      @max_retries = max_retries
+      @runs = Resources::Runs.new(self)
+      @enrichments = Resources::Enrichments.new(self)
+      @datasets = Resources::Datasets.new(self)
+      @configured_datasets = Resources::ConfiguredDatasets.new(self)
+      @extractions = Resources::Extractions.new(self)
+      @monitors = Resources::Monitors.new(self)
+    end
+
+    # Start an enrichment run on rows of input data. (operationId: enrich)
+    def enrich(**params)
+      Run.new(request(:post, "/enrich", body: params))
+    end
+
+    # Run one web search synchronously; results are already in #output. (operationId: quickSearch)
+    def quick_search(**params)
+      Run.new(request(:post, "/quick_search", body: params))
+    end
+
+    # Scrape a webpage and return its text synchronously. (operationId: scrape)
+    def scrape(**params)
+      ScrapeResult.new(request(:post, "/scrape", body: params))
+    end
+
+    # Account, plan, and credit info for the API key. (operationId: getAccount)
+    def account
+      AccountInfo.new(request(:get, "/account"))
+    end
+
+    def request(method, path, query: nil, body: nil, timeout: nil)
+      uri = URI.parse(@base_url + path)
+      if query
+        compact = query.reject { |_key, value| value.nil? }
+        uri.query = URI.encode_www_form(compact) unless compact.empty?
+      end
+
+      retry_on_failure = method == :get
+      attempt = 0
+      loop do
+        response = begin
+          perform_http_request(method, uri, body, timeout || @timeout)
+        rescue Net::OpenTimeout, Net::ReadTimeout => e
+          if retry_on_failure && attempt < @max_retries
+            sleep(backoff_seconds(attempt))
+            attempt += 1
+            next
+          end
+          raise APITimeoutError, "Request timed out: #{method.to_s.upcase} #{path} (#{e.class})"
+        rescue SystemCallError, SocketError, IOError, OpenSSL::SSL::SSLError => e
+          if retry_on_failure && attempt < @max_retries
+            sleep(backoff_seconds(attempt))
+            attempt += 1
+            next
+          end
+          raise APIConnectionError, "Request failed: #{method.to_s.upcase} #{path}: #{e.message}"
+        end
+
+        status = response.code.to_i
+        return parse_json_body(response) if status.between?(200, 299)
+
+        if status == 429 && attempt < @max_retries
+          sleep(rate_limit_delay_seconds(response, attempt))
+          attempt += 1
+          next
+        end
+        if status >= 500 && retry_on_failure && attempt < @max_retries
+          sleep(backoff_seconds(attempt))
+          attempt += 1
+          next
+        end
+
+        raise APIError.from_response(status, parse_json_body(response))
+      end
+    end
+
+    private
+
+    def perform_http_request(method, uri, body, timeout)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+
+      request_class = { get: Net::HTTP::Get, post: Net::HTTP::Post, patch: Net::HTTP::Patch }.fetch(method)
+      request = request_class.new(uri)
+      request["Authorization"] = "Bearer #{@api_key}"
+      request["User-Agent"] = "riveter-sdk-ruby/#{VERSION}"
+      if body
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate(body.reject { |_key, value| value.nil? })
+      end
+
+      http.request(request)
+    end
+
+    def parse_json_body(response)
+      return nil if response.body.nil? || response.body.empty?
+
+      JSON.parse(response.body)
+    rescue JSON::ParserError
+      response.body
+    end
+
+    def backoff_seconds(attempt)
+      [0.5 * (2**attempt), 8].min
+    end
+
+    def rate_limit_delay_seconds(response, attempt)
+      reset = response["X-RateLimit-Reset"].to_f
+      return backoff_seconds(attempt) unless reset.positive?
+
+      [[reset - Time.now.to_f, 0].max, 30].min
+    end
+  end
+end

data/lib/riveter/errors.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Riveter
+  # Base class for every error raised by this SDK.
+  class Error < StandardError; end
+
+  # Network-level failure: the request never produced an HTTP response.
+  class APIConnectionError < Error; end
+
+  # A request or wait helper exceeded its time budget.
+  class APITimeoutError < APIConnectionError; end
+
+  # A non-2xx HTTP response, normalized across both error body dialects.
+  class APIError < Error
+    FALLBACK_TYPES = {
+      400 => "bad_request",
+      401 => "unauthorized",
+      403 => "forbidden",
+      404 => "not_found",
+      409 => "conflict",
+      422 => "validation",
+      429 => "rate_limited"
+    }.freeze
+
+    attr_reader :status, :type, :details
+
+    def initialize(status:, type:, message:, details: nil)
+      super(message)
+      @status = status
+      @type = type
+      @details = details
+    end
+
+    # Builds an APIError from either the clean { "error" => {...} } envelope
+    # or the legacy { "request_status" => "error" } shape (401s).
+    def self.from_response(status, body)
+      if body.is_a?(Hash)
+        error = body["error"]
+        if error.is_a?(Hash) && error["type"].is_a?(String)
+          return new(
+            status: status,
+            type: error["type"],
+            message: error["message"] || "HTTP #{status}",
+            details: error["details"]
+          )
+        end
+        if body["request_status"] == "error"
+          return new(
+            status: status,
+            type: body["error_type"] || "error",
+            message: body["message"] || "HTTP #{status}",
+            details: body["errors"]
+          )
+        end
+      end
+
+      message = body.is_a?(String) && !body.empty? ? body[0, 200] : "HTTP #{status}"
+      new(status: status, type: FALLBACK_TYPES[status] || "http_#{status}", message: message)
+    end
+  end
+end

data/lib/riveter/models.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Riveter
+  # Read-only view over a response hash: declared fields become reader methods,
+  # unknown fields stay reachable via #raw / #[].
+  class Model
+    attr_reader :raw
+
+    def initialize(raw)
+      @raw = raw.is_a?(Hash) ? raw : {}
+    end
+
+    def [](key)
+      @raw[key.to_s]
+    end
+
+    def to_h
+      @raw
+    end
+
+    def inspect
+      "#<#{self.class.name} #{@raw.inspect}>"
+    end
+
+    def self.field(*names)
+      names.each do |name|
+        define_method(name) { @raw[name.to_s] }
+      end
+    end
+
+    def self.model_field(name, model_class)
+      define_method(name) do
+        value = @raw[name.to_s]
+        value.nil? ? nil : model_class.new(value)
+      end
+    end
+  end
+
+  class RunProgress < Model
+    field :percent_complete, :estimated_seconds_remaining, :elapsed_seconds,
+          :completed_cells, :total_cells_expected, :not_found_cells
+  end
+
+  # The uniform run envelope returned by kickoffs and every /runs endpoint.
+  # Endpoint-specific kickoff extras (dataset_id, credits_charged, ...) are
+  # plain fields; #output is nil until the run finishes.
+  class Run < Model
+    field :id, :type, :status, :credits_used, :app_url, :result_url,
+          :started_at, :finished_at, :error, :enrichment_id, :enrichment_name,
+          :dataset_id, :extraction_id, :monitor_id, :webhook_url, :output,
+          :max_items, :enrichment_run_id, :source_dataset_id,
+          :configured_dataset_id, :credits_charged, :variables,
+          :validation_warning, :tier
+    model_field :progress, RunProgress
+
+    def finished?
+      %w[success stopped].include?(status)
+    end
+  end
+
+  class RunListItem < Model
+    field :id, :type, :status, :enrichment_id, :enrichment_name, :row_count,
+          :credits_used, :error, :created_at, :started_at, :finished_at,
+          :app_url, :result_url
+  end
+
+  class Pagination < Model
+    field :page, :per_page, :total_count, :total_pages
+  end
+
+  class RunsSummary < Model
+    field :counts
+  end
+
+  class EnrichmentSummary < Model
+    field :id, :name, :status, :app_url, :columns
+  end
+
+  class Enrichment < Model
+    field :id, :name, :status, :app_url, :input, :output, :dataset_id
+  end
+
+  class Extraction < Model
+    field :id, :name, :status, :app_url, :starting_url, :goal_description,
+          :output_record_json_schema, :required_keys, :locked,
+          :validation_passing, :discovered_at, :run_credits_required,
+          :credits_charged
+  end
+
+  class Monitor < Model
+    field :id, :name, :enabled, :cadence, :minute, :hour, :day_of_week,
+          :day_of_month, :timezone, :webhook_url, :alert_rule, :output_format,
+          :next_run_at, :schedule_summary, :enrichment_id, :enrichment_name,
+          :created_at, :has_input
+  end
+
+  # Synchronous scrape result (legacy request_status format, per the spec).
+  class ScrapeResult < Model
+    field :request_status, :text, :url, :base_url_for_links, :status_code,
+          :possibly_blocked, :credit_used, :riveter_app_link
+  end
+
+  class Credit < Model
+    field :count, :max, :balance
+  end
+
+  class Account < Model
+    field :uuid, :name, :plan
+    model_field :credit, Credit
+  end
+
+  class ApiKeyInfo < Model
+    field :name, :last_used_at, :created_by
+  end
+
+  # Account info (legacy request_status format, per the spec).
+  class AccountInfo < Model
+    field :request_status, :message
+    model_field :account, Account
+    model_field :api_key_info, ApiKeyInfo
+  end
+end

data/lib/riveter/page.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Riveter
+  # One page of runs. #each iterates the page; #auto_paging_each walks every
+  # following page too.
+  class RunsPage
+    include Enumerable
+
+    attr_reader :runs, :pagination, :monitor_id
+
+    def initialize(data, fetch_page)
+      data = data.is_a?(Hash) ? data : {}
+      @runs = (data["runs"] || []).map { |item| RunListItem.new(item) }
+      @pagination = Pagination.new(data["pagination"] || {})
+      @monitor_id = data["monitor_id"]
+      @fetch_page = fetch_page
+    end
+
+    def each(&block)
+      @runs.each(&block)
+    end
+
+    def next_page?
+      (pagination.page || 1) < (pagination.total_pages || 1)
+    end
+
+    def next_page
+      RunsPage.new(@fetch_page.call((pagination.page || 1) + 1), @fetch_page)
+    end
+
+    def auto_paging_each(&block)
+      return enum_for(:auto_paging_each) unless block
+
+      page = self
+      loop do
+        page.runs.each(&block)
+        break unless page.next_page?
+
+        page = page.next_page
+      end
+    end
+  end
+end

data/lib/riveter/resources.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module Riveter
+  module Resources
+    # The uniform lifecycle for every async operation — status, results, stop.
+    class Runs
+      def initialize(client)
+        @client = client
+      end
+
+      # Status and progress of a run. (operationId: getRun)
+      def get(run_id)
+        Run.new(@client.request(:get, "/runs/#{run_id}"))
+      end
+
+      # The run plus its #output (nil until finished). `wait` long-polls up to
+      # 50 seconds server-side. (operationId: getRunResult)
+      def result(run_id, wait: nil)
+        timeout = wait ? [@client.timeout, wait + 10].max : nil
+        Run.new(@client.request(:get, "/runs/#{run_id}/result", query: { wait: wait }, timeout: timeout))
+      end
+
+      # Stop a run early. (operationId: stopRun)
+      def stop(run_id)
+        Run.new(@client.request(:post, "/runs/#{run_id}/stop"))
+      end
+
+      # List the account's runs, newest first. (operationId: listRuns)
+      def list(**params)
+        fetch_page = ->(page) { @client.request(:get, "/runs", query: params.merge(page: page)) }
+        RunsPage.new(fetch_page.call(params[:page] || 1), fetch_page)
+      end
+
+      # All-time run counts by status. (operationId: runsSummary)
+      def summary
+        RunsSummary.new(@client.request(:get, "/runs/summary"))
+      end
+
+      # Polls #result with 50s long-polls until the run reaches success or
+      # stopped; raises APITimeoutError past the timeout (seconds).
+      def wait_for_result(run_id, timeout: 600, poll_wait: 50)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+        loop do
+          run = result(run_id, wait: poll_wait)
+          return run if run.finished?
+
+          if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+            raise APITimeoutError, "Run #{run_id} did not finish within #{timeout}s"
+          end
+        end
+      end
+    end
+
+    # Saved enrichment configurations.
+    class Enrichments
+      def initialize(client)
+        @client = client
+      end
+
+      # List enrichments with their output column configuration. (operationId: listEnrichments)
+      def list
+        response = @client.request(:get, "/enrichments")
+        (response["enrichments"] || []).map { |item| EnrichmentSummary.new(item) }
+      end
+
+      # Create an enrichment (no run) from a completed dataset build. (operationId: createEnrichment)
+      def create(dataset_id:)
+        Enrichment.new(@client.request(:post, "/enrichments", body: { dataset_id: dataset_id }))
+      end
+
+      # The enrichment's input columns and output column configuration. (operationId: getEnrichment)
+      def get(enrichment_id)
+        Enrichment.new(@client.request(:get, "/enrichments/#{enrichment_id}"))
+      end
+
+      # Add, update, rename, delete, or reorder output columns. (operationId: updateEnrichment)
+      def update(enrichment_id, **params)
+        @client.request(:patch, "/enrichments/#{enrichment_id}", body: params)
+      end
+
+      # Build a dataset shaped for this enrichment. (operationId: buildDatasetForEnrichment)
+      def build_dataset(enrichment_id, **params)
+        Run.new(@client.request(:post, "/enrichments/#{enrichment_id}/datasets", body: params))
+      end
+    end
+
+    # Dataset builds — generate rows from prompts or structured specs.
+    class Datasets
+      def initialize(client)
+        @client = client
+      end
+
+      # Build a dataset from a prompt, a structured spec, or both. (operationId: buildDataset)
+      def build(**params)
+        Run.new(@client.request(:post, "/datasets", body: params))
+      end
+
+      # Generate new deduplicated rows for a completed dataset build.
+      # Named extend_dataset because Object#extend is taken. (operationId: extendDataset)
+      def extend_dataset(dataset_id, **params)
+        Run.new(@client.request(:post, "/datasets/#{dataset_id}/extend", body: params))
+      end
+    end
+
+    # Reusable, pre-configured dataset templates (cds_...).
+    class ConfiguredDatasets
+      def initialize(client)
+        @client = client
+      end
+
+      # Run a configured dataset template. (operationId: buildConfiguredDataset)
+      def build(configured_dataset_id, **params)
+        Run.new(@client.request(:post, "/configured_datasets/#{configured_dataset_id}/build", body: params))
+      end
+    end
+
+    # Reusable site scrape/extract recipes and their runs.
+    class Extractions
+      def initialize(client)
+        @client = client
+      end
+
+      # Create an extraction and start its agent discovery. (operationId: createExtraction)
+      def create(**params)
+        Extraction.new(@client.request(:post, "/extractions", body: params))
+      end
+
+      # The extraction's status and definition. (operationId: getExtraction)
+      def get(extraction_id)
+        Extraction.new(@client.request(:get, "/extractions/#{extraction_id}"))
+      end
+
+      # Execute a ready extraction. (operationId: runExtraction)
+      def run(extraction_id, **params)
+        Run.new(@client.request(:post, "/extractions/#{extraction_id}/runs", body: params))
+      end
+    end
+
+    # Scheduled enrichment runs with webhooks.
+    class Monitors
+      def initialize(client)
+        @client = client
+      end
+
+      # Create a monitor that re-runs an enrichment on a schedule. (operationId: createMonitor)
+      def create(**params)
+        Monitor.new(@client.request(:post, "/monitors", body: params))
+      end
+
+      # List the account's monitors, newest first. (operationId: listMonitors)
+      def list
+        response = @client.request(:get, "/monitors")
+        (response["monitors"] || []).map { |item| Monitor.new(item) }
+      end
+
+      # The monitor's schedule, webhook, and next run time. (operationId: getMonitor)
+      def get(monitor_id)
+        Monitor.new(@client.request(:get, "/monitors/#{monitor_id}"))
+      end
+
+      # Pause, resume, or repoint a monitor. (operationId: updateMonitor)
+      def update(monitor_id, **params)
+        Monitor.new(@client.request(:patch, "/monitors/#{monitor_id}", body: params))
+      end
+
+      # The monitor's run history, newest first. (operationId: listMonitorRuns)
+      def runs(monitor_id, **params)
+        fetch_page = lambda do |page|
+          @client.request(:get, "/monitors/#{monitor_id}/runs", query: params.merge(page: page))
+        end
+        RunsPage.new(fetch_page.call(params[:page] || 1), fetch_page)
+      end
+    end
+  end
+end

data/lib/riveter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Riveter
+  VERSION = "0.1.0"
+end

data/lib/riveter.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "riveter/version"
+require "riveter/errors"
+require "riveter/models"
+require "riveter/page"
+require "riveter/resources"
+require "riveter/client"
+
+# Official Ruby SDK for the Riveter API. https://docs.riveterhq.com
+module Riveter
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: riveter-sdk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Riveter
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Client for the Riveter API — enrich data, build datasets, scrape pages,
+  and run web searches. https://docs.riveterhq.com
+email:
+- support@riveterhq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/riveter.rb
+- lib/riveter/client.rb
+- lib/riveter/errors.rb
+- lib/riveter/models.rb
+- lib/riveter/page.rb
+- lib/riveter/resources.rb
+- lib/riveter/version.rb
+homepage: https://docs.riveterhq.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://docs.riveterhq.com
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Official Ruby SDK for the Riveter API
+test_files: []