rager 0.6.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2036814b6f6bbe713486b60918b0d75222416ecf90eeb2e0fbf139c44d2d8c1f
-  data.tar.gz: d6e112b1c3d1189df8957aa219a0cee7d86735b4198ec355680fab25215e33aa
+  metadata.gz: 2db5c90419613081d3292daff1f7d16ef7a5c9e5b459dfcd3e78226ebc86538b
+  data.tar.gz: e43d6a988df3da33390e3b278b77eb44967aad6f667c2c4b604ee61fab30261f
 SHA512:
-  metadata.gz: f3c65b99f301a2e617a86c1bbd2ae3149cd1a7a473d688936f66e4321eaf1ead643f58e9d387dd7d9cb314e15188a4577f710188da3082c5753229a1ae8998bf
-  data.tar.gz: 80e6f853ccdee991e19ba3f921fc6b10023cc2c2620d92ccc40f9b796cd5037d2ddad694834d0df4e9ed5aa9fdd84554c97a8afc2b311c95f7cb94c565a56f95
+  metadata.gz: 490172cb198dfd79c391b56fadebc44124f766334b19cc9c79997c08f82351a71834e0a647e758ed63fd2ff0a4837da61527e8ee19b451a258f9e66b44b334b3
+  data.tar.gz: a37fe08071870f6dd9cce48db5f45dd3af0ae2e42e1aaeabc3bd12deac2d6746e6108035f9e64c6be12f39bdd0a8ee35c57dfe8f4a679c84b157e65887664508

data/README.md

@@ -8,41 +8,41 @@
 
 Build continuously improving generative workflows.
 
-## Providers
+## Logging
 
