rager 0.5.0 → 0.7.0

data/lib/rager/errors/options_error.rb

@@ -8,11 +8,16 @@ module Rager
     class OptionsError < Rager::Error
       extend T::Sig
 
-      sig { params(invalid_keys: T::Array[String], description: T.nilable(String)).void }
-      def initialize(invalid_keys:, description: nil)
-        message = "Invalid keys #{invalid_keys.join(", ")}"
-        message += " (#{description})" if description
-        super(message)
+      sig { params(options: Rager::Types::Options, invalid_keys: T::Array[String], details: T.nilable(String)).void }
+      def initialize(options, invalid_keys, details: nil)
+        error_data = {
+          type: "options",
+          options: options.serialize_safe,
+          invalid_keys: invalid_keys,
+          details: details
+        }
+
+        super(error_data.to_json)
       end
     end
   end

data/lib/rager/errors/parse_error.rb

@@ -8,11 +8,15 @@ module Rager
     class ParseError < Rager::Error
       extend T::Sig
 
-      sig { params(description: String, body: T.nilable(String)).void }
-      def initialize(description, body = nil)
-        message = description
-        message += " -- #{body}" if body
-        super(message)
+      sig { params(body: String, details: T.nilable(String)).void }
+      def initialize(body, details: nil)
+        error_data = {
+          type: "parse",
+          body: body,
+          details: details
+        }
+
+        super(error_data.to_json)
       end
     end
   end

data/lib/rager/errors/template_error.rb

@@ -8,10 +8,16 @@ module Rager
     class TemplateError < Rager::Error
       extend T::Sig
 
-      sig { params(input: Rager::Template::Input, message: String).void }
-      def initialize(input, message)
-        message = "Template Error: #{message} in #{input.template}"
-        super(message)
+      sig { params(template: String, variables: T::Hash[Symbol, T.untyped], details: T.nilable(String)).void }
+      def initialize(template, variables, details: nil)
+        error_data = {
+          type: "template",
+          template: template,
+          variables: variables,
+          details: details
+        }
+
+        super(error_data.to_json)
       end
     end
   end

data/lib/rager/errors/timeout_error.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Errors
+    class TimeoutError < Rager::Error
+      extend T::Sig
+
+      sig { params(operation: String, timeout_seconds: T.nilable(Numeric), attempts: T.nilable(Integer), details: T.nilable(String)).void }
+      def initialize(operation, timeout_seconds: nil, attempts: nil, details: nil)
+        error_data = {
+          type: "timeout",
+          operation: operation,
+          timeout_seconds: timeout_seconds,
+          attempts: attempts,
+          details: details
+        }
+
+        super(error_data.to_json)
+      end
+    end
+  end
+end

data/lib/rager/http/adapters/async_http.rb

@@ -11,7 +11,11 @@ module Rager
 
         sig { void }
         def initialize
-          require "async/http"
+          begin
+            require "async/http"
+          rescue LoadError
+            raise Rager::Errors::DependencyError.new("async-http", details: "Please install the async-http gem to use the AsyncHttp adapter")
+          end
 
           @internet = T.let(Async::HTTP::Internet.new, Async::HTTP::Internet)
         end
@@ -22,22 +26,21 @@ module Rager
           ).returns(Rager::Http::Response)
         }
         def make_request(request)
-          response = @internet.call(
-            request.verb.serialize,
-            request.url,
-            request.headers.to_a,
-            request.body
-          )
+          response = wrap_if_timeout(request.timeout) do
+            @internet.call(
+              request.verb.serialize,
+              request.url,
+              request.headers.to_a,
+              request.body
+            )
+          end
 
           body = if response.body.nil?
             nil
-          elsif (response.headers["Transfer-Encoding"]&.downcase == "chunked") ||
-              response.headers["content-type"]&.downcase&.include?("text/event-stream")
+          elsif request.streaming
             body_enum(response)
           else
-            body_parts = []
-            response.body.each { |chunk| body_parts << chunk }
-            body_parts.join.force_encoding("UTF-8")
+            response.body.join
           end
 
           Response.new(
@@ -45,9 +48,58 @@ module Rager
             headers: response.headers.to_h,
             body: body
           )
