fal 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 294f1aa2fea312c2b0a42b2fe97753e45a8d8807083d5a60a3c739b7bdd722f6
-  data.tar.gz: 93fb4193c178ffd22bfddeffab3926a4288afd89e42f9bd418d9a71ce45c2645
+  metadata.gz: f22dff48b2f5121df441220f3fffe41f3e548c8a2c229dd0f1c7d3c19072b74f
+  data.tar.gz: 8e5c092fb5246f8ea7ee88b80123e63d5ed7384f37b1cfc61474bcd3daef1431
 SHA512:
-  metadata.gz: 3d328838cdf0dc3eff20b2275ecff9528d90bf8d549272b663f0b985b7fd2d3744e4a60e5b621a96a7a3f9a549b506e28f83776c5c84514d9d541fc376ed27d0
-  data.tar.gz: 112f8673d40fd9195c1b157656e2f1c9dc8208e14c460207672cefd8e2264fac2f9857df17a11d2d174f9617c7771700f71e71ed797d6f1c820fcd9613cd472d
+  metadata.gz: '05697e66efb4f7d26fb110d707627755395244fa5a9fca86d3624e4bd6d33cae7a42ccbe625cd14dd8646b4a934496e2f169247a387ad046cf049ece487eb0d4'
+  data.tar.gz: b7bd9bf3bddb0f1a62ed61bb9d681a5531f4e00ff628cbc4a77b720e4367ef9a6d7a45253bb4777654e078c1e55e67ab6aaa95cebb2bf83ebc0e4a28df5b49c0

data/.env.example

@@ -0,0 +1 @@
+FAL_KEY=

data/Gemfile

@@ -7,3 +7,4 @@ gemspec
 gem "minitest", "~> 5.0"
 gem "rake", "~> 13.0"
 gem "rubocop", "~> 1.21"
+gem "dotenv"

data/Gemfile.lock

@@ -1,13 +1,14 @@
 PATH
   remote: .
   specs:
-    fal (0.0.1)
+    fal (0.0.3)
       faraday (>= 1)
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
+    dotenv (3.1.8)
     faraday (2.14.0)
       faraday-net_http (>= 2.0, < 3.5)
       json
@@ -53,6 +54,7 @@ PLATFORMS
   x86_64-darwin-23
 
 DEPENDENCIES
+  dotenv
   fal!
   minitest (~> 5.0)
   rake (~> 13.0)

data/README.md

@@ -9,3 +9,168 @@ Install the gem and add to the application"s Gemfile by executing:
 If bundler is not being used to manage dependencies, install the gem by executing:
 
     $ gem install fal
