rager 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5b4311f3da8c6cf4e479c8c951322e329b4f4d697a8f78c6b2945b89793a2903
+  data.tar.gz: b92e1be42bcf7a769da8d1164f0dcd0d3108249bf3e1266cf1f2b0612bdab69f
+SHA512:
+  metadata.gz: 7bb128546a71dc3e61e28d7c7ffbbfaa7dfdbf1f3b5236de89eb7c9069cb94d45ca5b3336650ee4e7d29a9cfbb8b4a88ead87134ff0b781aba08c3c90ce5b00d
+  data.tar.gz: bcdb5dbd47c1fc6f7014e321349aa95102c6cd1492872755afe5ca32101d7cd9aa68b24c4eb98021c2cd19edc44479121c01f5ce118f4b539ffc39a5979019cb

data/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2025 Marko Vukovic
+
+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,23 @@
+# rager_rb
+
+[![test](https://github.com/mvkvc/rager_rb/actions/workflows/test.yaml/badge.svg)](https://github.com/mvkvc/rager_rb/actions/workflows/test.yaml)
+
+Build continuously improving AI applications.
+
+## Installation
+
+If you are using Bundler:
+
+```bash
+bundle add rager
+```
+
+Otherwise you can add it to your Gemfile directly:
+
+```Ruby
+gem "rager", "~> 0.1.0"
+```
+
+## License
+
+[MIT](./LICENSE.md)

data/lib/rager/chat/message.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Chat
+    class Message < T::Struct
+      const :role, MessageRole
+      const :content, T.any(String, T::Array[MessageContent])
+    end
+  end
+end

data/lib/rager/chat/message_content.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Chat
+    class MessageContent < T::Struct
+      const :type, MessageContentType, default: MessageContentType::Text
+      const :image_type, T.nilable(MessageContentImageType)
+      const :content, String
+    end
+  end
+end

data/lib/rager/chat/message_content_image_type.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Chat
+    class MessageContentImageType < T::Enum
+      enums do
+        Jpeg = new("jpeg")
+        Png = new("png")
+        Webp = new("webp")
+      end
+    end
+  end
+end

data/lib/rager/chat/message_content_type.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Chat
+    class MessageContentType < T::Enum
+      enums do
+        Text = new("text")
+        ImageUrl = new("image_url")
+        ImageBase64 = new("image_base64")
+      end
+    end
+  end
+end

data/lib/rager/chat/message_delta.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Chat
+    class MessageDelta < T::Struct
+      const :index, Integer, default: 0
+      const :content, String
+    end
+  end
+end

data/lib/rager/chat/message_role.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Chat
+    class MessageRole < T::Enum
+      enums do
+        User = new("user")
+        Assistant = new("assistant")
+        System = new("system")
+      end
+    end
+  end
+end

data/lib/rager/chat/options.rb

@@ -0,0 +1,52 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "dry-schema"
+require "sorbet-runtime"
+
+module Rager
+  module Chat
+    class Options < T::Struct
+      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 :model, T.nilable(String)
+      const :stream, T.nilable(T::Boolean)
+      const :n, T.nilable(Integer)
+      const :temperature, T.nilable(Float)
+      const :system_prompt, T.nilable(String)
+      const :schema, T.nilable(Dry::Schema::JSON)
+      const :schema_name, 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["schema"] = Rager::Chat::Schema.dry_schema_to_json_schema(result["schema"]) if result.key?("schema")
+        result
+      end
+
+      sig { override.void }
+      def validate
+        if stream && schema
+          raise Rager::Errors::OptionsError.new(
+            invalid_keys: %w[stream schema],
+            description: "You cannot use streaming with structured outputs"
+          )
+        end
+
+        if schema && schema_name.nil?
+          raise Rager::Errors::OptionsError.new(
+            invalid_keys: %w[schema schema_name],
+            description: "You must provide a schema name when using structured outputs"
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Chat
+    module Providers
+      class Abstract
+        extend T::Sig
+        extend T::Helpers
+        abstract!
+
+        sig do
+          abstract.params(
+            messages: T::Array[Rager::Chat::Message],
+            options: Rager::Chat::Options
+          ).returns(Rager::Types::ChatOutput)
+        end
+        def chat(messages, options)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+require "sorbet-runtime"
+
+module Rager
+  module Chat
+    module Providers
+      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])]] }
+
+        sig do
+          override.params(
+            messages: T::Array[Rager::Chat::Message],
+            options: Rager::Chat::Options
+          ).returns(Rager::Types::ChatOutput)
+        end
+        def chat(messages, options)
+          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-4o"
+
+          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))
+              }
+            }
+          end
+
+          request = Rager::Http::Request.new(
+            verb: Rager::Http::Verb::Post,
+            url: url,
+            headers: headers,
+            body: body.to_json
+          )
+
+          http_adapter = Rager.config.http_adapter
+          response = 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
+
+          case response_body
+          when String
+            parse_non_stream_body(response_body)
+          when Enumerator
+            create_message_delta_stream(response_body)
+          end
+        end
+
+        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)
+
+          if history.empty? && system_prompt && !system_prompt.empty?
+            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
+            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}
+            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
+            end
+          rescue JSON::ParserError
+            raise Rager::Errors::ParseError.new(
+              "OpenAI response body is not valid JSON",
+              body
+            )
+          end
+
+          messages
+        end
+
+        sig { params(body: T::Enumerator[String]).returns(T::Enumerator[Rager::Chat::MessageDelta]) }
+        def create_message_delta_stream(body)
+          Enumerator.new do |yielder|
+            buffer = +""
+
+            process_chunk = lambda do |chunk|
+              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)
+
+                next if data_line.nil? || data_line.strip.empty?
+                next if 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
+                  end
+                rescue JSON::ParserError
+                  next
+                end
+              end
+            end
+
+            body.each(&process_chunk)
+
+            process_chunk.call("\n") unless buffer.empty?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rager/chat/schema.rb

