rager 0.1.0

data/lib/rager/options.rb

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Options
+    extend T::Sig
+    extend T::Helpers
+    requires_ancestor { T::Struct }
+    interface!
+
+    sig { abstract.returns(T::Hash[String, T.untyped]) }
+    def serialize_safe
+    end
+
+    sig { abstract.void }
+    def validate
+    end
+  end
+end

data/lib/rager/result.rb

@@ -0,0 +1,198 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+require "securerandom"
+require "sorbet-runtime"
+
+module Rager
+  class Result
+    extend T::Sig
+
+    sig { returns(Rager::Operation) }
+    attr_reader :operation
+
+    sig { returns(Rager::Options) }
+    attr_reader :options
+
+    sig { returns(Rager::Types::Input) }
+    attr_reader :input
+
+    sig { returns(Integer) }
+    attr_reader :start_time
+
+    sig { returns(Integer) }
+    attr_reader :end_time
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :result_id
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :context_id
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :hash
+
+    sig do
+      params(
+        operation: Rager::Operation,
+        options: Rager::Options,
+        input: Rager::Types::Input,
+        output: Rager::Types::Output,
+        start_time: Integer,
+        end_time: Integer,
+        context_id: T.nilable(String),
+        hash: T.nilable(String)
+      ).void
+    end
+    def initialize(
+      operation:,
+      options:,
+      input:,
+      output:,
+      start_time:,
+      end_time:,
+      context_id: nil,
+      hash: nil
+    )
+      @operation = operation
+      @options = options
+      @input = input
+      @output = output
+      @start_time = start_time
+      @end_time = end_time
+      @stream = T.let(nil, T.nilable(Rager::Types::Stream))
+      @buffer = T.let([], Rager::Types::Buffer)
+      @consumed = T.let(false, T::Boolean)
+      @result_id = T.let(SecureRandom.uuid, T.nilable(String))
+      @context_id = T.let(context_id, T.nilable(String))
+      @hash = T.let(hash, T.nilable(String))
+    end
+
+    sig { returns(T::Boolean) }
+    def stream?
+      @output.is_a?(Enumerator)
+    end
+
+    sig { returns(Rager::Types::Output) }
+    def out
+      return @output unless stream?
+      return @buffer.each if @consumed
+
+      log
+
+      @stream = Enumerator.new do |yielder|
+        T.cast(@output, Rager::Types::Stream)
+          .each { |message_delta|
+          @buffer << message_delta
+          yielder << message_delta
+        }
+
+        @consumed = true
+        @end_time = Time.now.to_i
+
+        log
+      end
+
+      @stream
+    end
+
+    sig { returns(Rager::Types::NonStreamOutput) }
+    def mat
+      return T.cast(@output, Rager::Types::NonStreamOutput) unless stream?
+
+      if !@consumed
+        T.cast(out, Rager::Types::Stream).each { |_| }
+      end
+
+      parts = {}
+
+      @buffer.each do |message_delta|
+        parts[message_delta.index] =
+          (parts[message_delta.index] || "") + message_delta.content
+      end
+
+      parts
+        .sort_by { |index, _| index }
+        .map { |_, content| content }
+    end
+
+    sig { returns(T.any(String, T::Array[T::Hash[String, T.untyped]])) }
+    def serialize_input
+      case @input
+      when String
+        @input
+      when Array
+        @input.map(&:serialize)
+      end
+    end
+
+    sig { returns(Rager::Types::NonStreamOutput) }
+    def serialize_output
+      if @consumed
+        mat
+      elsif stream?
+        "[STREAM]"
+      else
+        T.cast(@output, Rager::Types::NonStreamOutput)
+      end
+    end
+
+    sig { returns(T::Hash[String, T.untyped]) }
+    def to_h
+      {
+        operation: @operation.serialize,
+        options: @options.serialize_safe,
+        input: serialize_input,
+        output: if @consumed
+                  mat
+                elsif stream?
+                  "[STREAM]"
+                else
+                  @output
+                end,
+        start_time: @start_time,
+        end_time: @end_time,
+        result_id: @result_id,
+        context_id: @context_id,
+        hash: @hash
+      }
+    end
+
+    sig { void }
+    def log
+      return unless Rager.config.logger
+
+      json = to_h.to_json
+
+      case Rager.config.logger
+      when Rager::Logger::Stdout
+        puts "LOG: #{json}"
+      when Rager::Logger::Remote
+        http_adapter = Rager.config.http_adapter
+        url = Rager.config.url
+        api_key = Rager.config.api_key
+
+        headers = {
+          "Content-Type" => "application/json",
+          "Authorization" => "Bearer #{api_key}"
+        }
+
+        if url && api_key
+          request = Rager::Http::Request.new(
+            url: url,
+            verb: Rager::Http::Verb::Post,
+            headers: headers,
+            body: json
+          )
+
+          response = http_adapter.make_request(request)
+
+          unless response.status >= 200 && response.status < 300
+            warn "Remote log failed: \\#{response.status} \\#{response.body}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rager/types.rb