+
+## Usage
+
+### Configuration
+
+Configure the client once at boot (e.g., in Rails an initializer) using `Fal.configure`.
+
+```ruby
+Fal.configure do |config|
+  config.api_key = "your-key" # Optional. Defaults to ENV["FAL_KEY"] if not set.
+  config.queue_base = "https://queue.fal.run" # Optional (default: https://queue.fal.run)
+  config.sync_base = "https://fal.run" # Optional (default: https://fal.run)
+  config.request_timeout = 120 # Optional (default: 120)
+end
+```
+
+### Create a queued request
+
+The Queue API is the recommended way to call models on fal. Provide a `model_id` in "namespace/name" format and an input payload.
+
+```ruby
+model_id = "fal-ai/fast-sdxl"
+
+request = Fal::Request.create!(
+  model_id: model_id,
+  input: { prompt: "a cat" }
+)
+
+request.id       # => request_id from fal
+request.status   # => "IN_QUEUE" | "IN_PROGRESS" | "COMPLETED"
+```
+
+You can also specify a webhook URL to be notified when the request is finished.
+
+```ruby
+request = Fal::Request.create!(
+  model_id: model_id,
+  input: { prompt: "a cat playing piano" },
+  webhook_url: "https://example.com/fal/webhook"
+)
+```
+
+### Get request status (find and reload)
+
+Fetch the current status by id:
+
+```ruby
+status = Fal::Request.find_by!(id: request.id, model_id: model_id)
+status.in_queue?      # => true/false
+status.in_progress?   # => true/false
+status.completed?     # => true/false
+```
+
+Reload an instance in-place, optionally including logs.
+
+```ruby
+request.reload!           # refreshes state
+request.reload!(logs: true)
+request.logs              # => array of log entries (if provided by model and logs=1)
+# When status is COMPLETED, reload! will also fetch and set request.response
+```
+
+Status constants are available for direct comparisons:
+
+```ruby
+Fal::Request::Status::IN_QUEUE
+Fal::Request::Status::IN_PROGRESS
+Fal::Request::Status::COMPLETED
+```
+
+### Fetch the response payload after completion
+
+Call `reload!` to populate `request.response`:
+
+```ruby
+# poll until completed
+until request.completed?
+  request.reload!
+  sleep 1
+end
+
+request.response   # => model-specific response body
+```
+
+### Cancel a request
+
+Requests that are still in the queue can be cancelled:
+
+```ruby
+request.cancel! # => { "status" => "CANCELLATION_REQUESTED" }
+```
+
+### Webhooks
+
+fal can POST a webhook to your server when a request completes. Use `Fal::WebhookRequest` to parse the incoming payload.
+
+```ruby
+# rails controller example
+class FalWebhooksController < ApplicationController
+  skip_before_action :verify_authenticity_token
+
+  def create
+    webhook = Fal::WebhookRequest.from_rack_request(request)
+
+    if webhook.success?
+      # webhook.response contains the model-specific payload
+      # webhook.logs, webhook.metrics may also be present
+      head :ok
+    else
+      Rails.logger.error("fal webhook error: #{webhook.error} detail=#{webhook.error_detail}")
+      head :ok
+    end
+  end
+end
+```
+
+### Error handling
+
+HTTP and API errors raise typed exceptions:
+
+- `Fal::UnauthorizedError` (401)
+- `Fal::ForbiddenError` (403)
+- `Fal::NotFoundError` (404)
+- `Fal::ServerError` (other non-success)
+
+Rescue them as needed:
+
+```ruby
+begin
+  Fal::Request.create!(model_id: model_id, input: { prompt: "hi" })
+rescue Fal::UnauthorizedError
+  # handle invalid/missing FAL_KEY
+end
+```
+
+### Stream synchronous responses
+
+Use `stream!` for SSE streaming from synchronous endpoints. It yields each chunk’s data Hash and returns a `Fal::Request` whose `response` contains the last chunk’s payload.
+
+```ruby
+model_id = "fal-ai/flux/dev"
+
+last = Fal::Request.stream!(model_id: model_id, input: { prompt: "a cat" }) do |chunk|
+  # chunk is a Hash, e.g. { images: [...] }
+  puts chunk
+end
+
+last.completed?    # => true/false
+last.response      # => last streamed data hash (e.g., { "response" => { ... } } or final payload)
+```
+
+### Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to rubygems.org.
+
+For local development, copy the example environment file and set your API key so `bin/console` can load it automatically:
+
+```
+cp .env.example .env
+echo 'FAL_KEY=your_api_key_here' >> .env
+```
+
+The console uses dotenv to load `.env`, so `Fal.configure` will default to `ENV["FAL_KEY"]`.