+        rescue SocketError => e
+          raise Rager::Errors::HttpError.new(
+            self,
+            request.url,
+            0,
+            body: nil,
+            details: "DNS resolution failed: #{e.message}"
+          )
+        rescue Errno::ECONNREFUSED => e
+          raise Rager::Errors::HttpError.new(
+            self,
+            request.url,
+            0,
+            body: nil,
+            details: "Connection refused: #{e.message}"
+          )
+        rescue Errno::ETIMEDOUT => e
+          raise Rager::Errors::HttpError.new(
+            self,
+            request.url,
+            0,
+            body: nil,
+            details: "Connection timed out: #{e.message}"
+          )
+        rescue Async::TimeoutError => e
+          raise Rager::Errors::HttpError.new(
+            self,
+            request.url,
+            0,
+            body: nil,
+            details: "Request timed out: #{e.message}"
+          )
+        rescue EOFError => e
+          raise Rager::Errors::HttpError.new(
+            self,
+            request.url,
+            0,
+            body: nil,
+            details: "Connection closed unexpectedly: #{e.message}"
+          )
         end
 
-        private
+        sig { params(timeout: T.nilable(Numeric), block: T.proc.returns(T.untyped)).returns(T.untyped) }
+        def wrap_if_timeout(timeout, &block)
+          if timeout
+            Async::Task.current.with_timeout(timeout) do
+              block.call
+            end
+          else
+            block.call
+          end
+        end
 
         sig {
           params(
@@ -56,7 +108,7 @@ module Rager
         }
         def body_enum(response)
           Enumerator.new do |yielder|
-            response.body.each { |chunk| yielder << chunk.force_encoding("UTF-8") }
+            response.body.each { |chunk| yielder << chunk }
           ensure
             response.close
           end

data/lib/rager/http/adapters/mock.rb

@@ -1,8 +1,10 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "base64"
 require "fileutils"
 require "json"
+
 require "sorbet-runtime"
 
 module Rager
@@ -20,13 +22,9 @@ module Rager
             chunk_delimiter: T.nilable(String)
           ).void
         end
-        def initialize(
-          test_file_path,
-          fallback_adapter = nil,
-          chunk_delimiter = nil
-        )
+        def initialize(test_file_path, fallback_adapter = nil, chunk_delimiter = nil)
           @test_file_path = T.let(test_file_path, String)
-          @fallback_adapter = T.let(fallback_adapter || Rager::Http::Adapters::AsyncHttp.new, Rager::Http::Adapters::Abstract)
+          @fallback_adapter = T.let(fallback_adapter || Rager::Http::Adapters::NetHttp.new, Rager::Http::Adapters::Abstract)
           @cache = T.let(load_cache, Cache)
         end
 
@@ -34,48 +32,48 @@ module Rager
         def make_request(request)
           key = request.serialize.to_json
           cached_entry = @cache[key]
-          if cached_entry
-            build_response_from_cache(cached_entry)
-          else
-            fetch_and_cache_response(request, key)
-          end
+          cached_entry ? build_response_from_cache(cached_entry) : fetch_and_cache_response(request, key)
         end
 
-        sig {
-          params(
-            request: Rager::Http::Request,
-            key: String
-          ).returns(Rager::Http::Response)
-        }
+        sig { params(request: Rager::Http::Request, key: String).returns(Rager::Http::Response) }
         def fetch_and_cache_response(request, key)
           response = @fallback_adapter.make_request(request)
 
-          serialized_response = T.let({
+          serialized_response = {
             "status" => response.status,
             "headers" => response.headers
-          }, T::Hash[String, T.untyped])
+          }
 
-          if response.body.is_a?(Enumerator)
-            chunks = T.let([], T::Array[String])
+          if request.streaming && response.body.is_a?(Enumerator)
+            raw_chunks = T.let([], T::Array[String])
+            T.cast(response.body, T::Enumerator[String]).each { |chunk| raw_chunks << chunk }
 
