rager 0.5.0 → 0.7.0

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

@@ -0,0 +1,68 @@
+# 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?
+
+          base_url = "https://s.jina.ai"
+          url = "#{base_url}/?#{URI.encode_www_form({"q" => query})}"
+          pagination = options.pagination
+          url = "#{url}&page=#{pagination}" if pagination && pagination > 1
+
+          headers = {
+            "Accept" => "application/json",
+            "X-Return-Format" => "markdown"
+          }.tap do |h|
+            h["Authorization"] = "Bearer #{api_key}" if api_key
+          end
+
+          request = Rager::Http::Request.new(
+            verb: Rager::Http::Verb::Get,
+            url: url,
+            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
+
+          search_results.map do |r|
+            content = r["content"] || r["description"]
+            content = content&.slice(0, options.max_length) if options.max_length
+
+            Rager::Search::Result.new(
+              url: r["url"],
+              title: r["title"],
+              content: content
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rager/search/result.rb

@@ -6,9 +6,16 @@ require "sorbet-runtime"
 module Rager
   module Search
     class Result < T::Struct
-      const :title, String
+      extend T::Sig
+
       const :url, String
-      const :description, String
+      const :title, String
+      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/template/input.rb

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

data/lib/rager/template/options.rb

@@ -7,7 +7,7 @@ module Rager
       include Rager::Options
       extend T::Sig
 
-      const :provider, String, default: "erb"
+      const :provider, Symbol, default: :erb
     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
@@ -17,8 +16,9 @@ module Rager
           ).returns(Rager::Types::TemplateOutput)
         end
         def template(input, options)
-          scope = OpenStruct.new(input.variables)
-          ERB.new(input.template).result(scope.instance_eval { binding })
+          ERB.new(input.template).result_with_hash(input.variables)
+        rescue SyntaxError, NameError => e
+          raise Rager::Errors::TemplateError.new(input.template, input.variables, details: e.message)
         end
       end
     end

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

@@ -0,0 +1,30 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Rager
+  module Template
+    module Providers
+      class Mustache < Rager::Template::Providers::Abstract
+        extend T::Sig
+
+        sig do
+          override.params(
+            input: Rager::Template::Input,
+            options: Rager::Template::Options
+          ).returns(Rager::Types::TemplateOutput)
+        end
+        def template(input, options)
+          begin
+            require "mustache"
+          rescue LoadError
+            raise Rager::Errors::DependencyError.new("mustache", details: "Please install the mustache gem to use mustache templates")
+          end
+
+          ::Mustache.render(input.template, input.variables)
+        rescue ::Mustache::Parser::SyntaxError, ::Mustache::ContextMiss => e
+          raise Rager::Errors::TemplateError.new(input.template, input.variables, details: e.message)
+        end
+      end
+    end
+  end
+end

data/lib/rager/types.rb

@@ -7,35 +7,35 @@ module Rager
 
     ChatInput = T.type_alias { T::Array[Rager::Chat::Message] }
     EmbedInput = T.type_alias { T::Array[String] }
-    ImageGenInput = T.type_alias { String }
-    MeshGenInput = T.type_alias { String }
-    RerankInput = T.type_alias { Rager::Rerank::Query }
+    ImageInput = T.type_alias { String }
+    MeshInput = T.type_alias { String }
+    RerankInput = T.type_alias { Rager::Rerank::Input }
     SearchInput = T.type_alias { String }
     TemplateInput = T.type_alias { Rager::Template::Input }
     Input = T.type_alias {
       T.any(
         ChatInput,
         EmbedInput,
-        ImageGenInput,
-        MeshGenInput,
+        ImageInput,
+        MeshInput,
         RerankInput,
         SearchInput,
         TemplateInput
       )
     }
 
-    ChatNonStream = T.type_alias { T::Array[String] }
-
-    ChatStream = T.type_alias { T::Enumerator[Rager::Chat::MessageDelta] }
-    Stream = T.type_alias { ChatStream }
+    ChatStreamOutput = T.type_alias { T::Enumerator[Rager::Chat::MessageDelta] }
+    Stream = T.type_alias { ChatStreamOutput }
 
     ChatBuffer = T.type_alias { T::Array[Rager::Chat::MessageDelta] }
     Buffer = T.type_alias { ChatBuffer }
 
-    ChatOutput = T.type_alias { T.any(ChatNonStream, ChatStream) }
+    ChatNonStreamOutput = T.type_alias { T.any(String, T::Array[String]) }
+
+    ChatOutput = T.type_alias { T.any(ChatNonStreamOutput, ChatStreamOutput) }
     EmbedOutput = T.type_alias { T::Array[T::Array[Float]] }
-    ImageGenOutput = T.type_alias { String }
-    MeshGenOutput = T.type_alias { String }
+    ImageOutput = T.type_alias { String }
+    MeshOutput = T.type_alias { String }
     RerankOutput = T.type_alias { T::Array[Rager::Rerank::Result] }
     SearchOutput = T.type_alias { T::Array[Rager::Search::Result] }
     TemplateOutput = T.type_alias { String }
@@ -43,25 +43,36 @@ module Rager
       T.any(
         ChatOutput,
         EmbedOutput,
-        ImageGenOutput,
-        MeshGenOutput,
+        ImageOutput,
+        MeshOutput,
         RerankOutput,
         SearchOutput,
         TemplateOutput
       )
     }
 
