rager 0.5.0 → 0.6.0

data/lib/rager/mesh_gen/providers/replicate.rb

@@ -1,9 +1,10 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
 require "json"
 
+require "sorbet-runtime"
+
 module Rager
   module MeshGen
     module Providers
@@ -13,7 +14,7 @@ module Rager
         sig { override.params(image_url: String, options: Rager::MeshGen::Options).returns(Rager::Types::MeshGenOutput) }
         def mesh_gen(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?
 
           body = {
             version: options.version,
@@ -36,18 +37,19 @@ module Rager
               "Authorization" => "Bearer #{api_key}",
               "Content-Type" => "application/json"
             },
-            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) 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/providers.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Providers
+    extend T::Sig
+
+    PROVIDERS = T.let({
+      chat: {
+        "openai" => -> { Rager::Chat::Providers::Openai.new }
+      },
+      embed: {
+        "openai" => -> { Rager::Embed::Providers::Openai.new }
+      },
+      rerank: {
+        "cohere" => -> { Rager::Rerank::Providers::Cohere.new }
+      },
+      image_gen: {
+        "replicate" => -> { Rager::ImageGen::Providers::Replicate.new }
+      },
+      mesh_gen: {
+        "replicate" => -> { Rager::MeshGen::Providers::Replicate.new }
+      },
+      template: {
+        "erb" => -> { Rager::Template::Providers::Erb.new }
+      },
+      search: {
+        "jina" => -> { Rager::Search::Providers::Jina.new }
+      }
+    }.freeze, T::Hash[Symbol, T::Hash[String, 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)
+      operation_providers = PROVIDERS[operation]
+      if operation_providers&.key?(provider_name.downcase)
+        return T.must(operation_providers[provider_name.downcase]).call
+      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}"
+      )
+    end
+  end
+end

data/lib/rager/rerank/options.rb

@@ -14,6 +14,7 @@ module Rager
       const :model, T.nilable(String)
       const :n, T.nilable(Integer)
       const :api_key, T.nilable(String)
+      const :timeout, T.nilable(Numeric)
     end
   end
 end

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

@@ -5,8 +5,8 @@ require "sorbet-runtime"
 
 module Rager
   module Rerank
-    class Query < T::Struct
-      const :query, String
+    class Output < T::Struct
+      const :scores, T::Array[Float]
       const :documents, T::Array[String]
     end
   end

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

@@ -13,11 +13,12 @@ module Rager
 
         sig do
           abstract.params(
-            query: Rager::Rerank::Query,
+            query: String,
+            documents: T::Array[String],
             options: Rager::Rerank::Options
           ).returns(Rager::Types::RerankOutput)
         end