-            T.cast(response.body, T::Enumerator[String]).each do |chunk|
-              chunks << chunk
-            end
+            has_binary = raw_chunks.any? { |chunk| binary_content?(chunk) }
+            chunks = raw_chunks.map { |chunk| binary_content?(chunk) ? Base64.strict_encode64(chunk) : chunk }
 
             serialized_response["body"] = chunks
             serialized_response["is_stream"] = true
+            serialized_response["is_binary"] = has_binary
 
             response_body = Enumerator.new do |yielder|
-              chunks.each { |chunk| yielder << chunk }
+              raw_chunks.each { |chunk| yielder << chunk }
             end
           else
-            serialized_response["body"] = response.body
+            body = T.cast(response.body, T.nilable(String)) || ""
+
+            if binary_content?(body)
+              serialized_response["body"] = Base64.strict_encode64(body)
+              serialized_response["is_binary"] = true
+            else
+              serialized_response["body"] = body
+              serialized_response["is_binary"] = false
+            end
+
             serialized_response["is_stream"] = false
-            response_body = response.body
+            response_body = body
           end
 
           @cache[key] = serialized_response
-
           save_cache
 
           Rager::Http::Response.new(
@@ -85,19 +83,19 @@ module Rager
           )
         end
 
-        sig {
-          params(
-            entry: T::Hash[String, T.untyped]
-          ).returns(Rager::Http::Response)
-        }
+        sig { params(entry: T::Hash[String, T.untyped]).returns(Rager::Http::Response) }
         def build_response_from_cache(entry)
           body = entry["body"]
           is_stream = entry["is_stream"] || false
+          is_binary = entry["is_binary"] || false
 
           body = if is_stream
-            T.cast(body, T::Array[String]).to_enum
+            chunks = T.cast(body, T::Array[String])
+            Enumerator.new do |yielder|
+              chunks.each { |chunk| yielder << (is_binary ? Base64.strict_decode64(chunk) : chunk) }
+            end
           else
