rager 0.5.0 → 0.7.0

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

@@ -1,19 +1,27 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
 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::MissingCredentialsError.new("Replicate", "REPLICATE_API_KEY") if api_key.nil?
+          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,
@@ -30,24 +38,22 @@ 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"
-            },
-            body: body.to_json
+            headers: headers,
+            body: body.to_json,
+            timeout: options.timeout || Rager.config.timeout
           )
 
           response = Rager.config.http_adapter.make_request(request)
           response_body = T.cast(T.must(response.body), String)
 
-          raise Rager::Errors::HttpError.new(Rager.config.http_adapter, response.status, response_body) unless [200, 201, 202].include?(response.status)
+          raise Rager::Errors::HttpError.new(Rager.config.http_adapter, request.url, response.status, body: response_body) unless [200, 201, 202].include?(response.status)
 
           json = JSON.parse(response_body)
           json.fetch("urls").fetch("get")
         rescue JSON::ParserError, KeyError => e
-          raise Rager::Errors::ParseError.new(e.message, response_body)
+          raise Rager::Errors::ParseError.new(response_body || "", details: e.message)
         end
       end
     end

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

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Providers
+    extend T::Sig
+
+    PROVIDERS = T.let({
+      Rager::Operation::Chat => {
+        openai: -> { Rager::Chat::Providers::Openai.new }
+      },
+      Rager::Operation::Embed => {
+        openai: -> { Rager::Embed::Providers::Openai.new }
+      },
+      Rager::Operation::Rerank => {
+        cohere: -> { Rager::Rerank::Providers::Cohere.new }
+      },
+      Rager::Operation::Image => {
+        replicate: -> { Rager::Image::Providers::Replicate.new }
+      },
+      Rager::Operation::Mesh => {
+        replicate: -> { Rager::Mesh::Providers::Replicate.new }
+      },
+      Rager::Operation::Template => {
+        erb: -> { Rager::Template::Providers::Erb.new },
+        mustache: -> { Rager::Template::Providers::Mustache.new }
+      },
+      Rager::Operation::Search => {
+        jina: -> { Rager::Search::Providers::Jina.new }
+      }
+    }, T::Hash[Rager::Operation, T::Hash[Symbol, T.proc.returns(T.untyped)]])
+
+    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]
+
+      unless operation_providers&.key?(key)
+        raise Rager::Errors::OptionsError.new(
+          options,
+          ["provider"],
+          details: "Unknown #{operation} provider: #{key}. Known providers: #{list_providers(operation).join(", ")}"
+        )
+      end
+
+      T.must(operation_providers[key]).call
+    end
+  end
+end

data/lib/rager/rerank/{query.rb → input.rb}

@@ -5,9 +5,16 @@ require "sorbet-runtime"
 
 module Rager
   module Rerank
-    class Query < T::Struct
+    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,11 +9,12 @@ 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
   end
 end

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

@@ -13,11 +13,11 @@ module Rager
 
         sig do
           abstract.params(
-            query: Rager::Rerank::Query,
+            input: Rager::Rerank::Input,
             options: Rager::Rerank::Options
           ).returns(Rager::Types::RerankOutput)
         end
-        def rerank(query, options)
+        def rerank(input, options)
         end
       end
     end

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

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "json"
+
 require "sorbet-runtime"
 
 module Rager
@@ -12,44 +13,52 @@ module Rager
 
         sig do
           override.params(
-            query: Rager::Rerank::Query,
+            input: Rager::Rerank::Input,
             options: Rager::Rerank::Options
           ).returns(Rager::Types::RerankOutput)
         end
-        def rerank(query, options)
+        def rerank(input, options)
           api_key = options.api_key || ENV["COHERE_API_KEY"]
-          raise Rager::Errors::MissingCredentialsError.new("Cohere", "COHERE_API_KEY") if api_key.nil?
+          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.query,
-            documents: query.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: options.url || ENV["COHERE_URL"] || "https://api.cohere.com/v2/rerank",
+            url: url,
             headers: headers,
-            body: body.to_json
+            body: body.to_json,
+            timeout: options.timeout || Rager.config.timeout
           )
 
           response = Rager.config.http_adapter.make_request(request)
           response_body = T.cast(T.must(response.body), String)
 
-          raise Rager::Errors::HttpError.new(Rager.config.http_adapter, response.status, response_body) if response.status != 200
+          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"]
+
+          results.map do |r|
+            score = r["relevance_score"].to_f
+            content = input.documents[r["index"]]
+            next if content.nil?
 
