rager 0.6.0 → 0.7.0

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

@@ -23,27 +23,28 @@ module Rager
         def make_request(request)
           uri = URI(request.url)
 
-          Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https") do |http|
-            if request.timeout
-              http.open_timeout = request.timeout
-              http.read_timeout = request.timeout
-            end
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == "https"
 
-            http_request = build_http_request(request, uri)
+          if request.timeout
+            http.open_timeout = request.timeout
+            http.read_timeout = request.timeout
+          end
 
-            http.request(http_request) do |response|
-              body = if request.streaming
-                body_enum(response)
-              else
-                response.body
-              end
+          http_request = build_http_request(request, uri)
 
-              return Rager::Http::Response.new(
-                status: response.code.to_i,
-                headers: response.to_hash,
-                body: body
-              )
+          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(
@@ -95,8 +96,6 @@ module Rager
           )
         end
 
-        private
-
         sig {
           params(
             response: Net::HTTPResponse

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

@@ -4,16 +4,16 @@
 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

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,16 +5,24 @@ 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::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: {
               prompt: prompt
@@ -25,13 +33,9 @@ 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"
-            },
+            headers: headers,
             body: body.to_json,
             timeout: options.timeout || Rager.config.timeout
           )

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,16 @@
 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

data/lib/rager/{mesh_gen → mesh}/providers/abstract.rb

@@ -4,7 +4,7 @@
 require "sorbet-runtime"
 
 module Rager
-  module MeshGen
+  module Mesh
     module Providers
       class Abstract
         extend T::Sig
@@ -14,10 +14,10 @@ module Rager
         sig do
           abstract.params(
             image_url: String,
-            options: Rager::MeshGen::Options
-          ).returns(Rager::Types::MeshGenOutput)
+            options: Rager::Mesh::Options
+          ).returns(Rager::Types::MeshOutput)
         end
-        def mesh_gen(image_url, options)
+        def mesh(image_url, options)
         end
       end
     end

data/lib/rager/{mesh_gen → mesh}/providers/replicate.rb

@@ -6,16 +6,23 @@ require "json"
 require "sorbet-runtime"
 
 module Rager
-  module MeshGen
+  module Mesh
     module Providers
-      class Replicate < Rager::MeshGen::Providers::Abstract
+      class Replicate < Rager::Mesh::Providers::Abstract
         extend T::Sig
 
-        sig { override.params(image_url: String, options: Rager::MeshGen::Options).returns(Rager::Types::MeshGenOutput) }
-        def mesh_gen(image_url, options)
+        sig { override.params(image_url: String, options: Rager::Mesh::Options).returns(Rager::Types::MeshOutput) }
+        def mesh(image_url, options)
           api_key = options.api_key || ENV["REPLICATE_API_KEY"]
           raise Rager::Errors::CredentialsError.new("Replicate", env_var: ["REPLICATE_API_KEY"]) if api_key.nil?
 