-            body
+            is_binary ? Base64.strict_decode64(T.cast(body, String)) : body
           end
 
           Rager::Http::Response.new(
@@ -116,21 +114,19 @@ module Rager
         sig { returns(Cache) }
         def load_cache
           create_file_if_not_exists
-          JSON.parse(File.read(@test_file_path, encoding: "UTF-8"))
+          JSON.parse(File.read(@test_file_path))
         end
 
         sig { void }
         def save_cache
-          current_file_content =
-            if File.exist?(@test_file_path)
-              JSON.parse(File.read(@test_file_path, encoding: "UTF-8"))
-            else
-              {}
-            end
-
+          current_file_content = File.exist?(@test_file_path) ? JSON.parse(File.read(@test_file_path)) : {}
           output = current_file_content.merge(@cache)
-          json_string = JSON.generate(output).force_encoding("UTF-8")
-          File.write(@test_file_path, json_string, encoding: "UTF-8")
+          File.write(@test_file_path, JSON.generate(output))
+        end
+
+        sig { params(content: String).returns(T::Boolean) }
+        def binary_content?(content)
+          content.include?("\0")
         end
       end
     end

data/lib/rager/http/adapters/net_http.rb

@@ -0,0 +1,144 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "sorbet-runtime"
+
+module Rager
+  module Http
+    module Adapters
+      class NetHttp < Rager::Http::Adapters::Abstract
+        extend T::Sig
+
+        sig { void }
+        def initialize
+        end
+
+        sig {
+          override.params(
+            request: Rager::Http::Request
+          ).returns(Rager::Http::Response)
+        }
+        def make_request(request)
+          uri = URI(request.url)
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
+
+          if request.timeout
+            http.open_timeout = request.timeout
+            http.read_timeout = request.timeout
+          end
+
+          http_request = build_http_request(request, uri)
+
+          http.request(http_request) do |response|
+            body = if request.streaming
+              body_enum(response)
+            else
+              response.body
+            end
+
+            return Rager::Http::Response.new(
+              status: response.code.to_i,
+              headers: response.to_hash,
+              body: body
+            )
+          end
+        rescue SocketError => e
+          raise Rager::Errors::HttpError.new(
+            self,
+            request.url,
+            0,
+            body: nil,
+            details: "DNS resolution failed: #{e.message}"
+          )
+        rescue Errno::ECONNREFUSED => e
+          raise Rager::Errors::HttpError.new(
+            self,
+            request.url,
+            0,
+            body: nil,
+            details: "Connection refused: #{e.message}"
+          )
+        rescue Errno::EBUSY => e
+          raise Rager::Errors::HttpError.new(
+            self,
+            request.url,
+            0,
+            body: nil,
+            details: "Device or resource busy: #{e.message}"
+          )
+        rescue Net::OpenTimeout => e
+          raise Rager::Errors::HttpError.new(
+            self,
+            request.url,
+            0,
+            body: nil,
+            details: "Connection timed out: #{e.message}"
+          )
+        rescue Net::ReadTimeout => e
+          raise Rager::Errors::HttpError.new(
+            self,
+            request.url,
+            0,
+            body: nil,
+            details: "Read timed out: #{e.message}"
+          )
+        rescue EOFError => e
+          raise Rager::Errors::HttpError.new(
+            self,
+            request.url,
+            0,
+            body: nil,
+            details: "Connection closed unexpectedly: #{e.message}"
+          )
+        end
+
+        sig {
+          params(
+            response: Net::HTTPResponse
+          ).returns(T::Enumerator[String])
+        }
+        def body_enum(response)
+          chunks = T.let([], T::Array[String])
+
+          response.read_body do |chunk|
+            chunks << chunk
+          end
+
+          chunks.to_enum
+        end
+
+        sig {
+          params(
+            request: Rager::Http::Request,
+            uri: URI::Generic
+          ).returns(Net::HTTPRequest)
+        }
+        def build_http_request(request, uri)
+          http_request = case request.verb
+          when Rager::Http::Verb::Get then Net::HTTP::Get.new(uri)
+          when Rager::Http::Verb::Post then Net::HTTP::Post.new(uri)
+          when Rager::Http::Verb::Put then Net::HTTP::Put.new(uri)
+          when Rager::Http::Verb::Patch then Net::HTTP::Patch.new(uri)
+          when Rager::Http::Verb::Delete then Net::HTTP::Delete.new(uri)
+          when Rager::Http::Verb::Head then Net::HTTP::Head.new(uri)
+          when Rager::Http::Verb::Options then Net::HTTP::Options.new(uri)
+          end
+
+          request.headers.each do |key, value|
+            http_request[key] = value
+          end
+
+          if request.body && http_request.request_body_permitted?
+            http_request.body = request.body
+          end
+
+          http_request
+        end
+      end
+    end
+  end
+end

data/lib/rager/http/request.rb

@@ -10,6 +10,8 @@ module Rager
       const :verb, Rager::Http::Verb, default: Rager::Http::Verb::Get
       const :headers, T::Hash[String, String]
       const :body, T.nilable(String)
+      const :streaming, T::Boolean, default: false
+      const :timeout, T.nilable(Numeric)
     end
   end
 end

data/lib/rager/{image_gen → image}/options.rb

@@ -4,16 +4,17 @@
 require "sorbet-runtime"
 
 module Rager
-  module ImageGen
+  module Image
     class Options < T::Struct
       extend T::Sig
       include Rager::Options
 
-      const :provider, String, default: "replicate"
+      const :provider, Symbol, default: :replicate
       const :model, String, default: "black-forest-labs/flux-schnell"
-      const :output_format, T.nilable(Rager::ImageGen::OutputFormat)
-      const :api_key, T.nilable(String)
+      const :output_format, T.nilable(Rager::Image::OutputFormat)
       const :seed, T.nilable(Integer)
+      const :api_key, T.nilable(String)
+      const :timeout, T.nilable(Numeric)
     end
   end
 end

data/lib/rager/{image_gen → image}/output_format.rb

@@ -4,7 +4,7 @@
 require "sorbet-runtime"
 
 module Rager
-  module ImageGen
+  module Image
     class OutputFormat < T::Enum
       extend T::Sig
 

data/lib/rager/{image_gen → image}/providers/abstract.rb

@@ -4,7 +4,7 @@
 require "sorbet-runtime"
 
 module Rager
-  module ImageGen
+  module Image
     module Providers
       class Abstract
         extend T::Sig
@@ -14,10 +14,10 @@ module Rager
         sig do
           abstract.params(
             prompt: String,
-            options: Rager::ImageGen::Options
-          ).returns(Rager::Types::ImageGenOutput)
+            options: Rager::Image::Options
+          ).returns(Rager::Types::ImageOutput)
         end