-          results.map do |result|
             Rager::Rerank::Result.new(
-              score: result["relevance_score"],
-              index: result["index"]
+              score: score,
+              content: content
             )
           end
         end

data/lib/rager/rerank/result.rb

@@ -6,8 +6,15 @@ require "sorbet-runtime"
 module Rager
   module Rerank
     class Result < T::Struct
+      extend T::Sig
+
       const :score, Float
-      const :index, Integer
+      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/result.rb

@@ -4,6 +4,7 @@
 require "json"
 require "logger"
 require "securerandom"
+
 require "sorbet-runtime"
 
 module Rager
@@ -25,7 +26,7 @@ module Rager
     sig { returns(T.nilable(Rager::Types::Output)) }
     attr_reader :output
 
-    sig { returns(Rager::Options) }
+    sig { returns(Rager::Types::Options) }
     attr_reader :options
 
     sig { returns(Integer) }
@@ -34,17 +35,29 @@ module Rager
     sig { returns(Integer) }
     attr_reader :end_time
 
+    sig { returns(Integer) }
+    attr_reader :attempt
+
+    sig { returns(T::Array[String]) }
+    attr_reader :errors
+
+    sig { returns(T::Array[String]) }
+    attr_reader :input_ids
+
     sig { returns(T.nilable(String)) }
     attr_reader :name
 
+    sig { returns(T::Array[String]) }
+    attr_reader :tags
+
     sig { returns(T.nilable(String)) }
     attr_reader :context_name
 
-    sig { returns(T.nilable(T::Array[String])) }
-    attr_reader :iids
+    sig { returns(T::Array[String]) }
+    attr_reader :context_tags
 
-    sig { returns(T.nilable(String)) }
-    attr_reader :error
+    sig { returns(T.untyped) }
+    attr_reader :transform
 
     sig do
       params(
@@ -53,29 +66,20 @@ module Rager
         operation: Rager::Operation,
         input: Rager::Types::Input,
         output: T.nilable(Rager::Types::Output),
-        options: Rager::Options,
+        options: Rager::Types::Options,
         start_time: Integer,
         end_time: Integer,
+        attempt: Integer,
+        errors: T::Array[String],
+        input_ids: T::Array[String],
         name: T.nilable(String),
+        tags: T::Array[String],
         context_name: T.nilable(String),
-        iids: T.nilable(T::Array[String]),
-        error: T.nilable(String)
+        context_tags: T::Array[String],
+        transform: T.untyped
       ).void
     end
-    def initialize(
-      id:,
-      context_id:,
-      operation:,
-      input:,
-      output:,
-      options:,
-      start_time:,
-      end_time:,
-      name: nil,
-      context_name: nil,
-      iids: nil,
-      error: nil
-    )
+    def initialize(id:, context_id:, operation:, input:, output:, options:, start_time:, end_time:, attempt: 0, errors: [], input_ids: [], name: nil, tags: [], context_name: nil, context_tags: [], transform: nil)
       @id = id
       @context_id = context_id
       @operation = operation
@@ -84,10 +88,14 @@ module Rager
       @options = options
       @start_time = start_time
       @end_time = end_time
-      @name = T.let(name, T.nilable(String))
-      @context_name = T.let(context_name, T.nilable(String))
-      @iids = T.let(iids, T.nilable(T::Array[String]))
-      @error = T.let(error, T.nilable(String))
+      @attempt = attempt
+      @errors = T.let(errors, T::Array[String])
+      @input_ids = T.let(input_ids, T::Array[String])
+      @name = name
+      @tags = tags
+      @context_name = context_name
+      @context_tags = T.let(context_tags, T::Array[String])
+      @transform = transform
 
       @stream = T.let(nil, T.nilable(Rager::Types::Stream))
       @buffer = T.let([], Rager::Types::Buffer)
@@ -96,7 +104,7 @@ module Rager
 
     sig { returns(T::Boolean) }
     def success?
-      @error.nil?
+      @errors.empty?
     end
 
     sig { returns(T::Boolean) }
@@ -105,7 +113,7 @@ module Rager
     end
 
     sig { returns(Rager::Types::Output) }
-    def out
+    def stream
       return T.must(@output) unless stream?
       return @buffer.each if @consumed
 
@@ -125,62 +133,53 @@ module Rager
       @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
+    sig { returns(T.untyped) }
+    def value
+      return @transform if @transform
 
