rager 0.5.0 → 0.7.0

data/lib/rager/context.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "securerandom"
+
 require "sorbet-runtime"
 
 module Rager
@@ -14,128 +15,297 @@ module Rager
     sig { returns(T.nilable(String)) }
     attr_reader :name
 
-    sig { params(id: T.nilable(String), name: T.nilable(String)).void }
-    def initialize(id: nil, name: nil)
+    sig { returns(T::Array[String]) }
+    attr_reader :tags
+
+    sig { returns(Integer) }
+    attr_reader :max_retries
+
+    sig { returns(Numeric) }
+    attr_reader :backoff
+
+    sig {
+      params(
+        id: T.nilable(String),
+        name: T.nilable(String),
+        tags: T::Array[String],
+        max_retries: T.nilable(Integer),
+        backoff: T.nilable(Numeric)
+      ).void
+    }
+    def initialize(id: nil, name: nil, tags: [], max_retries: nil, backoff: nil)
       @id = T.let(id || SecureRandom.uuid, String)
       @name = T.let(name, T.nilable(String))
+      @tags = T.let(tags, T::Array[String])
+      @max_retries = T.let(max_retries || 0, Integer)
+      @backoff = T.let(backoff || 1.0, Numeric)
+    end
+
+    sig do
+      params(
+        max_retries: T.nilable(Integer),
+        backoff: T.nilable(Numeric)
+      ).returns(Rager::Context)
+    end
+    def with_options(max_retries: nil, backoff: nil)
+      Context.new(
+        id: @id,
+        name: @name,
+        tags: @tags,
+        max_retries: max_retries || @max_retries,
+        backoff: backoff || @backoff
+      )
     end
 
     sig do
       params(
-        messages: T.any(String, Rager::Types::ChatInput),
+        messages: T.any(String, Rager::Types::ChatInput, Rager::Result),
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
     def chat(messages, **kwargs)
-      if messages.is_a?(String)
-        messages = [
+      context_options = Rager::ContextOptions.new(**Rager::ContextOptions.extract_kwargs(kwargs))
+      options = Rager::Chat::Options.new(**kwargs)
+      options.validate
+
+      normalized_input, input_ids = normalize(messages, context_options.input_ids)
+
+      if normalized_input.is_a?(String)
+        normalized_input = [
           Rager::Chat::Message.new(
             role: Rager::Chat::MessageRole::User,
-            content: messages
+            content: normalized_input
           )
         ]
       end
 
       execute(
-        Rager::Operation::Chat,
-        Rager::Chat::Options,
-        kwargs,
-        messages
-      ) { |options| Chat.chat(messages, options) }
+        operation: Rager::Operation::Chat,
+        input: normalized_input,
+        options: options,
+        context_options: context_options,
+        input_ids: input_ids
+      ) do |input, opts|
+        Rager::Providers
+          .get_provider(Rager::Operation::Chat, opts.provider, opts)
+          .chat(input, opts)
+      end
     end
 
     sig do
       params(
-        text: T.any(String, Rager::Types::EmbedInput),
+        text: T.any(String, Rager::Types::EmbedInput, Rager::Result),
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
     def embed(text, **kwargs)
-      if text.is_a?(String)
-        text = [text]
-      end
+      context_options = Rager::ContextOptions.new(**Rager::ContextOptions.extract_kwargs(kwargs))
+      options = Rager::Embed::Options.new(**kwargs)
+      options.validate
+
+      normalized_input, input_ids = normalize(text, context_options.input_ids)
+
+      normalized_input = [normalized_input] if normalized_input.is_a?(String)
 
       execute(
-        Rager::Operation::Embed,
-        Rager::Embed::Options,
-        kwargs,
-        text
-      ) { |options| Embed.embed(text, options) }
+        operation: Rager::Operation::Embed,
+        input: normalized_input,
+        options: options,
+        context_options: context_options,
+        input_ids: input_ids
+      ) do |input, opts|
+        Rager::Providers
+          .get_provider(Rager::Operation::Embed, opts.provider, opts)
+          .embed(input, opts)
+      end
     end
 
     sig do
       params(
-        prompt: Rager::Types::ImageGenInput,
+        prompt: T.any(Rager::Types::ImageInput, Rager::Result),
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
-    def image_gen(prompt, **kwargs)
+    def image(prompt, **kwargs)
+      context_options = Rager::ContextOptions.new(**Rager::ContextOptions.extract_kwargs(kwargs))
+      options = Rager::Image::Options.new(**kwargs)
+      options.validate
+
+      normalized_input, input_ids = normalize(prompt, context_options.input_ids)
+
       execute(
-        Rager::Operation::ImageGen,
-        Rager::ImageGen::Options,
-        kwargs,
-        prompt
-      ) { |options| ImageGen.image_gen(prompt, options) }
+        operation: Rager::Operation::Image,
+        input: normalized_input,
+        options: options,
+        context_options: context_options,
+        input_ids: input_ids
+      ) do |input, opts|
+        Rager::Providers
+          .get_provider(Rager::Operation::Image, opts.provider, opts)
+          .image(input, opts)
+      end
     end
 
     sig do
       params(
-        prompt: Rager::Types::MeshGenInput,
+        prompt: T.any(Rager::Types::MeshInput, Rager::Result),
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
-    def mesh_gen(prompt, **kwargs)
+    def mesh(prompt, **kwargs)
+      context_options = Rager::ContextOptions.new(**Rager::ContextOptions.extract_kwargs(kwargs))
+      options = Rager::Mesh::Options.new(**kwargs)
+      options.validate
+
+      normalized_input, input_ids = normalize(prompt, context_options.input_ids)
+
       execute(
-        Rager::Operation::MeshGen,
-        Rager::MeshGen::Options,
-        kwargs,
-        prompt
-      ) { |options| MeshGen.mesh_gen(prompt, options) }
+        operation: Rager::Operation::Mesh,
+        input: normalized_input,
+        options: options,
+        context_options: context_options,
+        input_ids: input_ids
+      ) do |input, opts|
+        Rager::Providers
+          .get_provider(Rager::Operation::Mesh, opts.provider, opts)
+          .mesh(input, opts)
+      end
     end
 
     sig do
       params(
-        query: Rager::Types::RerankInput,
+        query: T.any(String, Rager::Result),
+        documents: T.any(T::Array[String], Rager::Result),
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
-    def rerank(query, **kwargs)
+    def rerank(query, documents, **kwargs)
+      context_options = Rager::ContextOptions.new(**Rager::ContextOptions.extract_kwargs(kwargs))
+      options = Rager::Rerank::Options.new(**kwargs)
+      options.validate
+
+      normalized_query, input_ids = normalize(query, context_options.input_ids)
+      normalized_documents, input_ids = normalize(documents, input_ids)
+
+      rerank_input = Rager::Rerank::Input.new(
+        query: normalized_query,
+        documents: normalized_documents
+      )
+
       execute(
-        Rager::Operation::Rerank,
-        Rager::Rerank::Options,
-        kwargs,
-        query
-      ) { |options| Rager::Rerank.rerank(query, options) }
+        operation: Rager::Operation::Rerank,
+        input: rerank_input,
+        options: options,
+        context_options: context_options,
+        input_ids: input_ids
+      ) do |input, opts|
+        Rager::Providers
+          .get_provider(Rager::Operation::Rerank, opts.provider, opts)
+          .rerank(input, opts)
+      end
     end
 
     sig do
       params(
-        query: Rager::Types::SearchInput,
+        query: T.any(Rager::Types::SearchInput, Rager::Result),
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
     def search(query, **kwargs)
+      context_options = Rager::ContextOptions.new(**Rager::ContextOptions.extract_kwargs(kwargs))
+      options = Rager::Search::Options.new(**kwargs)
+      options.validate
+
+      normalized_input, input_ids = normalize(query, context_options.input_ids)
+
       execute(
-        Rager::Operation::Search,
-        Rager::Search::Options,
-        kwargs,
-        query
-      ) { |options| Search.search(query, options) }
+        operation: Rager::Operation::Search,
+        input: normalized_input,
+        options: options,
+        context_options: context_options,
+        input_ids: input_ids
+      ) do |input, opts|
+        Rager::Providers
+          .get_provider(Rager::Operation::Search, opts.provider, opts)
+          .search(input, opts)
+      end
     end
 
     sig do
       params(
-        input: Rager::Types::TemplateInput,
+        template: T.any(String, Rager::Result),
+        variables: T.any(T::Hash[Symbol, T.untyped], Rager::Result),
         kwargs: T.untyped
       ).returns(Rager::Result)
     end
-    def template(input, **kwargs)
+    def template(template, variables, **kwargs)
+      context_options = Rager::ContextOptions.new(**Rager::ContextOptions.extract_kwargs(kwargs))
+      options = Rager::Template::Options.new(**kwargs)
+      options.validate
+
+      normalized_template, input_ids = normalize(template, context_options.input_ids)
+      normalized_variables, input_ids = normalize(variables, input_ids)
+
+      template_input = Rager::Template::Input.new(
+        template: normalized_template,
+        variables: normalized_variables
+      )
+
       execute(
-        Rager::Operation::Template,
-        Rager::Template::Options,
-        kwargs,
-        input
-      ) { |options| Template.template(input, options) }
+        operation: Rager::Operation::Template,
+        input: template_input,
+        options: options,
+        context_options: context_options,
+        input_ids: input_ids
+      ) do |input, opts|
+        Rager::Providers
+          .get_provider(Rager::Operation::Template, opts.provider, opts)
+          .template(input, opts)
+      end
+    end
+
+    sig do
+      params(
+        value: Float,
+        feedback: T.nilable(String),
+        tags: T::Array[String]
+      ).void
+    end
+    def outcome(value, feedback: nil, tags: [])
+      Rager::Utils::Http.log_remote(
+        "outcomes",
+        {
+          version: "1",
+          data: Rager::Outcome.new(
+            context_id: @id,
+            value: value,
+            feedback: feedback,
+            tags: tags
+          )
+        }.to_json
+      )
+    end
+
+    sig { returns(T::Hash[Symbol, T.untyped]) }
+    def to_h
+      {
+        id: @id,
+        name: @name,
+        tags: @tags,
+        max_retries: @max_retries,
+        backoff: @backoff
+      }
+    end
+
+    sig { params(hash: T::Hash[Symbol, T.untyped], max_retries: T.nilable(Integer), backoff: T.nilable(Float)).returns(Rager::Context) }
+    def self.from_h(hash, max_retries: nil, backoff: nil)
+      new(
+        id: hash[:id],
+        name: hash[:name],
+        tags: hash[:tags],
+        max_retries: max_retries || hash[:max_retries],
+        backoff: backoff || hash[:backoff]
+      )
     end
 
     private