@@ -0,0 +1,45 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rager
+  module Types
+    extend T::Sig
+
+    ChatInput = T.type_alias { T.any(String, T::Array[Rager::Chat::Message]) }
+    ImageGenInput = T.type_alias { String }
+    MeshGenInput = T.type_alias { String }
+    Input = T.type_alias {
+      T.any(
+        ChatInput,
+        ImageGenInput,
+        MeshGenInput
+      )
+    }
+
+    ChatStream = T.type_alias { T::Enumerator[Rager::Chat::MessageDelta] }
+    Stream = T.type_alias { ChatStream }
+
+    ChatBuffer = T.type_alias { T::Array[Rager::Chat::MessageDelta] }
+    Buffer = T.type_alias { ChatBuffer }
+
+    ChatOutput = T.type_alias { T.any(T::Array[String], ChatStream) }
+    ImageGenOutput = T.type_alias { String }
+    MeshGenOutput = T.type_alias { String }
+    Output = T.type_alias {
+      T.any(
+        ChatOutput,
+        ImageGenOutput,
+        MeshGenOutput
+      )
+    }
+
+    ChatNonStreamOutput = T.type_alias { T::Array[String] }
+    NonStreamOutput = T.type_alias {
+      T.any(
+        ChatNonStreamOutput,
+        ImageGenOutput,
+        MeshGenOutput
+      )
+    }
+  end
+end

data/lib/rager/version.rb

@@ -0,0 +1,6 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rager
+  VERSION = "0.1.0"
+end

data/lib/rager.rb

@@ -0,0 +1,35 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+require "sorbet-runtime"
+
+module Rager
+  extend T::Sig
+
+  ConfigBlock = T.type_alias do
+    T.proc.params(config: Config).void
+  end
+
+  @config = T.let(nil, T.nilable(Rager::Config))
+
+  sig { returns(Config) }
+  def self.config
+    @config ||= Config.new
+  end
+
+  sig { params(block: ConfigBlock).void }
+  def self.configure(&block)
+    yield(config)
+  end
+
+  sig { void }
+  def self.reset_config!
+    @config = Config.new
+  end
+end
+
+loader.eager_load

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: rager
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- mvkvc
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-schema
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.12028
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.12028
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+email:
+- mail@mvk.vc
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- lib/rager.rb
+- lib/rager/chat.rb
+- lib/rager/chat/message.rb
+- lib/rager/chat/message_content.rb
+- lib/rager/chat/message_content_image_type.rb
+- lib/rager/chat/message_content_type.rb
+- lib/rager/chat/message_delta.rb
+- lib/rager/chat/message_role.rb
+- lib/rager/chat/options.rb
+- lib/rager/chat/providers/abstract.rb
+- lib/rager/chat/providers/openai.rb
+- lib/rager/chat/schema.rb
+- lib/rager/config.rb
+- lib/rager/context.rb
+- lib/rager/error.rb
+- lib/rager/errors/http_error.rb
+- lib/rager/errors/missing_credentials_error.rb
+- lib/rager/errors/options_error.rb
+- lib/rager/errors/parse_error.rb
+- lib/rager/errors/unknown_provider_error.rb
+- lib/rager/http/adapters/abstract.rb
+- lib/rager/http/adapters/async_http.rb
+- lib/rager/http/adapters/mock.rb
+- lib/rager/http/request.rb
+- lib/rager/http/response.rb
+- lib/rager/http/verb.rb
+- lib/rager/image_gen.rb
+- lib/rager/image_gen/options.rb
+- lib/rager/image_gen/providers/abstract.rb
+- lib/rager/image_gen/providers/replicate.rb
+- lib/rager/logger.rb
+- lib/rager/mesh_gen.rb
+- lib/rager/mesh_gen/options.rb
+- lib/rager/mesh_gen/providers/abstract.rb
+- lib/rager/mesh_gen/providers/replicate.rb
+- lib/rager/operation.rb
+- lib/rager/options.rb
+- lib/rager/result.rb
+- lib/rager/types.rb
+- lib/rager/version.rb
+homepage: https://github.com/mvkvc/rager_ruby
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Build continuously improving AI applications.
+test_files: []