-        def rerank(query, options)
+        def rerank(query, documents, 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,18 +13,21 @@ module Rager
 
         sig do
           override.params(
-            query: Rager::Rerank::Query,
+            query: String,
+            documents: T::Array[String],
             options: Rager::Rerank::Options
           ).returns(Rager::Types::RerankOutput)
         end
-        def rerank(query, options)
+        def rerank(query, documents, 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"
 
           body = {
             model: options.model || "rerank-v3.5",
-            query: query.query,
-            documents: query.documents
+            query: query,
+            documents: documents
           }.tap do |b|
             b[:top_n] = options.n if options.n
           end
@@ -33,25 +37,24 @@ module Rager
 
           request = Rager::Http::Request.new(
             verb: Rager::Http::Verb::Post,
-            url: options.url || ENV["COHERE_URL"] || "https://api.cohere.com/v2/rerank",
+            url: "#{base_url}/rerank",
             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.map do |result|
-            Rager::Rerank::Result.new(
-              score: result["relevance_score"],
-              index: result["index"]
-            )
-          end
+          scores = results.map { |r| r["relevance_score"].to_f }
+          reranked_documents = results.map { |r| documents[r["index"]] }
+
+          Rager::Rerank::Output.new(scores: scores, documents: reranked_documents)
         end
       end
     end

data/lib/rager/result.rb

@@ -4,6 +4,7 @@
 require "json"
 require "logger"
 require "securerandom"
+
 require "sorbet-runtime"
 
 module Rager
@@ -40,11 +41,17 @@ module Rager
     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 :tags
 
-    sig { returns(T.nilable(String)) }
-    attr_reader :error
+    sig { returns(T::Array[String]) }
+    attr_reader :input_ids
+
+    sig { returns(T::Array[String]) }
+    attr_reader :errors
+
+    sig { returns(Integer) }
+    attr_reader :attempt
 
     sig do
       params(
@@ -58,8 +65,10 @@ module Rager
         end_time: Integer,
         name: T.nilable(String),
         context_name: T.nilable(String),
-        iids: T.nilable(T::Array[String]),
-        error: T.nilable(String)
+        tags: T::Array[String],
+        input_ids: T::Array[String],
+        errors: T::Array[String],
+        attempt: Integer
       ).void
     end
     def initialize(
@@ -73,8 +82,10 @@ module Rager
       end_time:,
       name: nil,
       context_name: nil,
-      iids: nil,
-      error: nil
+      tags: [],
+      input_ids: [],
+      errors: [],
+      attempt: 0
     )
       @id = id
       @context_id = context_id
@@ -86,8 +97,10 @@ module Rager
       @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))
+      @tags = T.let(tags, T::Array[String])
+      @input_ids = T.let(input_ids, T::Array[String])
+      @errors = T.let(errors, T::Array[String])
+      @attempt = attempt
 
       @stream = T.let(nil, T.nilable(Rager::Types::Stream))
       @buffer = T.let([], Rager::Types::Buffer)
@@ -96,7 +109,7 @@ module Rager
 
     sig { returns(T::Boolean) }
     def success?
-      @error.nil?
+      @errors.empty?
     end
 
     sig { returns(T::Boolean) }
@@ -143,6 +156,7 @@ module Rager
       parts
         .sort_by { |index, _| index }
         .map { |_, content| content }
+        .then { |parts| (parts.length == 1) ? parts.first : parts }
     end
 
     sig do
@@ -158,10 +172,8 @@ module Rager
       case @input
       when String
         @input
-      when Rager::Rerank::Query
-        @input.serialize
-      when Rager::Template::Input
-        @input.serialize
+      when Hash
+        @input.transform_keys(&:to_s)
       when Array
         @input.map do |item|
           if !item.is_a?(String)
@@ -170,6 +182,8 @@ module Rager
             item
           end
         end
+      else
+        @input.to_s
       end
     end
 
@@ -183,20 +197,22 @@ module Rager
     sig { returns(T::Hash[String, T.untyped]) }
     def to_h
       {
+        id: @id,
         version: "1",
         data: {
-          id: @id,
           context_id: @context_id,
           operation: @operation.serialize,
-          input: serialize_input,
-          output: serialize_output,
+          input: {input: serialize_input},
+          output: {output: serialize_output},
           options: @options.serialize_safe,
           start_time: @start_time,
           end_time: @end_time,
           name: @name,
           context_name: @context_name,
-          iids: @iids,
-          error: @error
+          tags: @tags,
+          input_ids: @input_ids,
+          errors: @errors,
+          attempt: @attempt
         }
       }
     end
@@ -217,22 +233,26 @@ module Rager
         url = Rager.config.url
         api_key = Rager.config.api_key
 
+        unless url && api_key
+          raise Rager::Errors::CredentialsError.new("Rager Cloud", details: "Missing url or api_key for remote logging")
+        end
+
         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
-          )
+        request = Rager::Http::Request.new(
+          url: url,
+          verb: Rager::Http::Verb::Post,
+          headers: headers,
+          body: json
+        )
 
-          response = http_adapter.make_request(request)
+        response = http_adapter.make_request(request)
 
-          logger.warn "Remote log failed: \\#{response.status} \\#{response.body}" unless response.success?
+        unless response.success?
+          logger.error("Failed to log to remote server: #{response.status} #{response.body}")
         end
       end
     end