-| Feature                | Providers                      |
-| ---------------------- | ------------------------------ |
-| **Chat**               | `openai` (and compatible APIs) |
-| **Embedding**          | `openai` (and compatible APIs) |
-| **Image generation**   | `replicate`                    |
-| **3D mesh generation** | `replicate`                    |
-| **Rerank**             | `cohere` (and compatible APIs) |
-| **Search**             | `jina`                         |
-| **Templating**         | `erb` (built-in)               |
+Why yet another library? The main reason is to have an out-of-the-box logging server that records workflows and outcomes to use in few-shot prompts and fine-tuning. It’s live at [`rager.cloud`](https://rager.cloud), though public signups are paused until I roll out usage-based billing.
 
-## Logging
+## Providers
 
-The main reason for developing yet another library is to have an out-of-the-box compatible logging server that tracks AI workflows and outcomes. This data can be used to generate high-quality examples for few-shot prompting and fine-tuning. That server will be released soon, check back here for updates.
+Modalities that take a URL parameter (chat, embedding, rerank) support compatible services, allowing you to use alternative providers that support the interface.
+
+| Feature                | Providers        |
+| ---------------------- | ---------------- |
+| **Chat**               | `openai`         |
+| **Embedding**          | `openai`         |
+| **Image generation**   | `replicate`      |
+| **3D mesh generation** | `replicate`      |
+| **Reranking**          | `cohere`         |
+| **Search**             | `jina`           |
+| **Templating**         | `erb`,`mustache` |
 
 ## Installation
 
-Add this line to your application’s Gemfile:
+Add this line to your application's Gemfile:
 
 ```ruby
-gem "rager", "~> 0.6.0"
+gem "rager", "~> 0.8.0"
 ```
 
-Or use it in a standalone script (example uses OPENAI_API_KEY env var):
+Or use it in a standalone script (requires OPENAI_API_KEY set):
 
 ```ruby
-#!/usr/bin/env ruby
-
 require "bundler/inline"
 
 gemfile do
   source "https://rubygems.org"
   gem "async-http", "~> 0.88.0"
-  gem "rager", "~> 0.6.0"
+  gem "rager", "~> 0.8.0"
 end
 
 require "rager"
@@ -51,19 +51,16 @@ Rager.configure do |config|
   config.http_adapter = Rager::Http::Adapters::AsyncHttp.new
 end
 
+PROMPT = ARGV[0] || "Ruby programming"
+
 Async do
   ctx = Rager::Context.new
-  prompt = ctx.template(
-    "Tell me about the history of <%= topic %>:\n",
-    {topic: "Ruby programming"}
-  )
+  prompt = ctx.template("Tell me about the history of <%= topic %>", {topic: PROMPT})
   chat = ctx.chat(prompt, stream: true)
-  chat.out.each { |d| print d.content }
+  chat.stream.each { |d| print d.content }
 end
 ```
 
-This library makes extensive use of `sorbet-runtime` for runtime type checking. To learn more, including how to disable it, please see the official Sorbet [documentation](https://sorbet.org/docs/overview).
-
 ## License
 
 [MIT](./LICENSE.md)

data/lib/rager/chat/message.rb

@@ -6,8 +6,18 @@ require "sorbet-runtime"
 module Rager
   module Chat
     class Message < T::Struct
+      extend T::Sig
+
       const :role, MessageRole
       const :content, T.any(String, T::Array[MessageContent])
+
+      sig { params(options: T.untyped).returns(String) }
+      def to_json(options = nil)
+        {
+          role: role,
+          content: content
+        }.to_json(options)
+      end
     end
   end
 end

data/lib/rager/chat/message_content.rb

@@ -6,9 +6,16 @@ require "sorbet-runtime"
 module Rager
   module Chat
     class MessageContent < T::Struct
+      extend T::Sig
+
       const :type, MessageContentType, default: MessageContentType::Text
       const :image_type, T.nilable(MessageContentImageType)
       const :content, String
+
+      sig { params(options: T.untyped).returns(String) }
+      def to_json(options = nil)
+        serialize.to_json(options)
+      end
     end
   end
 end

data/lib/rager/chat/message_delta.rb

@@ -6,8 +6,15 @@ require "sorbet-runtime"
 module Rager
   module Chat
     class MessageDelta < T::Struct
+      extend T::Sig
+
       const :index, Integer, default: 0
       const :content, String
+
+      sig { params(options: T.untyped).returns(String) }
+      def to_json(options = nil)
+        serialize.to_json(options)
+      end
     end
   end
 end

data/lib/rager/chat/options.rb

@@ -10,22 +10,21 @@ module Rager
       extend T::Sig
       include Rager::Options
 
-      const :provider, String, default: "openai"
-      const :history, T::Array[Message], default: []
-      const :url, T.nilable(String)
-      const :api_key, T.nilable(String)
+      const :provider, Symbol, default: :openai
       const :model, T.nilable(String)
+      const :stream, T.nilable(T::Boolean)
       const :n, T.nilable(Integer)
-      const :max_tokens, T.nilable(Integer)
       const :temperature, T.nilable(Float)
+      const :max_tokens, T.nilable(Integer)
       const :system_prompt, T.nilable(String)
       const :schema, T.nilable(Dry::Schema::JSON)
       const :schema_name, T.nilable(String)
-      const :stream, T.nilable(T::Boolean)
       const :seed, T.nilable(Integer)
+      const :url, T.nilable(String)
+      const :api_key, T.nilable(String)
       const :timeout, T.nilable(Numeric)
 
-      sig { override.returns(T::Hash[String, T.untyped]) }
+      sig { override.returns(T::Hash[Symbol, T.untyped]) }
       def serialize_safe
         result = serialize
         result["api_key"] = "[REDACTED]" if result.key?("api_key")

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

@@ -11,7 +11,8 @@ module Rager
       class Openai < Rager::Chat::Providers::Abstract
         extend T::Sig
 
-        OpenaiMessages = T.type_alias { T::Array[T::Hash[String, T.any(String, T::Array[T.untyped])]] }
+        OpenaiContentItem = T.type_alias { T::Hash[String, T.any(String, T::Hash[String, String])] }
+        OpenaiMessages = T.type_alias { T::Array[T::Hash[String, T.any(String, T::Array[OpenaiContentItem])]] }
 
         sig do
           override.params(
@@ -24,10 +25,17 @@ module Rager
           raise Rager::Errors::CredentialsError.new("OpenAI", env_var: ["OPENAI_API_KEY"]) if api_key.nil?
 
           base_url = options.url || ENV["OPENAI_URL"] || "https://api.openai.com/v1"
+          url = "#{base_url}/chat/completions"
+
+          headers = {
+            "Content-Type" => "application/json"
+          }.tap do |h|
+            h["Authorization"] = "Bearer #{api_key}" if api_key
+          end
 
           body = {
             model: options.model || "gpt-4.1",
-            messages: build_openai_messages(messages, options.history, options.system_prompt)
+            messages: build_openai_messages(messages, options.system_prompt)
           }.tap do |b|
             b[:n] = options.n if options.n
             b[:max_tokens] = options.max_tokens if options.max_tokens
@@ -47,12 +55,9 @@ module Rager
             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: "#{base_url}/chat/completions",
+            url: url,
             headers: headers,
             body: body.to_json,
             streaming: options.stream || false,
@@ -70,39 +75,36 @@ module Rager
           end
         end
 
-        private
-
         sig do
           params(
             messages: T::Array[Rager::Chat::Message],
-            history: T::Array[Rager::Chat::Message],
             system_prompt: T.nilable(String)
           ).returns(OpenaiMessages)
         end
-        def build_openai_messages(messages, history, system_prompt)
-          result = T.let([], OpenaiMessages)
+        def build_openai_messages(messages, system_prompt)
+          output = T.let([], OpenaiMessages)
 
-          if history.empty? && system_prompt && !system_prompt.empty?
-            result << {"role" => "system", "content" => system_prompt}
+          if system_prompt
+            output << {"role" => "system", "content" => system_prompt}
           end
 
-          (history + messages).each do |message|
+          messages.each do |message|
             role = message.role.is_a?(String) ? message.role : message.role.serialize
             content = message.content
 
             case content
             when String
-              result << {"role" => role, "content" => content}
+              output << {"role" => role, "content" => content}
             when Array
               formatted_content = content.map { |item| format_content_item(item) }
-              result << {"role" => role, "content" => formatted_content}
+              output << {"role" => role, "content" => formatted_content}
             end
           end
 
-          result
+          output
         end
 
-        sig { params(item: Rager::Chat::MessageContent).returns(T::Hash[String, T.untyped]) }
+        sig { params(item: Rager::Chat::MessageContent).returns(OpenaiContentItem) }
         def format_content_item(item)
           case item.type
           when Rager::Chat::MessageContentType::Text
@@ -119,7 +121,7 @@ module Rager
           end
         end
 
-        sig { params(body: String).returns(Rager::Types::ChatNonStream) }
+        sig { params(body: String).returns(Rager::Types::ChatNonStreamOutput) }
         def handle_non_stream_body(body)
           response_data = JSON.parse(body)
           return [] unless response_data.key?("choices") && response_data["choices"].is_a?(Array)
@@ -137,25 +139,38 @@ module Rager
         sig { params(body: T::Enumerator[String]).returns(T::Enumerator[Rager::Chat::MessageDelta]) }
         def handle_stream_body(body)
           Enumerator.new do |yielder|
-            buffer = +""
+            buffer_parts = []
             body.each do |chunk|
-              buffer << chunk
+              buffer_parts << chunk.force_encoding(Encoding::UTF_8)
+              buffer = buffer_parts.join
               while (line = buffer.slice!(/.*\n/))
-                line.delete_prefix!("data: ") or next
-                line.strip!
-                next if line.empty? || line == "[DONE]"
-
-                begin
-                  JSON.parse(line).dig("choices")&.each do |choice|
-                    if (content = choice.dig("delta", "content"))
-                      yielder << Rager::Chat::MessageDelta.new(index: choice["index"] || 0, content: content)
-                    end
-                  end
-                rescue
-                  nil
-                end
+                process_stream_line(line, yielder)
+              end
+              buffer_parts = buffer.empty? ? [] : [buffer]
+            end
+
+            unless buffer_parts.empty?
+              process_stream_line(buffer_parts.join, yielder)
+            end
+          end
+        end
+
+        private
+
+        sig { params(line: String, yielder: Enumerator::Yielder).void.checked(:never) }
+        def process_stream_line(line, yielder)
+          line.delete_prefix!("data: ") or return
+          line.strip!
+          return if line.empty? || line == "[DONE]"
+
+          begin
+            JSON.parse(line).dig("choices")&.each do |choice|
+              if (content = choice.dig("delta", "content"))
+                yielder << Rager::Chat::MessageDelta.new(index: choice["index"] || 0, content: content)
               end
             end
+          rescue JSON::ParserError
+            nil
           end
         end
       end

data/lib/rager/chat/schema.rb

@@ -42,8 +42,6 @@ module Rager
           node.each { |item| make_strict_recursive!(item) }
         end
       end
-
-      private_class_method :make_strict_recursive!
     end
   end
 end

data/lib/rager/config.rb

@@ -7,12 +7,18 @@ module Rager
   class Config
     extend T::Sig
 
-    sig { returns(T.nilable(Rager::Logger)) }
-    attr_accessor :logger_type
-
     sig { returns(::Logger) }
     attr_accessor :logger
 
+    sig { returns(T::Boolean) }
+    attr_accessor :log_raise
+
+    sig { returns(Rager::LogStrategy) }
+    attr_accessor :log_strategy
+
+    sig { returns(Rager::Http::Adapters::Abstract) }
+    attr_accessor :http_adapter
+
     sig { returns(T.nilable(String)) }
     attr_accessor :url
 
@@ -24,27 +30,13 @@ module Rager
 
     sig { void }
     def initialize
-      @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)
+      @log_raise = T.let(false, T::Boolean)
+      @log_strategy = T.let(Rager::LogStrategy::None, Rager::LogStrategy)
+      @http_adapter = T.let(Rager::Http::Adapters::NetHttp.new, Rager::Http::Adapters::Abstract)
       @url = T.let(nil, T.nilable(String))
       @api_key = T.let(nil, T.nilable(String))
       @timeout = T.let(nil, T.nilable(Numeric))
     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::NetHttp.new
-    end
   end
 end