+          url = "https://api.replicate.com/v1/predictions"
+
+          headers = {
+            "Authorization" => "Bearer #{api_key}",
+            "Content-Type" => "application/json"
+          }
+
           body = {
             version: options.version,
             input: {
@@ -31,12 +38,9 @@ module Rager
           end
 
           request = Rager::Http::Request.new(
-            url: "https://api.replicate.com/v1/predictions",
+            url: url,
             verb: Rager::Http::Verb::Post,
-            headers: {
-              "Authorization" => "Bearer #{api_key}",
-              "Content-Type" => "application/json"
-            },
+            headers: headers,
             body: body.to_json,
             timeout: options.timeout || Rager.config.timeout
           )

data/lib/rager/operation.rb

@@ -8,8 +8,8 @@ module Rager
     enums do
       Chat = new("chat")
       Embed = new("embed")
-      ImageGen = new("image_gen")
-      MeshGen = new("mesh_gen")
+      Image = new("image")
+      Mesh = new("mesh")
       Rerank = new("rerank")
       Search = new("search")
       Template = new("template")

data/lib/rager/options.rb

@@ -9,7 +9,7 @@ module Rager
     extend T::Helpers
     requires_ancestor { T::Struct }
 
-    sig { returns(T::Hash[String, T.untyped]) }
+    sig { returns(T::Hash[Symbol, T.untyped]) }
     def serialize_safe
       result = T.cast(self, T::Struct).serialize
       result["api_key"] = "[REDACTED]" if result.key?("api_key")

data/lib/rager/outcome.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  class Outcome < T::Struct
+    extend T::Sig
+
+    const :context_id, String
+    const :value, Float
+    const :feedback, T.nilable(String)
+    const :tags, T::Array[T.untyped], default: []
+
+    sig { params(options: T.untyped).returns(String) }
+    def to_json(options = nil)
+      {
+        context_id: context_id,
+        value: value,
+        feedback: feedback,
+        tags: tags
+      }.to_json(options)
+    end
+  end
+end

data/lib/rager/providers.rb

@@ -8,42 +8,54 @@ module Rager
     extend T::Sig
 
     PROVIDERS = T.let({
-      chat: {
-        "openai" => -> { Rager::Chat::Providers::Openai.new }
+      Rager::Operation::Chat => {
+        openai: -> { Rager::Chat::Providers::Openai.new }
       },
-      embed: {
-        "openai" => -> { Rager::Embed::Providers::Openai.new }
+      Rager::Operation::Embed => {
+        openai: -> { Rager::Embed::Providers::Openai.new }
       },
-      rerank: {
-        "cohere" => -> { Rager::Rerank::Providers::Cohere.new }
+      Rager::Operation::Rerank => {
+        cohere: -> { Rager::Rerank::Providers::Cohere.new }
       },
-      image_gen: {
-        "replicate" => -> { Rager::ImageGen::Providers::Replicate.new }
+      Rager::Operation::Image => {
+        replicate: -> { Rager::Image::Providers::Replicate.new }
       },
-      mesh_gen: {
-        "replicate" => -> { Rager::MeshGen::Providers::Replicate.new }
+      Rager::Operation::Mesh => {
+        replicate: -> { Rager::Mesh::Providers::Replicate.new }
       },
-      template: {
-        "erb" => -> { Rager::Template::Providers::Erb.new }
+      Rager::Operation::Template => {
+        erb: -> { Rager::Template::Providers::Erb.new },
+        mustache: -> { Rager::Template::Providers::Mustache.new }
       },
-      search: {
-        "jina" => -> { Rager::Search::Providers::Jina.new }
+      Rager::Operation::Search => {
+        jina: -> { Rager::Search::Providers::Jina.new }
       }
-    }.freeze, T::Hash[Symbol, T::Hash[String, T.proc.returns(T.untyped)]])
+    }, T::Hash[Rager::Operation, T::Hash[Symbol, T.proc.returns(T.untyped)]])
 
-    sig { params(operation: Symbol, provider_name: String, options: Rager::Options).returns(T.untyped) }
-    def self.get_provider(operation, provider_name, options)
+    sig { params(operation: Rager::Operation).returns(T::Array[Symbol]) }
+    def self.list_providers(operation)
+      PROVIDERS.fetch(operation, {}).keys
+    end
+
+    sig {
+      params(
+        operation: Rager::Operation,
+        key: Symbol,
+        options: Rager::Types::Options
+      ).returns(T.untyped)
+    }
+    def self.get_provider(operation, key, options)
       operation_providers = PROVIDERS[operation]
-      if operation_providers&.key?(provider_name.downcase)
-        return T.must(operation_providers[provider_name.downcase]).call
+
+      unless operation_providers&.key?(key)
+        raise Rager::Errors::OptionsError.new(
+          options,
+          ["provider"],
+          details: "Unknown #{operation} provider: #{key}. Known providers: #{list_providers(operation).join(", ")}"
+        )
       end
 
-      known_providers = operation_providers&.keys&.join(", ") || "none"
-      raise Rager::Errors::OptionsError.new(
-        options,
-        ["provider"],
-        details: "Unknown #{operation} provider: #{provider_name}. Known providers: #{known_providers}"
-      )
+      T.must(operation_providers[key]).call
     end
   end
 end

data/lib/rager/rerank/input.rb

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Rerank
+    class Input < T::Struct
+      extend T::Sig
+
+      const :query, String
+      const :documents, T::Array[String]
+
+      sig { params(options: T.untyped).returns(String) }
+      def to_json(options = nil)
+        serialize.to_json(options)
+      end
+    end
+  end
+end

data/lib/rager/rerank/options.rb

@@ -9,10 +9,10 @@ module Rager
       extend T::Sig
       include Rager::Options
 
-      const :provider, String, default: "cohere"
-      const :url, T.nilable(String)
+      const :provider, Symbol, default: :cohere
       const :model, T.nilable(String)
       const :n, T.nilable(Integer)
+      const :url, T.nilable(String)
       const :api_key, T.nilable(String)
       const :timeout, T.nilable(Numeric)
     end

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

@@ -13,12 +13,11 @@ module Rager
 
         sig do
           abstract.params(
-            query: String,
-            documents: T::Array[String],
+            input: Rager::Rerank::Input,
             options: Rager::Rerank::Options
           ).returns(Rager::Types::RerankOutput)
         end
-        def rerank(query, documents, options)
+        def rerank(input, options)
         end
       end
     end

data/lib/rager/rerank/providers/cohere.rb

@@ -13,31 +13,31 @@ module Rager
 
         sig do
           override.params(
-            query: String,
-            documents: T::Array[String],
+            input: Rager::Rerank::Input,
             options: Rager::Rerank::Options
           ).returns(Rager::Types::RerankOutput)
         end
-        def rerank(query, documents, options)
+        def rerank(input, options)
           api_key = options.api_key || ENV["COHERE_API_KEY"]
           raise Rager::Errors::CredentialsError.new("Cohere", env_var: ["COHERE_API_KEY"]) if api_key.nil?
 
           base_url = options.url || ENV["COHERE_URL"] || "https://api.cohere.com/v2"
+          url = "#{base_url}/rerank"
+
+          headers = {"Content-Type" => "application/json"}
+          headers["Authorization"] = "Bearer #{api_key}" if api_key
 
           body = {
             model: options.model || "rerank-v3.5",
-            query: query,
-            documents: documents
+            query: input.query,
+            documents: input.documents
           }.tap do |b|
             b[:top_n] = options.n if options.n
           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}/rerank",
+            url: url,
             headers: headers,
             body: body.to_json,
             timeout: options.timeout || Rager.config.timeout
@@ -49,12 +49,18 @@ module Rager
           raise Rager::Errors::HttpError.new(Rager.config.http_adapter, request.url, response.status, body: response_body) if response.status != 200
 
           parsed_response = JSON.parse(response_body)
-          results = parsed_response["results"] || []
+          results = parsed_response["results"]
 
-          scores = results.map { |r| r["relevance_score"].to_f }
-          reranked_documents = results.map { |r| documents[r["index"]] }
+          results.map do |r|
+            score = r["relevance_score"].to_f
+            content = input.documents[r["index"]]
+            next if content.nil?
 
-          Rager::Rerank::Output.new(scores: scores, documents: reranked_documents)
+            Rager::Rerank::Result.new(
+              score: score,
+              content: content
+            )
+          end
         end
       end
     end

data/lib/rager/rerank/result.rb

@@ -0,0 +1,20 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Rerank
+    class Result < T::Struct
+      extend T::Sig
+
+      const :score, Float
+      const :content, String
+
+      sig { params(options: T.untyped).returns(String) }
+      def to_json(options = nil)
+        serialize.to_json(options)
+      end
+    end
+  end
+end