@@ -0,0 +1,48 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "dry-schema"
+require "json"
+require "sorbet-runtime"
+
+Dry::Schema.load_extensions(:json_schema)
+
+module Rager
+  module Chat
+    module Schema
+      extend T::Sig
+
+      sig { params(schema: Dry::Schema::JSON).returns(T::Hash[Symbol, T.untyped]) }
+      def self.dry_schema_to_json_schema(schema)
+        json_schema_original = schema.json_schema
+        json_schema = JSON.parse(JSON.generate(json_schema_original).force_encoding("UTF-8"))
+
+        make_strict_recursive!(json_schema)
+
+        json_schema
+      end
+
+      sig { params(node: T.untyped).void }
+      def self.make_strict_recursive!(node)
+        case node
+        when Hash
+          %w[minLength maxLength not].each { |key| node.delete(key) }
+
+          case node["type"]
+          when "object"
+            node["additionalProperties"] = false
+            make_strict_recursive!(node["properties"]) if node.key?("properties")
+          when "array"
+            make_strict_recursive!(node["items"]) if node.key?("items")
+          end
+
+          node.each_value { |v| make_strict_recursive!(v) }
+        when Array
+          node.each { |item| make_strict_recursive!(item) }
+        end
+      end
+
+      private_class_method :make_strict_recursive!
+    end
+  end
+end

data/lib/rager/chat.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Chat
+    extend T::Sig
+
+    sig do
+      params(
+        messages: T::Array[Rager::Chat::Message],
+        options: Rager::Chat::Options
+      ).returns(Rager::Types::ChatOutput)
+    end
+    def self.chat(messages, options = Rager::Chat::Options.new)
+      provider = get_provider(options.provider)
+      provider.chat(messages, options)
+    end
+
+    sig do
+      params(
+        key: String
+      ).returns(Rager::Chat::Providers::Abstract)
+    end
+    def self.get_provider(key)
+      case key.downcase
+      when "openai"
+        Rager::Chat::Providers::Openai.new
+      else
+        raise Rager::Errors::UnknownProviderError.new(Rager::Operation::Chat, key)
+      end
+    end
+  end
+end

data/lib/rager/config.rb

@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+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
+
+    sig { returns(T.nilable(String)) }
+    attr_accessor :url
+
+    sig { returns(T.nilable(String)) }
+    attr_accessor :api_key
+
+    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))
+      @url = T.let(nil, T.nilable(String))
+      @api_key = T.let(nil, T.nilable(String))
+    end
+  end
+end

data/lib/rager/context.rb

@@ -0,0 +1,116 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "securerandom"
+require "sorbet-runtime"
+
+module Rager
+  class Context
+    extend T::Sig
+
+    sig { returns(String) }
+    attr_reader :id
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :hash
+
+    sig { params(id: T.nilable(String)).void }
+    def initialize(id: nil)
+      @id = T.let(id || SecureRandom.uuid, String)
+      @hash = T.let(lookup_git_hash, T.nilable(String))
+    end
+
+    sig do
+      params(
+        messages: T.any(String, T::Array[Rager::Chat::Message]),
+        kwargs: T.untyped
+      ).returns(Rager::Result)
+    end
+    def chat(messages, **kwargs)
+      if messages.is_a?(String)
+        messages = [
+          Rager::Chat::Message.new(
+            role: Rager::Chat::MessageRole::User,
+            content: messages
+          )
+        ]
+      end
+
+      execute(
+        Rager::Operation::Chat,
+        Rager::Chat::Options,
+        kwargs,
+        messages
+      ) { |options| Chat.chat(messages, options) }
+    end
+
+    sig do
+      params(
+        prompt: String,
+        kwargs: T.untyped
+      ).returns(Rager::Result)
+    end
+    def image_gen(prompt, **kwargs)
+      execute(
+        Rager::Operation::ImageGen,
+        Rager::ImageGen::Options,
+        kwargs,
+        prompt
+      ) { |options| ImageGen.image_gen(prompt, options) }
+    end
+
+    sig do
+      params(
+        prompt: String,
+        kwargs: T.untyped
+      ).returns(Rager::Result)
+    end
+    def mesh_gen(prompt, **kwargs)
+      execute(
+        Rager::Operation::MeshGen,
+        Rager::MeshGen::Options,
+        kwargs,
+        prompt
+      ) { |options| MeshGen.mesh_gen(prompt, options) }
+    end
+
+    private
+
+    sig do
+      params(
+        operation: Rager::Operation,
+        options_struct: T::Class[Rager::Options],
+        kwargs: T.untyped,
+        input: T.any(String, T::Array[Rager::Chat::Message]),
+        block: T.proc.params(options: T.untyped).returns(T.untyped)
+      ).returns(Rager::Result)
+    end
+    def execute(operation, options_struct, kwargs, input, &block)
+      options = options_struct.new(**kwargs)
+      options.validate
+
+      start_time = Time.now
+
+      output = yield(options)
+
+      Result.new(
+        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
+      ).tap { |r| r.log }
+    end
+
+    private
+
+    sig { returns(T.nilable(String)) }
+    def lookup_git_hash
+      result = `git rev-parse HEAD`
+      $?.success? ? result.strip : nil
+    end
+  end
+end

data/lib/rager/error.rb

@@ -0,0 +1,7 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rager
+  class Error < StandardError
+  end
+end

data/lib/rager/errors/http_error.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Errors
+    class HttpError < Rager::Error
+      extend T::Sig
+
+      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
+        super(message)
+      end
+    end
+  end
+end