-      parts = {}
+      return T.cast(@output, Rager::Types::NonStreamOutput) unless stream?
 
-      @buffer.each do |message_delta|
-        parts[message_delta.index] =
-          (parts[message_delta.index] || "") + message_delta.content
-      end
+      T.cast(stream, Rager::Types::Stream).each { |_| } unless @consumed
 
-      parts
-        .sort_by { |index, _| index }
-        .map { |_, content| content }
+      @buffer
+        .group_by(&:index)
+        .transform_values { |deltas| deltas.map(&:content).join }
+        .sort
+        .map(&:last)
+        .then { |parts| (parts.length == 1) ? parts.first : parts }
     end
 
     sig do
-      returns(
-        T.any(
-          String,
-          T::Hash[String, T.untyped],
-          T::Array[T.untyped]
-        )
-      )
-    end
-    def serialize_input
-      case @input
-      when String
-        @input
-      when Rager::Rerank::Query
-        @input.serialize
-      when Rager::Template::Input
-        @input.serialize
-      when Array
-        @input.map do |item|
-          if !item.is_a?(String)
-            item.serialize
-          else
-            item
-          end
-        end
-      end
+      params(
+        block: T.proc.params(
+          value: Rager::Types::NonStreamOutput
+        ).returns(T.untyped)
+      ).returns(Rager::Result)
     end
-
-    sig { returns(T.nilable(Rager::Types::NonStreamOutput)) }
-    def serialize_output
-      return nil unless success?
-      return @consumed ? mat : "[STREAM]" if stream?
-      T.cast(@output, Rager::Types::NonStreamOutput)
+    def let(&block)
+      transform = yield(value)
+
+      Result.new(
+        id: @id,
+        context_id: @context_id,
+        operation: @operation,
+        input: @input,
+        output: @output,
+        options: @options,
+        start_time: @start_time,
+        end_time: @end_time,
+        attempt: @attempt,
+        errors: @errors,
+        input_ids: @input_ids,
+        name: @name,
+        tags: @tags,
+        context_name: @context_name,
+        context_tags: @context_tags,
+        transform: transform
+      )
     end
 
-    sig { returns(T::Hash[String, T.untyped]) }
+    sig { returns(T::Hash[Symbol, T.untyped]) }
     def to_h
       {
         version: "1",
@@ -188,53 +187,44 @@ module Rager
           id: @id,
           context_id: @context_id,
           operation: @operation.serialize,
-          input: serialize_input,
-          output: serialize_output,
+          input: @input,
+          output: display_output,
           options: @options.serialize_safe,
           start_time: @start_time,
           end_time: @end_time,
+          attempt: @attempt,
+          errors: @errors,
+          input_ids: @input_ids,
           name: @name,
+          tags: @tags,
           context_name: @context_name,
-          iids: @iids,
-          error: @error
+          context_tags: @context_tags
         }
       }
     end
 
+    sig { returns(String) }
+    def to_json
+      to_h.to_json
+    end
+
     sig { void }
     def log
-      return unless Rager.config.logger_type
-
-      json = to_h.to_json
-
-      logger = Rager.config.logger
-
-      case Rager.config.logger_type
-      when Rager::Logger::Stdout
-        success? ? logger.info(json) : logger.error(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}"
-        }
+      Rager::Utils::Http.log_remote(
+        "results",
+        to_json,
+        !success?
+      )
+    end
 
-        if url && api_key
-          request = Rager::Http::Request.new(
-            url: url,
-            verb: Rager::Http::Verb::Post,
-            headers: headers,
-            body: json
-          )
+    private
 
-          response = http_adapter.make_request(request)
+    sig { returns(T.nilable(Rager::Types::NonStreamOutput)) }
+    def display_output
+      return nil unless success?
+      return @consumed ? value : "[STREAM]" if stream?
 
-          logger.warn "Remote log failed: \\#{response.status} \\#{response.body}" unless response.success?
-        end
-      end
+      T.cast(@output, Rager::Types::NonStreamOutput)
     end
   end
 end

data/lib/rager/search/options.rb

@@ -9,9 +9,12 @@ module Rager
       extend T::Sig
       include Rager::Options
 
-      const :provider, String, default: "brave"
+      const :provider, Symbol, default: :jina
       const :n, T.nilable(Integer)
+      const :pagination, T.nilable(Integer)
+      const :max_length, T.nilable(Integer)
       const :api_key, T.nilable(String)
+      const :timeout, T.nilable(Numeric)
     end
   end
 end