@@ -143,55 +313,114 @@ module Rager
     sig do
       params(
         operation: Rager::Operation,
-        options_struct: T::Class[Rager::Options],
-        kwargs: T.untyped,
         input: Rager::Types::Input,
-        block: T.proc.params(options: T.untyped).returns(T.untyped)
+        options: Rager::Types::Options,
+        context_options: Rager::ContextOptions,
+        input_ids: T::Array[String],
+        block: T.proc.params(
+          input: Rager::Types::Input,
+          options: Rager::Types::Options
+        ).returns(Rager::Types::Output)
       ).returns(Rager::Result)
     end
-    def execute(operation, options_struct, kwargs, input, &block)
-      name = kwargs.delete(:name)
-      iids = kwargs.delete(:iids)
-
-      options = options_struct.new(**kwargs)
-      options.validate
-
+    def execute(operation:, input:, options:, context_options:, input_ids:, &block)
       start_time = Time.now
+      attempt = 0
+      errors = []
+      last_error = nil
 
       begin
-        output = yield(options)
-
-        Result.new(
-          id: SecureRandom.uuid,
-          context_id: @id,
-          operation: operation,
-          input: input,
-          output: output,
-          options: options,
-          start_time: start_time.to_i,
-          end_time: Time.now.to_i,
-          name: name,
-          context_name: @name,
-          iids: iids,
-          error: nil
-        ).tap(&:log)
-      rescue => e
-        Result.new(
-          id: SecureRandom.uuid,
-          context_id: @id,
-          operation: operation,
-          input: input,
-          output: nil,
-          options: options,
-          start_time: start_time.to_i,
-          end_time: Time.now.to_i,
-          name: name,
-          context_name: @name,
-          iids: iids,
-          error: e.message
-        ).tap(&:log)
-
-        raise e
+        output = yield(input, options)
+      rescue Rager::Errors::HttpError => e
+        errors << e.message
+        last_error = e
+        attempt += 1
+
+        if attempt <= @max_retries
+          jitter = @backoff * rand(0.0..1.0)
+          delay = @backoff * (2**(attempt - 1)) + jitter
+          Rager.config.logger.warn("Retrying in #{delay.round(2)}s after failure #{attempt}/#{@max_retries}: #{e.message}")
+
+          Rager::Utils::Runtime.sleep(delay)
+
+          retry
+        else
+          output = nil
+        end
+      end
+
+      result = Result.new(
+        id: SecureRandom.uuid,
+        context_id: @id,
+        operation: operation,
+        input: input,
+        output: output,
+        options: options,
+        start_time: start_time.to_i,
+        end_time: Time.now.to_i,
+        attempt: attempt,
+        errors: errors,
+        input_ids: input_ids.uniq,
+        name: context_options.name,
+        tags: context_options.tags,
+        context_name: @name,
+        context_tags: @tags
+      ).tap(&:log)
+
+      raise last_error if last_error
+
+      result
+    end
+
+    sig {
+      params(
+        input: T.untyped,
+        ids: T.nilable(T::Array[String])
+      ).returns([T.untyped, T::Array[String]])
+    }
+    def normalize(input, ids = nil)
+      collected_ids = (ids || []).to_set
+      visited = Set.new
+
+      normalized_input = normalize_item(input, collected_ids, visited)
+      [normalized_input, collected_ids.to_a]
+    end
+
+    sig {
+      params(
+        item: T.untyped,
+        collected_ids: T::Set[String],
+        visited: T::Set[Integer]
+      ).returns(T.untyped)
+    }
+    def normalize_item(item, collected_ids, visited)
+      case item
+      when Rager::Result
+        collected_ids.add(item.id)
+        normalize_item(item.value, collected_ids, visited)
+      when Array
+        object_id = item.object_id
+        return item if visited.include?(object_id)
+        visited.add(object_id)
+
+        item.map { |i| normalize_item(i, collected_ids, visited) }
+      when Hash
+        object_id = item.object_id
+        return item if visited.include?(object_id)
+        visited.add(object_id)
+
+        item.transform_values { |value| normalize_item(value, collected_ids, visited) }
+      when T::Struct
+        object_id = item.object_id
+        return item if visited.include?(object_id)
+        visited.add(object_id)
+
+        transformed_props = item.class.props.each_key.each_with_object({}) do |prop_name, acc|
+          acc[prop_name] = normalize_item(item.send(prop_name), collected_ids, visited)
+        end
+        item.class.new(transformed_props)
+      else
+        item
       end
     end
   end