-    ChatNonStreamOutput = T.type_alias { ChatNonStream }
     NonStreamOutput = T.type_alias {
       T.any(
         ChatNonStreamOutput,
         EmbedOutput,
-        ImageGenOutput,
-        MeshGenOutput,
+        ImageOutput,
+        MeshOutput,
         RerankOutput,
         SearchOutput,
         TemplateOutput
       )
     }
+
+    Options = T.type_alias {
+      T.any(
+        Rager::Chat::Options,
+        Rager::Embed::Options,
+        Rager::Image::Options,
+        Rager::Mesh::Options,
+        Rager::Rerank::Options,
+        Rager::Search::Options,
+        Rager::Template::Options
+      )
+    }
   end
 end

data/lib/rager/utils/http.rb

@@ -1,48 +1,113 @@
 # 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 || {})
+      sig {
+        params(
+          url: String,
+          http_adapter: T.nilable(Rager::Http::Adapters::Abstract)
+        ).returns(T.nilable(String))
+      }
+      def self.download(url, http_adapter: nil)
+        adapter = http_adapter || Rager.config.http_adapter
+        response = adapter.make_request(
+          Rager::Http::Request.new(url: url, headers: {})
         )
 
-        if response.success? && response.body
-          binary_data = T.cast(response.body, String)
-          binary_data.force_encoding(Encoding::BINARY)
-          binary_data
+        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
-      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
+      sig {
+        params(
+          url: String,
+          path: String,
+          http_adapter: T.nilable(Rager::Http::Adapters::Abstract)
+        ).returns(T.nilable(String))
+      }
+      def self.download_to_file(url, path, http_adapter: nil)
+        content = download(url, http_adapter: http_adapter)
+        return nil if content.nil?
+
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, content, mode: "wb")
+        path
+      end
+
+      sig do
+        params(
+          endpoint: String,
+          body: String,
+          error: T::Boolean
+        ).void
+      end
+      def self.log_remote(endpoint, body, error = false)
+        logger = Rager.config.logger
+
+        case Rager.config.log_strategy
+        when Rager::LogStrategy::Stdout
+          error ? logger.error(body) : logger.info(body)
+        when Rager::LogStrategy::Remote
+          http_adapter = Rager.config.http_adapter
+          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
-        end
 
-        binary_data = download_binary(url, headers)
-        raise Rager::Errors::HttpError.new(Rager.config.http_adapter, 500, "Download failed") if binary_data.nil?
+          headers = {
+            "Content-Type" => "application/json",
+            "Authorization" => "Bearer #{api_key}"
+          }
 
-        File.binwrite(path, binary_data)
-        path
-      rescue => e
-        raise Rager::Errors::HttpError.new(Rager.config.http_adapter, 500, "Download failed: #{e.message}")
+          request = Rager::Http::Request.new(
+            url: "#{url}/#{endpoint}",
+            verb: Rager::Http::Verb::Post,
+            headers: headers,
+            body: body
+          )
+
+          begin
+            response = http_adapter.make_request(request)
+
+            unless response.success?
+              raise Rager::Errors::HttpError.new(
+                http_adapter,
+                request.url,
+                response.status,
+                body: T.cast(response.body, String),
+                details: "HTTP request failed during remote logging"
+              )
+            end
+          rescue Rager::Error => e
+            if Rager.config.log_raise
+              raise e
+            else
+              Rager.config.logger.error(e.message)
+            end
+          end
+        end
       end
     end
   end

