rager 0.2.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32cd931dd6c3c714456232f7aeb15743580a605330051a31c4167a0435e8d766
-  data.tar.gz: bd28897b484c9b6d0972b229b6fe834eb532b1027baf855b33ac9940df303c8a
+  metadata.gz: 5799720e30799c04913866e328e581ed4670f6008489a00d78b438306a6d72e3
+  data.tar.gz: 30c3b31026a2ddcc9436fdb0f911f98129ce471ab0deb2ffdb05fb567fb4d030
 SHA512:
-  metadata.gz: 9b98958d909a001eb2f21a65e1186a473fa5c11e1e86255e0d9c9cfdd535b3ce6131c90c1fa9b5665fe4831f168860d49e399b9b25d0bcd179b2a022e9db8d7a
-  data.tar.gz: 70d77abac363b663d6b82636b93af19bddf02f37570599e6df71e6a2f0f30fbb309d87b2f8431bdf4106bf9e3559448579b66ac8cd2cb34eca2b3ccca0f98bbe
+  metadata.gz: 42f1d694221214b2d098b5996d870fe02dd7704ffce9f2ca44c154e790c6713bf23f98fb649a2ff601f8ab7c3a45da9571bbfcd643628b8c72b64df792bb524c
+  data.tar.gz: d4440b82e846327792039b33d352320ed00a1c72ac93701e3bed56a9e9f3cacaea5d300fe8853eaf7b2cd93b6c0a2d440d59c6c486707035fd982b7827a01b1a

data/README.md

@@ -18,7 +18,7 @@ bundle add rager
 Otherwise you can add it to your Gemfile directly:
 
 ```Ruby
-gem "rager", "~> 0.2.0"
+gem "rager", "~> 0.4.0"
 ```
 
 ## License

data/lib/rager/chat/providers/openai.rb

@@ -22,63 +22,50 @@ module Rager
           api_key = options.api_key || ENV["OPENAI_API_KEY"]
           raise Rager::Errors::MissingCredentialsError.new("OpenAI", "OPENAI_API_KEY") if api_key.nil?
 
-          url = options.url || ENV["OPENAI_URL"] || "https://api.openai.com/v1/chat/completions"
-          model = options.model || "gpt-4.1"
-
-          openai_messages = build_openai_messages(messages, options.history, options.system_prompt)
-
-          headers = {
-            "Content-Type" => "application/json"
-          }
-          headers["Authorization"] = "Bearer #{api_key}" if api_key
-
           body = {
-            model: model,
-            messages: openai_messages
-          }
-          body[:temperature] = options.temperature unless options.temperature.nil?
-          body[:n] = options.n unless options.n.nil?
-          body[:stream] = options.stream unless options.stream.nil?
-          body[:seed] = options.seed unless options.seed.nil?
-
-          if options.schema && options.schema_name
-            body[:response_format] = {
-              type: "json_schema",
-              json_schema: {
-                name: T.must(options.schema_name).downcase,
-                strict: true,
-                schema: Rager::Chat::Schema.dry_schema_to_json_schema(T.must(options.schema))
+            model: options.model || "gpt-4.1",
+            messages: build_openai_messages(messages, options.history, options.system_prompt)
+          }.tap do |b|
+            b[:temperature] = options.temperature if options.temperature
+            b[:n] = options.n if options.n
+            b[:stream] = options.stream if options.stream
+            b[:seed] = options.seed if options.seed
+
+            if options.schema && options.schema_name
+              b[:response_format] = {
+                type: "json_schema",
+                json_schema: {
+                  name: T.must(options.schema_name).downcase,
+                  strict: true,
+                  schema: Rager::Chat::Schema.dry_schema_to_json_schema(T.must(options.schema))
+                }
               }
-            }
+            end
           end
 
+          headers = {"Content-Type" => "application/json"}
+          headers["Authorization"] = "Bearer #{api_key}" if api_key
+
           request = Rager::Http::Request.new(
             verb: Rager::Http::Verb::Post,
-            url: url,
+            url: options.url || ENV["OPENAI_URL"] || "https://api.openai.com/v1/chat/completions",
             headers: headers,
             body: body.to_json
           )
 