data/lib/fal/client.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Fal
+  class Client
+    attr_accessor :configuration
+
+    def initialize(configuration = Fal.configuration)
+      @configuration = configuration
+    end
+
+    def post(path, payload = {}, headers: {})
+      response = connection.post(build_url(path)) do |request|
+        request.headers["Authorization"] = "Key #{@configuration.api_key}" if @configuration.api_key
+        request.headers["Content-Type"] = "application/json"
+        request.headers["Accept"] = "application/json"
+        request.headers.merge!(headers)
+        request.body = payload.compact.to_json
+      end
+
+      handle_error(response) unless response.success?
+
+      parse_json(response.body)
+    end
+
+    # Perform a POST to the streaming (sync) base with SSE/text-event-stream handling.
+    # The provided on_data Proc will be used to receive chunked data.
+    # @param path [String]
+    # @param payload [Hash]
+    # @param on_data [Proc] called with chunks as they arrive
+    # @return [void]
+    def post_stream(path, payload = {}, on_data:)
+      url = build_sync_url(path)
+      connection.post(url) do |request|
+        request.headers["Authorization"] = "Key #{@configuration.api_key}" if @configuration.api_key
+        request.headers["Accept"] = "text/event-stream"
+        request.headers["Cache-Control"] = "no-store"
+        request.headers["Content-Type"] = "application/json"
+        request.body = payload.compact.to_json
+        request.options.on_data = on_data
+      end
+    end
+
+    def get(path, query: nil, headers: {})
+      url = build_url(path)
+      url = "#{url}?#{URI.encode_www_form(query)}" if query && !query.empty?
+
+      response = connection.get(url) do |request|
+        request.headers["Authorization"] = "Key #{@configuration.api_key}" if @configuration.api_key
+        request.headers["Accept"] = "application/json"
+        request.headers.merge!(headers)
+      end
+
+      handle_error(response) unless response.success?
+
+      parse_json(response.body)
+    end
+
+    def put(path)
+      response = connection.put(build_url(path)) do |request|
+        request.headers["Authorization"] = "Key #{@configuration.api_key}" if @configuration.api_key
+        request.headers["Content-Type"] = "application/json"
+        request.headers["Accept"] = "application/json"
+        request.body = {}.to_json
+      end
+
+      handle_error(response) unless response.success?
+
+      parse_json(response.body)
+    end
+
+    def handle_error(response)
+      case response.status
+      when 401
+        raise UnauthorizedError, response.body
+      when 403
+        raise ForbiddenError, response.body
+      when 404
+        raise NotFoundError, response.body
+      else
+        raise ServerError, response.body
+      end
+    end
+
+    private
+
+    def parse_json(body)
+      return nil if body.nil? || body.strip.empty?
+
+      JSON.parse(body)
+    end
+
+    def build_url(path)
+      "#{@configuration.queue_base}#{path}"
+    end
+
+    def build_sync_url(path)
+      "#{@configuration.sync_base}#{path}"
+    end
+
+    def connection
+      Faraday.new do |faraday|
+        faraday.request :url_encoded
+        faraday.options.timeout = @configuration.request_timeout
+        faraday.options.open_timeout = @configuration.request_timeout
+      end
+    end
+  end
+end