data/lib/rager/search/options.rb

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

data/lib/rager/search/output.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Search
+    class Output < T::Struct
+      const :urls, T::Array[String]
+      const :titles, T::Array[String]
+      const :contents, T::Array[String]
+    end
+  end
+end

data/lib/rager/search/providers/jina.rb

@@ -0,0 +1,67 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+
+require "sorbet-runtime"
+
+module Rager
+  module Search
+    module Providers
+      class Jina < Rager::Search::Providers::Abstract
+        extend T::Sig
+
+        sig do
+          override.params(
+            query: String,
+            options: Rager::Search::Options
+          ).returns(Rager::Types::SearchOutput)
+        end
+        def search(query, options)
+          api_key = options.api_key || ENV["JINA_API_KEY"]
+          raise Rager::Errors::CredentialsError.new("Jina", env_var: ["JINA_API_KEY"]) if api_key.nil?
+
+          params = {"q" => query}
+
+          headers = {
+            "Accept" => "application/json",
+            "X-Return-Format" => "markdown"
+          }
+
+          headers["Authorization"] = "Bearer #{api_key}" if api_key
+
+          request = Rager::Http::Request.new(
+            verb: Rager::Http::Verb::Get,
+            url: "https://s.jina.ai/?#{URI.encode_www_form(params)}",
+            headers: headers,
+            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, request.url, response.status, body: response_body) if response.status != 200
+
+          parsed_response = JSON.parse(response_body)
+          search_results = parsed_response["data"] || []
+
+          search_results = search_results.first(options.n) if options.n
+
+          urls = search_results.map { |r| r["url"] }
+          titles = search_results.map { |r| r["title"] }
+          contents = search_results.map { |r|
+            content = r["content"] || r["description"]
+            options.max_length ? content&.slice(0, options.max_length) : content
+          }
+
+          Rager::Search::Output.new(
+            urls: urls,
+            titles: titles,
+            contents: contents
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -14,11 +14,12 @@ module Rager
 
         sig do
           abstract.params(
-            input: Rager::Template::Input,
+            template: String,
+            variables: T::Hash[Symbol, T.untyped],
             options: Rager::Template::Options
           ).returns(Rager::Types::TemplateOutput)
         end
-        def template(input, options)
+        def template(template, variables, options)
         end
       end
     end

data/lib/rager/template/providers/erb.rb

@@ -2,7 +2,6 @@
 # frozen_string_literal: true
 
 require "erb"
-require "ostruct"
 
 module Rager
   module Template
@@ -12,13 +11,15 @@ module Rager
 
         sig do
           override.params(
-            input: Rager::Template::Input,
+            template: String,
+            variables: T::Hash[Symbol, T.untyped],
             options: Rager::Template::Options
           ).returns(Rager::Types::TemplateOutput)
         end
-        def template(input, options)
-          scope = OpenStruct.new(input.variables)
-          ERB.new(input.template).result(scope.instance_eval { binding })
+        def template(template, variables, options)
+          ERB.new(template).result_with_hash(variables)
+        rescue SyntaxError, NameError => e
+          raise Rager::Errors::TemplateError.new(template, variables, details: e.message)
         end
       end
     end

data/lib/rager/types.rb

@@ -1,6 +1,9 @@
 # typed: strict
 # frozen_string_literal: true
 
+require_relative "rerank/output"
+require_relative "search/output"
+
 module Rager
   module Types
     extend T::Sig
@@ -9,9 +12,9 @@ module Rager
     EmbedInput = T.type_alias { T::Array[String] }
     ImageGenInput = T.type_alias { String }
     MeshGenInput = T.type_alias { String }
-    RerankInput = T.type_alias { Rager::Rerank::Query }
+    RerankInput = T.type_alias { {query: String, documents: T.any(T::Array[String], T::Array[T::Hash[Symbol, String]])} }
     SearchInput = T.type_alias { String }
-    TemplateInput = T.type_alias { Rager::Template::Input }
+    TemplateInput = T.type_alias { {template: String, variables: T::Hash[Symbol, T.untyped]} }
     Input = T.type_alias {
       T.any(
         ChatInput,
@@ -20,24 +23,25 @@ module Rager
         MeshGenInput,
         RerankInput,
         SearchInput,
-        TemplateInput
+        TemplateInput,
+        Rager::Result
       )
     }
 
-    ChatNonStream = T.type_alias { T::Array[String] }
-
     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 }
 