-          http_adapter = Rager.config.http_adapter
-          response = http_adapter.make_request(request)
+          response = Rager.config.http_adapter.make_request(request)
           response_body = T.must(response.body)
 
-          if response.status != 200
-            raise Rager::Errors::HttpError.new(
-              http_adapter,
-              response.status,
-              T.cast(response_body, String)
-            )
-          end
+          raise Rager::Errors::HttpError.new(Rager.config.http_adapter, response.status, T.cast(response_body, String)) if response.status != 200
 
           case response_body
-          when String
-            parse_non_stream_body(response_body)
-          when Enumerator
-            create_message_delta_stream(response_body)
+          when String then handle_non_stream_body(response_body)
+          when Enumerator then handle_stream_body(response_body)
           end
         end
 
+        private
+
         sig do
           params(
             messages: T::Array[Rager::Chat::Message],
@@ -90,94 +77,75 @@ module Rager
           result = T.let([], OpenaiMessages)
 
           if history.empty? && system_prompt && !system_prompt.empty?
-            result << {"role" => "system",
-                        "content" => system_prompt}
+            result << {"role" => "system", "content" => system_prompt}
           end
 
-          history.each do |msg|
-            role_str = msg.role.is_a?(String) ? msg.role : msg.role.serialize
-            result << {"role" => role_str, "content" => msg.content}
-          end
-
-          messages.each do |message|
-            role_str = message.role.is_a?(String) ? message.role : message.role.serialize
+          (history + messages).each do |message|
+            role = message.role.is_a?(String) ? message.role : message.role.serialize
             content = message.content
 
-            if content.is_a?(String)
-              result << {"role" => role_str, "content" => content}
-            elsif content.is_a?(Array)
-              formatted_content = content.map do |item|
-                item_type = item.type
-                case item_type
-                when Rager::Chat::MessageContentType::Text
-                  {"type" => "text", "text" => item.content}
-                when Rager::Chat::MessageContentType::ImageUrl
-                  {"type" => "image_url", "image_url" => {"url" => item.content}}
-                when Rager::Chat::MessageContentType::ImageBase64
-                  image_type = T.must(item.image_type)
-                  image_mime_type = case image_type
-                  when Rager::Chat::MessageContentImageType::Jpeg then "image/jpeg"
-                  when Rager::Chat::MessageContentImageType::Png then "image/png"
-                  when Rager::Chat::MessageContentImageType::Webp then "image/webp"
-                  end
-                  data_uri = "data:#{image_mime_type};base64,#{item.content}"
-                  {"type" => "image_url", "image_url" => {"url" => data_uri}}
-                end
-              end
-              result << {"role" => role_str, "content" => formatted_content}
+            case content
+            when String
+              result << {"role" => role, "content" => content}
+            when Array
+              formatted_content = content.map { |item| format_content_item(item) }
+              result << {"role" => role, "content" => formatted_content}
             end
           end
 
           result
         end
 
-        sig { params(body: String).returns(T::Array[String]) }
-        def parse_non_stream_body(body)
-          messages = T.let([], T::Array[String])
-
-          begin
-            response_data = JSON.parse(body)
-            if response_data.key?("choices") && response_data["choices"].is_a?(Array)
-              response_data["choices"].each do |choice|
-                text = choice.dig("message", "content").to_s
-                messages << text unless text.empty?
-              end
+        sig { params(item: Rager::Chat::MessageContent).returns(T::Hash[String, T.untyped]) }
+        def format_content_item(item)
+          case item.type
+          when Rager::Chat::MessageContentType::Text
+            {"type" => "text", "text" => item.content}
+          when Rager::Chat::MessageContentType::ImageUrl
+            {"type" => "image_url", "image_url" => {"url" => item.content}}
+          when Rager::Chat::MessageContentType::ImageBase64
+            mime_type = case T.must(item.image_type)
+            when Rager::Chat::MessageContentImageType::Jpeg then "image/jpeg"
+            when Rager::Chat::MessageContentImageType::Png then "image/png"
+            when Rager::Chat::MessageContentImageType::Webp then "image/webp"
             end
-          rescue JSON::ParserError
-            raise Rager::Errors::ParseError.new(
-              "OpenAI response body is not valid JSON",
-              body
-            )
+            {"type" => "image_url", "image_url" => {"url" => "data:#{mime_type};base64,#{item.content}"}}
           end
+        end
 
-          messages
+        sig { params(body: String).returns(T::Array[String]) }
+        def handle_non_stream_body(body)
+          response_data = JSON.parse(body)
+          return [] unless response_data.key?("choices") && response_data["choices"].is_a?(Array)
+
+          response_data["choices"].filter_map do |choice|
+            text = choice.dig("message", "content").to_s
+            text unless text.empty?
+          end
+        rescue JSON::ParserError
+          raise Rager::Errors::ParseError.new("OpenAI response body is not valid JSON", body)
         end
 
         sig { params(body: T::Enumerator[String]).returns(T::Enumerator[Rager::Chat::MessageDelta]) }
-        def create_message_delta_stream(body)
+        def handle_stream_body(body)
           Enumerator.new do |yielder|
             buffer = +""
 
-            process_chunk = lambda do |chunk|
+            process_chunk = ->(chunk) do
               buffer << chunk
-              pattern = /\Adata: (.*?)\n\n|\Adata: (.*?)\n/
-              while (event_match = buffer.match(pattern))
-                full_event = T.must(event_match[0])
-                data_line = event_match[1] || event_match[2]
-
-                buffer.delete_prefix!(full_event)
+              while (match = buffer.match(/\Adata: (.*?)\n\n|\Adata: (.*?)\n/))
+                buffer.delete_prefix!(T.must(match[0]))
+                data_line = match[1] || match[2]
 
-                next if data_line.nil? || data_line.strip.empty?
-                next if data_line.strip == "[DONE]"
+                next if data_line.nil? || data_line.strip.empty? || data_line.strip == "[DONE]"
 
                 begin
                   data = JSON.parse(data_line)
-                  if data.key?("choices") && data["choices"].is_a?(Array)
-                    data["choices"].each do |choice|
-                      choice_index = choice.dig("index") || 0
-                      delta = choice.dig("delta", "content")
-                      yielder << Rager::Chat::MessageDelta.new(index: choice_index, content: delta) if delta
-                    end
+                  next unless data.key?("choices") && data["choices"].is_a?(Array)
+
+                  data["choices"].each do |choice|
+                    delta = choice.dig("delta", "content")
+                    yielder << Rager::Chat::MessageDelta.new(index: choice.dig("index") || 0, content: delta) if delta
                   end
                 rescue JSON::ParserError
                   next
@@ -186,7 +154,6 @@ module Rager
             end
 
             body.each(&process_chunk)
-
             process_chunk.call("\n") unless buffer.empty?
           end
         end

data/lib/rager/chat.rb

@@ -9,7 +9,7 @@ module Rager
 
     sig do
       params(
-        messages: T::Array[Rager::Chat::Message],
+        messages: Rager::Types::ChatInput,
         options: Rager::Chat::Options
       ).returns(Rager::Types::ChatOutput)
     end

data/lib/rager/config.rb

@@ -7,10 +7,10 @@ module Rager
   class Config
     extend T::Sig
 
-    sig { returns(Rager::Http::Adapters::Abstract) }
-    attr_accessor :http_adapter
-
     sig { returns(T.nilable(Rager::Logger)) }
+    attr_accessor :logger_type
+
+    sig { returns(::Logger) }
     attr_accessor :logger
 
     sig { returns(T.nilable(String)) }
@@ -21,10 +21,26 @@ module Rager
 
     sig { void }
     def initialize
-      @http_adapter = T.let(Rager::Http::Adapters::AsyncHttp.new, Rager::Http::Adapters::Abstract)
-      @logger = T.let(nil, T.nilable(Rager::Logger))
+      @http_adapter = T.let(nil, T.nilable(Rager::Http::Adapters::Abstract))
+      @logger_type = T.let(nil, T.nilable(Rager::Logger))
+      @logger = T.let(::Logger.new($stdout), ::Logger)
       @url = T.let(nil, T.nilable(String))
       @api_key = T.let(nil, T.nilable(String))
     end
+
+    sig { returns(Rager::Http::Adapters::Abstract) }
+    def http_adapter
+      @http_adapter ||= default_http_adapter
+    end
+
+    sig { params(http_adapter: Rager::Http::Adapters::Abstract).void }
+    attr_writer :http_adapter
+
+    private
+
+    sig { returns(Rager::Http::Adapters::Abstract) }
+    def default_http_adapter
+      Rager::Http::Adapters::AsyncHttp.new
+    end
   end
 end

data/lib/rager/context.rb

@@ -12,17 +12,17 @@ module Rager
     attr_reader :id
 
     sig { returns(T.nilable(String)) }
-    attr_reader :hash
+    attr_reader :name
 
-    sig { params(id: T.nilable(String)).void }
-    def initialize(id: nil)
+    sig { params(id: T.nilable(String), name: T.nilable(String)).void }
+    def initialize(id: nil, name: nil)
       @id = T.let(id || SecureRandom.uuid, String)
-      @hash = T.let(lookup_git_hash, T.nilable(String))
+      @name = T.let(name, T.nilable(String))
     end
 
     sig do
       params(
-        messages: T.any(String, T::Array[Rager::Chat::Message]),
+        messages: T.any(String, Rager::Types::ChatInput),
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
@@ -46,7 +46,7 @@ module Rager
 
     sig do
       params(
-        text: T.any(String, T::Array[String]),
+        text: T.any(String, Rager::Types::EmbedInput),
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
@@ -65,7 +65,7 @@ module Rager
 
     sig do
       params(
-        prompt: String,
+        prompt: Rager::Types::ImageGenInput,
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
@@ -80,7 +80,7 @@ module Rager
 
     sig do
       params(
-        prompt: String,
+        prompt: Rager::Types::MeshGenInput,
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
@@ -95,7 +95,7 @@ module Rager
 
     sig do
       params(
-        query: Rager::Rerank::Query,
+        query: Rager::Types::RerankInput,
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
@@ -110,7 +110,7 @@ module Rager
 
     sig do
       params(
-        query: String,
+        query: Rager::Types::SearchInput,
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
@@ -125,7 +125,7 @@ module Rager
 
     sig do
       params(
-        input: Rager::Template::Input,
+        input: Rager::Types::TemplateInput,
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
@@ -150,33 +150,49 @@ module Rager
       ).returns(Rager::Result)
     end
     def execute(operation, options_struct, kwargs, input, &block)
-      input_ids = kwargs.delete(:input_ids)
+      name = kwargs.delete(:name)
+      iids = kwargs.delete(:iids)
 
       options = options_struct.new(**kwargs)
       options.validate
 
       start_time = Time.now
 
-      output = yield(options)
-
-      Result.new(
-        id: @id,
-        context_id: @id,
-        hash: @hash,
-        operation: operation,
-        input: input,
-        options: options,
-        start_time: start_time.to_i,
-        end_time: Time.now.to_i,
-        output: output,
-        input_ids: input_ids
-      ).tap(&:log)
-    end
-
-    sig { returns(T.nilable(String)) }
-    def lookup_git_hash
-      result = `git rev-parse HEAD`
-      $?.success? ? result.strip : nil
+      begin
+        output = yield(options)
+
+        Result.new(
+          id: SecureRandom.uuid,
+          context_id: @id,
+          operation: operation,
+          input: input,
+          output: output,
+          options: options,
+          start_time: start_time.to_i,
+          end_time: Time.now.to_i,
+          name: name,
+          context_name: @name,
+          iids: iids,
+          error: nil
+        ).tap(&:log)
+      rescue => e
+        Result.new(
+          id: SecureRandom.uuid,
+          context_id: @id,
+          operation: operation,
+          input: input,
+          output: nil,
+          options: options,
+          start_time: start_time.to_i,
+          end_time: Time.now.to_i,
+          name: name,
+          context_name: @name,
+          iids: iids,
+          error: e.message
+        ).tap(&:log)
+
+        raise e
+      end
     end
   end
 end

data/lib/rager/embed/options.rb

@@ -14,17 +14,6 @@ module Rager
       const :model, T.nilable(String)
       const :api_key, T.nilable(String)
       const :seed, T.nilable(Integer)
-
-      sig { override.returns(T::Hash[String, T.untyped]) }
-      def serialize_safe
-        result = serialize
-        result["api_key"] = "[REDACTED]" if result.key?("api_key")
-        result
-      end
-
-      sig { override.void }
-      def validate
-      end
     end
   end
 end

data/lib/rager/embed/providers/openai.rb

@@ -20,37 +20,25 @@ module Rager
           api_key = options.api_key || ENV["OPENAI_API_KEY"]
           raise Rager::Errors::MissingCredentialsError.new("OpenAI", "OPENAI_API_KEY") if api_key.nil?
 
-          url = options.url || ENV["OPENAI_URL"] || "https://api.openai.com/v1/embeddings"
-          model = options.model || "text-embedding-3-large"
-
-          headers = {
-            "Content-Type" => "application/json"
-          }
+          headers = {"Content-Type" => "application/json"}
           headers["Authorization"] = "Bearer #{api_key}" if api_key
 
           body = {
-            model: model,
+            model: options.model || "text-embedding-3-large",
             input: text
           }
 
           request = Rager::Http::Request.new(
             verb: Rager::Http::Verb::Post,
-            url: url,
+            url: options.url || ENV["OPENAI_URL"] || "https://api.openai.com/v1/embeddings",
             headers: headers,
             body: body.to_json
           )
 
-          http_adapter = Rager.config.http_adapter
-          response = http_adapter.make_request(request)
+          response = Rager.config.http_adapter.make_request(request)
           response_body = T.cast(T.must(response.body), String)
 
-          if response.status != 200
-            raise Rager::Errors::HttpError.new(
-              http_adapter,
-              response.status,
-              response_body
-            )
-          end
+          raise Rager::Errors::HttpError.new(Rager.config.http_adapter, response.status, response_body) if response.status != 200
 
           parsed_response = JSON.parse(response_body)
           parsed_response["data"].map { |item| item["embedding"] }

data/lib/rager/embed.rb

@@ -9,7 +9,7 @@ module Rager
 
     sig do
       params(
-        text: T::Array[String],
+        text: Rager::Types::EmbedInput,
         options: Rager::Embed::Options
       ).returns(Rager::Types::EmbedOutput)
     end

data/lib/rager/errors/http_error.rb

@@ -10,8 +10,8 @@ module Rager
 
       sig { params(adapter: Rager::Http::Adapters::Abstract, status: Integer, body: T.nilable(String)).void }
       def initialize(adapter, status, body)
-        message = "HTTP Error #{status} using adapter #{adapter.class.name}"
-        message += " -- #{body}" if body
+        message = "HTTP Error #{status} using #{adapter.class.name}"
+        message += ": #{body}" if body
         super(message)
       end
     end

data/lib/rager/errors/options_error.rb

@@ -11,7 +11,7 @@ module Rager
       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
+        message += " (#{description})" if description
         super(message)
       end
     end

data/lib/rager/http/response.rb

@@ -6,9 +6,16 @@ require "sorbet-runtime"
 module Rager
   module Http
     class Response < T::Struct
+      extend T::Sig
+
       const :status, Integer
       const :headers, T::Hash[String, T.any(String, T::Array[String])]
       const :body, T.nilable(T.any(String, T::Enumerator[String]))
+
+      sig { returns(T::Boolean) }
+      def success?
+        status >= 200 && status < 300
+      end
     end
   end
 end

data/lib/rager/image_gen/options.rb

@@ -11,19 +11,9 @@ module Rager
 
       const :provider, String, 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 :seed, T.nilable(Integer)
-
-      sig { override.returns(T::Hash[String, T.untyped]) }
-      def serialize_safe
-        result = serialize
-        result["api_key"] = "[REDACTED]" if result.key?("api_key")
-        result
-      end
-
-      sig { override.void }
-      def validate
-      end
     end
   end
 end

data/lib/rager/image_gen/output_format.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module ImageGen
+    class OutputFormat < T::Enum
+      extend T::Sig
+
+      enums do
+        Png = new("png")
+        Jpg = new("jpg")
+        Webp = new("webp")
+      end
+    end
+  end
+end