data/lib/fal/request.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Fal
+  # Represents a queued request submitted to a fal model endpoint.
+  # Provides helpers to create, query status, cancel, and fetch response payloads
+  # using the Queue API described in the fal docs.
+  # See: https://docs.fal.ai/model-apis/model-endpoints/queue
+  class Request
+    # Request status values returned by the Queue API.
+    module Status
+      # @return [String]
+      IN_QUEUE = "IN_QUEUE"
+      # @return [String]
+      IN_PROGRESS = "IN_PROGRESS"
+      # @return [String]
+      COMPLETED = "COMPLETED"
+    end
+
+    # @return [String] The request identifier (request_id)
+    attr_reader :id
+    # @return [String] The current status, one of Fal::Request::Status constants
+    attr_reader :status
+    # @return [Integer, nil] The current position in the queue, if available
+    attr_reader :queue_position
+    # @return [Array<Hash>, nil] Log entries when requested via logs=1
+    attr_reader :logs
+    # @return [Hash, nil] Response payload when status is COMPLETED
+    attr_reader :response
+    # @return [String] The model identifier used when creating this request
+    attr_reader :model_id
+
+    # @param attributes [Hash] Raw attributes from fal Queue API
+    # @param model_id [String] Model ID in "namespace/name" format
+    # @param client [Fal::Client] HTTP client to use for subsequent calls
+    def initialize(attributes, model_id:, client: Fal.client)
+      @client = client
+      @model_id = model_id
+      reset_attributes(attributes)
+    end
+
+    class << self
+      # Create a new queued request for a model.
+      # Corresponds to POST https://queue.fal.run/{model_id}
+      # Optionally appends fal_webhook query param per docs.
+      # @param model_id [String]
+      # @param input [Hash]
+      # @param webhook_url [String, nil]
+      # @param client [Fal::Client]
+      # @return [Fal::Request]
+      def create!(model_id:, input:, webhook_url: nil, client: Fal.client)
+        path = "/#{model_id}"
+        body = input || {}
+        path = "#{path}?fal_webhook=#{CGI.escape(webhook_url)}" if webhook_url
+        attrs = client.post(path, body)
+        new(attrs, model_id: model_id, client: client)
+      end
+
+      # Find the current status for a given request.
+      # Corresponds to GET https://queue.fal.run/{model_id}/requests/{request_id}/status
+      # @param id [String]
+      # @param model_id [String]
+      # @param logs [Boolean] include logs if true
+      # @param client [Fal::Client]
+      # @return [Fal::Request]
+      def find_by!(id:, model_id:, logs: false, client: Fal.client)
+        model_id_without_subpath = model_id.split("/").slice(0, 2).join("/")
+        attrs = client.get("/#{model_id_without_subpath}/requests/#{id}/status", query: (logs ? { logs: 1 } : nil))
+        new(attrs, model_id: model_id, client: client)
+      end
+
+      # Stream a synchronous request using SSE and yield response chunks as they arrive.
+      # It returns a Fal::Request initialized with the last streamed data in the response field.
+      # @param model_id [String]
+      # @param input [Hash]
+      # @param client [Fal::Client]
+      # @yield [chunk] yields each parsed chunk Hash from the stream
+      # @yieldparam chunk [Hash]
+      # @return [Fal::Request]
+      def stream!(model_id:, input:, client: Fal.client, &block)
+        path = "/#{model_id}/stream"
+        last_data = nil
+
+        Stream.new(path: path, input: input, client: client).each do |event|
+          data = event["data"]
+          last_data = data
+          block&.call(data)
+        end
+
+        # Wrap last chunk into a Request-like object for convenience
+        # Build attributes from last event, using inner response if available
+        response_payload = if last_data&.key?("response")
+                             last_data["response"]
+                           else
+                             last_data
+                           end
+        attrs = {
+          "request_id" => last_data && last_data["request_id"],
+          "status" => last_data && last_data["status"],
+          "response" => response_payload
+        }.compact
+        new(attrs, model_id: model_id, client: client)
+      end
+    end
+
+    # @return [String] The model ID without the subpath
+    def model_id_without_subpath
+      @model_id.split("/").slice(0, 2).join("/")
+    end
+
+    # Reload the current status from the Queue API.
+    # @param logs [Boolean] include logs if true
+    # @return [Fal::Request]
+    def reload!(logs: false)
+      if @status == Status::IN_PROGRESS || @status == Status::IN_QUEUE
+        attrs = @client.get("/#{model_id_without_subpath}/requests/#{@id}/status", query: (logs ? { logs: 1 } : nil))
+        reset_attributes(attrs)
+      end
+
+      @response = @client.get("/#{model_id_without_subpath}/requests/#{@id}") if @status == Status::COMPLETED
+
+      self
+    end
+
+    # Attempt to cancel the request if still in queue.
+    # @return [Hash] cancellation response
+    def cancel!
+      @client.put("/#{model_id_without_subpath}/requests/#{@id}/cancel")
+    end
+
+    # @return [Boolean]
+    def in_queue?
+      @status == Status::IN_QUEUE
+    end
+
+    # @return [Boolean]
+    def in_progress?
+      @status == Status::IN_PROGRESS
+    end
+
+    # @return [Boolean]
+    def completed?
+      @status == Status::COMPLETED
+    end
+
+    private
+
+    # Normalize attributes from different Queue API responses.
+    # @param attributes [Hash]
+    # @return [void]
+    def reset_attributes(attributes)
+      @id = attributes["request_id"] || @id
+      # Default to IN_QUEUE if no status provided and no previous status
+      @status = attributes["status"] || @status || Status::IN_QUEUE
+      @queue_position = attributes["queue_position"]
+      @logs = attributes["logs"]
+      @response = attributes["response"]
+    end
+  end
+end