+    ChatNonStream = T.type_alias { T.any(String, T::Array[String]) }
+
     ChatOutput = T.type_alias { T.any(ChatNonStream, ChatStream) }
     EmbedOutput = T.type_alias { T::Array[T::Array[Float]] }
     ImageGenOutput = T.type_alias { String }
     MeshGenOutput = T.type_alias { String }
-    RerankOutput = T.type_alias { T::Array[Rager::Rerank::Result] }
-    SearchOutput = T.type_alias { T::Array[Rager::Search::Result] }
+    RerankOutput = T.type_alias { Rager::Rerank::Output }
+    SearchOutput = T.type_alias { Rager::Search::Output }
     TemplateOutput = T.type_alias { String }
     Output = T.type_alias {
       T.any(

data/lib/rager/utils/http.rb

@@ -1,48 +1,55 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
+require "fileutils"
+require "json"
+require "net/http"
 require "uri"
 
+require "sorbet-runtime"
+
 module Rager
   module Utils
     module Http
       extend T::Sig
 
-      sig { params(url: String, headers: T.nilable(T::Hash[String, String])).returns(T.nilable(String)) }
-      def self.download_binary(url, headers = nil)
-        response = Rager.config.http_adapter.make_request(
-          Rager::Http::Request.new(url: url, headers: headers || {})
-        )
-
-        if response.success? && response.body
-          binary_data = T.cast(response.body, String)
-          binary_data.force_encoding(Encoding::BINARY)
-          binary_data
+      sig { params(duration: Numeric).void }
+      def self.sleep(duration)
+        if defined?(Async::Task) && (task = Async::Task.current?)
+          task.sleep(duration)
+        else
+          Kernel.sleep(duration)
         end
-      rescue
-        nil
       end
 
-      sig { params(url: String, path: T.nilable(String), headers: T.nilable(T::Hash[String, String])).returns(String) }
-      def self.download_file(url, path = nil, headers = nil)
-        path ||= begin
-          uri_path = URI.parse(url).path
-          if uri_path.nil? || uri_path.empty?
-            "output"
-          else
-            filename = File.basename(uri_path)
-            filename.empty? ? "output" : filename
-          end
+      sig { params(url: String, http_adapter: T.nilable(Rager::Http::Adapters::Abstract)).returns(T.nilable(String)) }
+      def self.download_binary(url, http_adapter: nil)
+        adapter = http_adapter || Rager.config.http_adapter
+        response = adapter.make_request(
+          Rager::Http::Request.new(url: url, headers: {})
+        )
+
+        return nil unless response.success?
+        body = response.body
+        return nil if body.nil?
+
+        if body.is_a?(String)
+          body
+        elsif body.respond_to?(:each)
+          body.to_a.join
+        else
+          body.to_s
         end
+      end
 
-        binary_data = download_binary(url, headers)
-        raise Rager::Errors::HttpError.new(Rager.config.http_adapter, 500, "Download failed") if binary_data.nil?
+      sig { params(url: String, path: String, http_adapter: T.nilable(Rager::Http::Adapters::Abstract)).returns(T.nilable(String)) }
+      def self.download_file(url, path, http_adapter: nil)
+        content = download_binary(url, http_adapter: http_adapter)
+        return nil if content.nil?
 
-        File.binwrite(path, binary_data)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content)
         path
-      rescue => e
-        raise Rager::Errors::HttpError.new(Rager.config.http_adapter, 500, "Download failed: #{e.message}")
       end
     end
   end