data/lib/rager/context_options.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  class ContextOptions < T::Struct
+    extend T::Sig
+
+    const :input_ids, T::Array[String], default: []
+    const :tags, T::Array[T.untyped], default: []
+    const :name, T.nilable(String)
+
+    sig { params(kwargs: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+    def self.extract_kwargs(kwargs)
+      {
+        input_ids: kwargs.delete(:input_ids),
+        tags: kwargs.delete(:tags),
+        name: kwargs.delete(:name)
+      }.compact
+    end
+  end
+end

data/lib/rager/embed/options.rb

@@ -9,11 +9,12 @@ module Rager
       extend T::Sig
       include Rager::Options
 
-      const :provider, String, default: "openai"
-      const :url, T.nilable(String)
+      const :provider, Symbol, default: :openai
       const :model, T.nilable(String)
-      const :api_key, T.nilable(String)
       const :seed, 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/embed/providers/openai.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require "json"
+
 require "sorbet-runtime"
 
 module Rager
@@ -18,10 +19,16 @@ module Rager
         end
         def embed(text, options)
           api_key = options.api_key || ENV["OPENAI_API_KEY"]
-          raise Rager::Errors::MissingCredentialsError.new("OpenAI", "OPENAI_API_KEY") if api_key.nil?
+          raise Rager::Errors::CredentialsError.new("OpenAI", env_var: ["OPENAI_API_KEY"]) if api_key.nil?
+
+          base_url = options.url || ENV["OPENAI_URL"] || "https://api.openai.com/v1"
+          url = "#{base_url}/embeddings"
 
-          headers = {"Content-Type" => "application/json"}
-          headers["Authorization"] = "Bearer #{api_key}" if api_key
+          headers = {
+            "Content-Type" => "application/json"
+          }.tap do |h|
+            h["Authorization"] = "Bearer #{api_key}" if api_key
+          end
 
           body = {
             model: options.model || "text-embedding-3-large",
@@ -30,15 +37,16 @@ module Rager
 
           request = Rager::Http::Request.new(
             verb: Rager::Http::Verb::Post,
-            url: options.url || ENV["OPENAI_URL"] || "https://api.openai.com/v1/embeddings",
+            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)
           parsed_response["data"].map { |item| item["embedding"] }

data/lib/rager/errors/credentials_error.rb

@@ -0,0 +1,24 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Errors
+    class CredentialsError < Rager::Error
+      extend T::Sig
+
+      sig { params(provider: String, env_var: T::Array[String], details: T.nilable(String)).void }
+      def initialize(provider, env_var: [], details: nil)
+        error_data = {
+          type: "credentials",
+          provider: provider,
+          env_var: env_var,
+          details: details
+        }
+
+        super(error_data.to_json)
+      end
+    end
+  end
+end

data/lib/rager/errors/dependency_error.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Rager
+  module Errors
+    class DependencyError < Rager::Error
+      extend T::Sig
+
+      sig { params(dependency: String, details: T.nilable(String)).void }
+      def initialize(dependency, details: nil)
+        error_data = {
+          type: "dependency",
+          dependency: dependency,
+          details: details
+        }
+
+        super(error_data.to_json)
+      end
+    end
+  end
+end

data/lib/rager/errors/http_error.rb

@@ -8,11 +8,18 @@ module Rager
     class HttpError < Rager::Error
       extend T::Sig
 
-      sig { params(adapter: Rager::Http::Adapters::Abstract, status: Integer, body: T.nilable(String)).void }
-      def initialize(adapter, status, body)
-        message = "HTTP Error #{status} using #{adapter.class.name}"
-        message += ": #{body}" if body
-        super(message)
+      sig { params(adapter: Rager::Http::Adapters::Abstract, url: T.nilable(String), status: Integer, body: T.nilable(String), details: T.nilable(String)).void }
+      def initialize(adapter, url, status, body: nil, details: nil)
+        error_data = {
+          type: "http",
+          adapter: adapter.class.name,
+          url: url,
+          status: status,
+          body: body,
+          details: details
+        }
+
+        super(error_data.to_json)
       end
     end
   end