data/lib/fal/stream.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Fal
+  # Streaming helper for Server-Sent Events from fal.run synchronous endpoints.
+  # It parses SSE lines and yields decoded event hashes with symbolized keys.
+  class Stream
+    # @return [String] endpoint path under fal.run, e.g. "/fal-ai/flux/dev/stream"
+    attr_reader :path
+
+    # @param path [String] full path under sync_base (leading slash), ex: "/fal-ai/flux/dev/stream"
+    # @param input [Hash] request input payload
+    # @param client [Fal::Client] HTTP client
+    def initialize(path:, input:, client: Fal.client)
+      @path = path
+      @input = input
+      @client = client
+    end
+
+    # Stream events; yields a Hash for each event data chunk. Blocks until stream ends.
+    # @yield [event] yields decoded event hash
+    # @yieldparam event [Hash]
+    # @return [void]
+    def each(&block)
+      buffer = ""
+      decoder = SSEDecoder.new
+
+      @client.post_stream(@path, @input, on_data: proc do |chunk, _total_bytes|
+        buffer = (buffer + chunk).gsub(/\r\n?/, "\n")
+        lines = buffer.split("\n", -1)
+        buffer = lines.pop || ""
+        lines.each do |line|
+          event = decoder.decode(line)
+          block.call(event) if event
+        end
+      end)
+    end
+
+    # Minimal SSE decoder for parsing standard server-sent event stream lines.
+    class SSEDecoder
+      def initialize
+        @event = ""
+        @data = ""
+        @id = nil
+        @retry = nil
+      end
+
+      # @param line [String]
+      # @return [Hash, nil]
+      def decode(line)
+        return flush_event if line.empty?
+        return if line.start_with?(":")
+
+        field, _, value = line.partition(":")
+        value = value.lstrip
+
+        case field
+        when "event"
+          @event = value
+        when "data"
+          @data += "#{value}\n"
+        when "id"
+          @id = value
+        when "retry"
+          @retry = value.to_i
+        end
+
+        nil
+      end
+
+      private
+
+      def flush_event
+        return if @data.empty?
+
+        data = @data.chomp
+        parsed = JSON.parse(data)
+
+        event = { "data" => parsed }
+        event["event"] = @event unless @event.empty?
+        event["id"] = @id if @id
+        event["retry"] = @retry if @retry
+
+        @event = ""
+        @data = ""
+        @id = nil
+        @retry = nil
+
+        event
+      end
+    end
+  end
+end

data/lib/fal/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Fal
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/lib/fal/webhook_request.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Fal
+  # WebhookRequest parses incoming webhook payloads from fal and exposes
+  # convenient helpers to inspect success/error and access the response payload.
+  # Follows Rails-like naming with predicate helpers.
+  class WebhookRequest
+    # Webhook status values.
+    module Status
+      # @return [String]
+      OK = "OK"
+      # @return [String]
+      ERROR = "ERROR"
+    end
+
+    # @return [String, nil] The request identifier
+    attr_reader :request_id
+    # @return [String, nil] The gateway request identifier, when present
+    attr_reader :gateway_request_id
+    # @return [String, nil] Webhook status (OK/ERROR) when provided
+    attr_reader :status
+    # @return [String, nil] Error message when provided
+    attr_reader :error
+    # @return [Hash, nil] Model-specific response payload
+    attr_reader :response
+    # @return [Array<Hash>, nil] Log entries, when present
+    attr_reader :logs
+    # @return [Hash, nil] Metrics, when present
+    attr_reader :metrics
+    # @return [Hash] The raw parsed payload
+    attr_reader :raw
+
+    # Initialize from a parsed payload Hash (string keys expected, tolerant of symbol keys).
+    # @param attributes [Hash]
+    def initialize(attributes)
+      @raw = attributes
+      reset_attributes(attributes)
+    end
+
+    class << self
+      # Build from a JSON string body.
+      # @param json [String]
+      # @return [Fal::WebhookRequest]
+      def from_json(json)
+        new(JSON.parse(json))
+      end
+
+      # Build from a Rack::Request.
+      # @param req [#body]
+      # @return [Fal::WebhookRequest]
+      def from_rack_request(req)
+        body = req.body.read
+        req.body.rewind if req.body.respond_to?(:rewind)
+        from_json(body)
+      end
+
+      # Build from a Hash payload.
+      # @param payload [Hash]
+      # @return [Fal::WebhookRequest]
+      def from_hash(payload)
+        new(payload)
+      end
+    end
+
+    # @return [Boolean]
+    def success?
+      @status == Status::OK || (
+        @status.nil? && @error.nil?
+      )
+    end
+
+    # @return [Boolean]
+    def error?
+      !success?
+    end
+
+    # Back-compat alias matching older naming (payload vs response).
+    # @return [Hash, nil]
+    def payload
+      @response
+    end
+
+    # @return [String, nil] Any nested error detail
+    def error_detail = @response&.dig(:detail)
+
+    private
+
+    def reset_attributes(attributes)
+      attributes = Fal.deep_symbolize_keys(attributes)
+      @request_id = attributes[:request_id]
+      @gateway_request_id = attributes[:gateway_request_id]
+      @status = attributes[:status]
+      @error = attributes[:error]
+      @response = attributes[:payload]
+      @logs = attributes[:logs]
+      @metrics = attributes[:metrics]
+    end
+  end
+end