data/lib/rager/utils/replicate.rb

@@ -1,38 +1,48 @@
 # typed: strict
 # frozen_string_literal: true
 
-require "sorbet-runtime"
 require "json"
 
+require "sorbet-runtime"
+
 module Rager
   module Utils
     module Replicate
       extend T::Sig
 
-      sig { params(prediction_url: String, key: T.nilable(String), http_adapter: T.nilable(Rager::Http::Adapters::Abstract)).returns(T.nilable(String)) }
+      sig {
+        params(
+          prediction_url: String,
+          key: T.nilable(String),
+          http_adapter: T.nilable(Rager::Http::Adapters::Abstract)
+        ).returns(T.nilable(String))
+      }
       def self.download_prediction(prediction_url, key = nil, http_adapter: nil)
         download_url = get_download_url(prediction_url, key, http_adapter: http_adapter)
         return nil if download_url.nil?
 
-        Rager::Utils::Http.download_binary(download_url)
-      rescue
-        nil
+        Rager::Utils::Http.download(download_url)
       end
 
-      sig { params(prediction_url: String, key: T.nilable(String), path: String, http_adapter: T.nilable(Rager::Http::Adapters::Abstract)).returns(T.nilable(String)) }
+      sig {
+        params(
+          prediction_url: String,
+          key: T.nilable(String),
+          path: String,
+          http_adapter: T.nilable(Rager::Http::Adapters::Abstract)
+        ).returns(T.nilable(String))
+      }
       def self.download_prediction_to_file(prediction_url, key = nil, path:, http_adapter: nil)
         download_url = get_download_url(prediction_url, key, http_adapter: http_adapter)
         return nil if download_url.nil?
 
-        Rager::Utils::Http.download_file(download_url, path)
-      rescue
-        nil
+        Rager::Utils::Http.download_to_file(download_url, path)
       end
 
       sig { params(prediction_url: String, key: T.nilable(String), http_adapter: T.nilable(Rager::Http::Adapters::Abstract)).returns(T.nilable(String)) }
       def self.get_download_url(prediction_url, key = nil, http_adapter: nil)
         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?
 
         adapter = http_adapter || Rager.config.http_adapter
         response = adapter.make_request(
@@ -42,14 +52,14 @@ module Rager
           )
         )
 
-        raise Rager::Errors::HttpError.new(adapter, response.status, T.cast(response.body, T.nilable(String))) unless response.success?
+        raise Rager::Errors::HttpError.new(adapter, prediction_url, response.status, body: response.body&.to_s) unless response.success?
 
         data = JSON.parse(T.cast(T.must(response.body), String))
         return nil if ["starting", "processing"].include?(data["status"])
 
         if data["status"] == "failed"
           error_msg = data["error"] || "Prediction failed"
-          raise Rager::Errors::HttpError.new(adapter, 422, "Prediction failed: #{error_msg}")
+          raise Rager::Errors::HttpError.new(adapter, prediction_url, 422, body: error_msg)
         end
 
         return nil unless data["status"] == "succeeded"
@@ -70,14 +80,19 @@ module Rager
         return nil if download_url.nil? || download_url.empty?
         download_url
       rescue JSON::ParserError => e
-        raise Rager::Errors::ParseError.new("Failed to parse prediction response", e.message)
-      rescue Rager::Errors::HttpError, Rager::Errors::ParseError, Rager::Errors::MissingCredentialsError
-        raise
-      rescue
-        nil
+        raise Rager::Errors::ParseError.new("Failed to parse prediction response", details: e.message)
       end
 
-      sig { params(prediction_url: String, key: T.nilable(String), path: T.nilable(String), max_attempts: Integer, sleep_interval: Integer, http_adapter: T.nilable(Rager::Http::Adapters::Abstract)).returns(T.nilable(String)) }
+      sig {
+        params(
+          prediction_url: String,
+          key: T.nilable(String),
+          path: T.nilable(String),
+          max_attempts: Integer,
+          sleep_interval: Integer,
+          http_adapter: T.nilable(Rager::Http::Adapters::Abstract)
+        ).returns(T.nilable(String))
+      }
       def self.poll_prediction(prediction_url, key: nil, path: nil, max_attempts: 30, sleep_interval: 10, http_adapter: nil)
         max_attempts.times do
           result = if path