-        def image_gen(prompt, options)
+        def image(prompt, options)
         end
       end
     end

data/lib/rager/{image_gen → image}/providers/replicate.rb

@@ -5,15 +5,23 @@ require "sorbet-runtime"
 require "json"
 
 module Rager
-  module ImageGen
+  module Image
     module Providers
-      class Replicate < Rager::ImageGen::Providers::Abstract
+      class Replicate < Rager::Image::Providers::Abstract
         extend T::Sig
 
-        sig { override.params(prompt: String, options: Rager::ImageGen::Options).returns(Rager::Types::ImageGenOutput) }
-        def image_gen(prompt, options)
+        sig { override.params(prompt: String, options: Rager::Image::Options).returns(Rager::Types::ImageOutput) }
+        def image(prompt, options)
           api_key = options.api_key || ENV["REPLICATE_API_KEY"]
-          raise Rager::Errors::MissingCredentialsError.new("Replicate", "REPLICATE_API_KEY") if api_key.nil?
+          raise Rager::Errors::CredentialsError.new("Replicate", env_var: ["REPLICATE_API_KEY"]) if api_key.nil?
+
+          url = "https://api.replicate.com/v1/models/#{options.model}/predictions"
+
+          headers = {
+            "Authorization" => "Bearer #{api_key}",
+            "Content-Type" => "application/json",
+            "Prefer" => "wait"
+          }
 
           body = {
             input: {
@@ -25,25 +33,22 @@ module Rager
           end
 
           request = Rager::Http::Request.new(
-            url: "https://api.replicate.com/v1/models/#{options.model}/predictions",
+            url: url,
             verb: Rager::Http::Verb::Post,
-            headers: {
-              "Authorization" => "Bearer #{api_key}",
-              "Content-Type" => "application/json",
-              "Prefer" => "wait"
-            },
-            body: body.to_json
+            headers: headers,
+            body: body.to_json,
+            timeout: options.timeout || Rager.config.timeout
           )
 
           response = Rager.config.http_adapter.make_request(request)
           response_body = T.cast(T.must(response.body), String)
 
-          raise Rager::Errors::HttpError.new(Rager.config.http_adapter, response.status, response_body) unless [200, 201].include?(response.status)
+          raise Rager::Errors::HttpError.new(Rager.config.http_adapter, request.url, response.status, body: response_body) unless [200, 201].include?(response.status)
 
           parsed = JSON.parse(response_body)
           parsed.fetch("output").first
         rescue JSON::ParserError, KeyError => e
-          raise Rager::Errors::ParseError.new(e.message, response_body)
+          raise Rager::Errors::ParseError.new(response_body || "", details: e.message)
         end
       end
     end

data/lib/rager/{logger.rb → log_strategy.rb}

@@ -4,8 +4,9 @@
 require "sorbet-runtime"
 
 module Rager
-  class Logger < T::Enum
+  class LogStrategy < T::Enum
     enums do
+      None = new("none")
       Stdout = new("stdout")
       Remote = new("remote")
     end

data/lib/rager/{mesh_gen → mesh}/options.rb

@@ -4,16 +4,17 @@
 require "sorbet-runtime"
 
 module Rager
-  module MeshGen
+  module Mesh
     class Options < T::Struct
       extend T::Sig
       include Rager::Options
 
-      const :provider, String, default: "replicate"
+      const :provider, Symbol, default: :replicate
       const :model, String, default: "firoz/trellis"
       const :version, String, default: "4876f2a8da1c544772dffa32e8889da4a1bab3a1f5c1937bfcfccb99ae347251"
-      const :api_key, T.nilable(String)
       const :seed, T.nilable(Integer)
+      const :api_key, T.nilable(String)
+      const :timeout, T.nilable(Numeric)
     end
   end
 end