data/lib/fal.rb

@@ -2,6 +2,99 @@
 
 require "faraday"
 require "time"
+require "json"
+require "cgi"
+require "uri"
+
+require_relative "fal/version"
 
 module Fal
+  # Base error class for all fal-related errors.
+  class Error < StandardError; end
+  # Raised when a request is unauthorized (HTTP 401).
+  class UnauthorizedError < Error; end
+  # Raised when a requested resource is not found (HTTP 404).
+  class NotFoundError < Error; end
+  # Raised when the server returns an unexpected error (HTTP 5xx or others).
+  class ServerError < Error; end
+  # Raised when the client is misconfigured.
+  class ConfigurationError < Error; end
+  # Raised when access is forbidden (HTTP 403).
+  class ForbiddenError < Error; end
+
+  # Global configuration for the fal client.
+  class Configuration
+    DEFAULT_QUEUE_BASE = "https://queue.fal.run"
+    DEFAULT_SYNC_BASE = "https://fal.run"
+    DEFAULT_REQUEST_TIMEOUT = 120
+
+    # API key used for authenticating with fal endpoints.
+    # Defaults to ENV["FAL_KEY"].
+    # @return [String]
+    attr_accessor :api_key
+
+    # Base URL for fal queue endpoints.
+    # @return [String]
+    attr_accessor :queue_base
+
+    # Base URL for synchronous streaming endpoints (fal.run).
+    # @return [String]
+    attr_accessor :sync_base
+
+    # Timeout in seconds for opening and processing HTTP requests.
+    # @return [Integer]
+    attr_accessor :request_timeout
+
+    # Initialize configuration with sensible defaults.
+    # @return [Fal::Configuration]
+    def initialize
+      @api_key = ENV.fetch("FAL_KEY", nil)
+      @queue_base = DEFAULT_QUEUE_BASE
+      @sync_base = DEFAULT_SYNC_BASE
+      @request_timeout = DEFAULT_REQUEST_TIMEOUT
+    end
+  end
+
+  class << self
+    # The global configuration instance.
+    # @return [Fal::Configuration]
+    attr_accessor :configuration
+
+    # Configure the fal client.
+    # @yield [Fal::Configuration] the configuration object to mutate
+    # @return [void]
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration)
+    end
+
+    # Global client accessor using the configured settings.
+    # @return [Fal::Client]
+    def client
+      configuration = self.configuration || Configuration.new
+      @client ||= Fal::Client.new(configuration)
+    end
+
+    # Deep symbolize keys of a Hash or Array.
+    # @param obj [Hash, Array]
+    # @return [Hash, Array]
+    def deep_symbolize_keys(obj)
+      case obj
+      when Hash
+        obj.each_with_object({}) do |(k, v), result|
+          key = k.is_a?(String) ? k.to_sym : k
+          result[key] = deep_symbolize_keys(v)
+        end
+      when Array
+        obj.map { |e| deep_symbolize_keys(e) }
+      else
+        obj
+      end
+    end
+  end
 end
+
+require_relative "fal/client"
+require_relative "fal/request"
+require_relative "fal/stream"
+require_relative "fal/webhook_request"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fal
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Dylan Player
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-10-03 00:00:00.000000000 Z
+date: 2025-10-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -31,6 +31,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".env.example"
 - ".rubocop.yml"
 - ".ruby-version"
 - Gemfile
@@ -40,7 +41,11 @@ files:
 - Rakefile
 - fal.gemspec
 - lib/fal.rb
+- lib/fal/client.rb
+- lib/fal/request.rb
+- lib/fal/stream.rb
 - lib/fal/version.rb
+- lib/fal/webhook_request.rb
 homepage: https://github.com/851-labs/fal
 licenses:
 - MIT