@@ -86,11 +101,15 @@ module Rager
             download_prediction(prediction_url, key, http_adapter: http_adapter)
           end
           return result unless result.nil?
-          sleep(sleep_interval)
+          Rager::Utils::Runtime.sleep(sleep_interval)
         end
 
-        adapter = http_adapter || Rager.config.http_adapter
-        raise Rager::Errors::HttpError.new(adapter, 408, "Prediction polling timed out after #{max_attempts} attempts")
+        raise Rager::Errors::TimeoutError.new(
+          "Replicate prediction polling",
+          timeout_seconds: max_attempts * sleep_interval,
+          attempts: max_attempts,
+          details: "Prediction at #{prediction_url} did not complete within #{max_attempts} attempts"
+        )
       end
     end
   end

data/lib/rager/utils/runtime.rb

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Utils
+    module Runtime
+      extend T::Sig
+
+      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
+      end
+    end
+  end
+end

data/lib/rager/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Rager
-  VERSION = "0.5.0"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rager
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - mvkvc
@@ -23,20 +23,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.14'
-- !ruby/object:Gem::Dependency
-  name: ostruct
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.6.2
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.6.2
 - !ruby/object:Gem::Dependency
   name: sorbet-runtime
   requirement: !ruby/object:Gem::Requirement
@@ -74,7 +60,6 @@ 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
@@ -87,55 +72,56 @@ files:
 - lib/rager/chat/schema.rb
 - lib/rager/config.rb
 - lib/rager/context.rb
-- lib/rager/embed.rb
+- lib/rager/context_options.rb
 - lib/rager/embed/options.rb
 - lib/rager/embed/providers/abstract.rb
 - lib/rager/embed/providers/openai.rb
 - lib/rager/error.rb
+- lib/rager/errors/credentials_error.rb
+- lib/rager/errors/dependency_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/template_error.rb
-- lib/rager/errors/unknown_provider_error.rb
+- lib/rager/errors/timeout_error.rb
 - lib/rager/http/adapters/abstract.rb
 - lib/rager/http/adapters/async_http.rb
 - lib/rager/http/adapters/mock.rb
+- lib/rager/http/adapters/net_http.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/output_format.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/image/options.rb
+- lib/rager/image/output_format.rb
+- lib/rager/image/providers/abstract.rb
+- lib/rager/image/providers/replicate.rb
+- lib/rager/log_strategy.rb
+- lib/rager/mesh/options.rb
+- lib/rager/mesh/providers/abstract.rb
+- lib/rager/mesh/providers/replicate.rb
 - lib/rager/operation.rb
 - lib/rager/options.rb
-- lib/rager/rerank.rb
+- lib/rager/outcome.rb
+- lib/rager/providers.rb
+- lib/rager/rerank/input.rb
 - lib/rager/rerank/options.rb
 - lib/rager/rerank/providers/abstract.rb
 - lib/rager/rerank/providers/cohere.rb
-- lib/rager/rerank/query.rb
 - lib/rager/rerank/result.rb
 - lib/rager/result.rb
-- lib/rager/search.rb
 - lib/rager/search/options.rb
 - lib/rager/search/providers/abstract.rb
-- lib/rager/search/providers/brave.rb
+- lib/rager/search/providers/jina.rb
 - lib/rager/search/result.rb
-- lib/rager/template.rb
 - lib/rager/template/input.rb
 - lib/rager/template/options.rb
 - lib/rager/template/providers/abstract.rb
 - lib/rager/template/providers/erb.rb
+- lib/rager/template/providers/mustache.rb
 - lib/rager/types.rb
 - lib/rager/utils/http.rb
 - lib/rager/utils/replicate.rb
+- lib/rager/utils/runtime.rb
 - lib/rager/version.rb
 homepage: https://github.com/mvkvc/rager_rb
 licenses:
@@ -155,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 3.6.9
 specification_version: 4
-summary: Build continuously improving AI applications.
+summary: Build continuously improving generative workflows.
 test_files: []