ox-ai-workers 0.5.8 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 722b00ed63bf9ef2340a61bb1465192a50377ad0a572f1b2765037132c5de18f
-  data.tar.gz: afb338f8edc2e2621a8f559bc50f9b5f8c29f3f25e9fe5b8bcac95eae95fe988
+  metadata.gz: 811df931f990a04c2764d1e5dc952e69e1dfc409bfe942ff87822ef8b755a6c9
+  data.tar.gz: 1d591cc02bec476f76707de96acadd58bb0cda60a1af0bf6657150e9360e02e0
 SHA512:
-  metadata.gz: d02f038e7e84323debec83b19323a5a91d34b7f4145e709cdb9462ecdfa471aad224bb5c9b489d7803fff94a14bf10eb17d29e9c0862cba6785c5a1a46e006a2
-  data.tar.gz: a34bee96ff8cd78a93c1a2da63150dd48a266945a3b9ea891840a3354d6e104aae37c3a659d7327709f544975249b24e377b5f23137600f5f0eb242d27c6d865
+  metadata.gz: e4629630ea656bb07ab2da027852ebc262901e7dfb09d27b73071727eed149c850a3b4f40c03e094792c630f32642f9dc2c8c5a6786b5283e4a03916b8c47f8b
+  data.tar.gz: c57849c113e05f41fad7a51ab17b86878a27b61b4f7abff08dbac478114efe2ba697fce94ebfff23551931e982d07ae7e2d808d54adb3f28424bc29381b574d7

data/.ruby-version

@@ -0,0 +1 @@
+3.3.4

data/CHANGELOG.md

@@ -1,4 +1,11 @@
-## [Unreleased]
+## [0.6.2] - 2024-08-024
+
+- Rails ActiveRecord support
+
+## [0.6.0] - 2024-08-02
+
+- Added rails compatibility
+- Added `wait_for_complete` option
 
 ## [0.5.8] - 2024-08-02
 

data/README.md

@@ -86,9 +86,10 @@ For a more robust setup, you can configure the gem with your API keys, for examp
 OxAiWorkers.configure do |config|
     config.access_token = ENV.fetch("OPENAI")
     config.model = "gpt-4o"
-    config.max_tokens = 4096 # Default
-    config.temperature = 0.7 # Default
+    config.max_tokens = 4096   # Default
+    config.temperature = 0.7   # Default
     config.auto_execute = true # Default
+    config.wait_for_complete = true # Default
 end
 ```
 
@@ -178,6 +179,53 @@ As a worker, you can use different classes depending on your needs:
 
 - `OxAiWorkers::DelayedRequest`: This class is used for batch API requests, ideal for operations that do not require immediate execution. Using `DelayedRequest` can save up to 50% on costs as requests are executed when the remote server is less busy, but no later than within 24 hours.
 
+### Rails Projects with DelayedRequest
+
+Generate your model to store the `batch_id` in the database:
+
+```bash
+rails generate model MyRequestWithStore batch_id:string
+```
+
+In your `app/models/my_request_with_store.rb` file, add the following code:
+
+```ruby
+class MyRequestWithStore < ApplicationRecord
+  def delayed_request
+    @worker ||= OxAiWorkers::DelayedRequest.new(batch_id: self.batch_id)
+  end
+end
+```
+
+Then you can use the iterator like this:
+
+```ruby
+# Fetch the first stored batch
+my_store = MyRequestWithStore.first
+
+# Get the worker
+my_worker = my_store.delayed_request
+
+# Create the iterator
+iterator = OxAiWorkers::Iterator.new(worker: my_worker)
+# ... use the iterator
+
+# Destroy the store after completion
+my_store.destroy if my_worker.completed?
+```
+
+To store your batches in the database, use the following code:
+
+```ruby
+# Get the worker from the iterator
+my_worker = iterator.worker
+
+# Store the batch_id if it's not completed
+unless my_worker.completed?
+  my_store = MyRequestWithStore.create!(batch_id: my_worker.batch_id)
+end
+```
+
 ## Command Line Interface (CLI)
 
 1. Navigate to the required directory.

data/lib/ox-ai-workers.rb

@@ -31,6 +31,8 @@ require_relative 'oxaiworkers/assistant/sysop'
 require_relative 'oxaiworkers/assistant/coder'
 require_relative 'oxaiworkers/assistant/localizer'
 
+require_relative 'oxaiworkers/engine' if defined?(Rails)
+
 module OxAiWorkers
   DEFAULT_MODEL = 'gpt-4o-mini'
   DEFAULT_MAX_TOKEN = 4096
@@ -40,7 +42,7 @@ module OxAiWorkers
   class ConfigurationError < Error; end
 
   class Configuration
-    attr_accessor :model, :max_tokens, :temperature, :access_token, :auto_execute
+    attr_accessor :model, :max_tokens, :temperature, :access_token, :auto_execute, :wait_for_complete
 
     def initialize
       @access_token = nil
@@ -48,6 +50,7 @@ module OxAiWorkers
       @max_tokens = DEFAULT_MAX_TOKEN
       @temperature = DEFAULT_TEMPERATURE
       @auto_execute = true
+      @wait_for_complete = true
 
       [Array, NilClass, String, Symbol, Hash].each do |c|
         c.send(:include, OxAiWorkers::PresentCompat) unless c.method_defined?(:present?)

data/lib/oxaiworkers/delayed_request.rb

@@ -3,7 +3,7 @@
 module OxAiWorkers
   class DelayedRequest < OxAiWorkers::StateBatch
     def initialize(batch_id: nil, model: nil, max_tokens: nil, temperature: nil)
-      initialize_requests(model: model, max_tokens: max_tokens, temperature: temperature)
+      initialize_requests(model:, max_tokens:, temperature:)
       @custom_id = nil if batch_id.present?
       @batch_id = batch_id
       @file_id = nil

data/lib/oxaiworkers/engine.rb

@@ -0,0 +1,11 @@
+module OxAiWorkers
+  class Engine < ::Rails::Engine
+    isolate_namespace OxAiWorkers # this is generally recommended
+
+    # no other special configuration needed. But maybe you want
+    # an initializer to be added to the app? Easy!
+    # initializer 'yourgem.boot_stuff_up' do
+    #   OxAiWorkers.boot_something_up!
+    # end
+  end
+end

data/lib/oxaiworkers/iterator.rb

@@ -52,8 +52,15 @@ module OxAiWorkers
       cleanup
 
       super()
+
+      tick_or_wait if requested?
     end
 
+    #
+    # Resets the state of the object by setting all instance variables to their initial values.
+    #
+    # Returns nothing.
+    #
     def cleanup
       @result = nil
       @queue = []
@@ -63,6 +70,11 @@ module OxAiWorkers
       complete_iteration
     end
 
+    # Updates the internal state of the iterator by adding the given `speach` to the `@queue` and calling the `@on_inner_monologue` callback with the `speach` text.
+    #
+    # @param speach [String] The text to be added to the `@queue` and passed to the `@on_inner_monologue` callback.
+    #
+    # @return [nil] This method does not return a value.
     def inner_monologue(speach:)
       # @queue.pop
       @queue << { role: :assistant, content: speach.to_s }
@@ -74,7 +86,7 @@ module OxAiWorkers
       # @queue.pop
       @queue << { role: :assistant, content: text.to_s }
       complete! unless available_defs.include?(:action_request)
-      @on_outer_voice&.call(text: text)
+      @on_outer_voice&.call(text:)
       nil
     end
 
@@ -96,7 +108,7 @@ module OxAiWorkers
       @worker.finish
       rebuild_worker
       complete! if can_complete?
-      @on_summarize&.call(text: text)
+      @on_summarize&.call(text:)
       nil
     end
 
@@ -158,11 +170,28 @@ module OxAiWorkers
 
     def external_request
       @worker.request!
-      ticker
+      tick_or_wait
+    end
+
+    def tick_or_wait
+      if OxAiWorkers.configuration.wait_for_complete
+        wait_for_complete
+      else
+        ticker
+      end
     end
 
     def ticker
-      sleep(60) until @worker.completed?
+      return false unless @worker.completed?
+
+      analyze!
+      true
+    end
+
+    def wait_for_complete
+      return unless requested?
+
+      sleep(60) unless ticker
       analyze!
     end
 
@@ -199,7 +228,7 @@ module OxAiWorkers
     end
 
     def add_context(text, role: :system)
-      @context << { role: role, content: text }
+      @context << { role:, content: text }
     end
 
     def execute

data/lib/oxaiworkers/load_i18n.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require 'i18n'
-I18n.load_path += Dir["#{File.expand_path('../../locales', __dir__)}/*.yml"]
+unless defined?(Rails)
+  require 'i18n'
+  I18n.load_path += Dir["#{File.expand_path('../../config/locales', __dir__)}/*.yml"]
+end
 
 module OxAiWorkers
   module LoadI18n

data/lib/oxaiworkers/state_tools.rb

@@ -7,7 +7,7 @@ module OxAiWorkers
     include OxAiWorkers::StateHelper
     extend StateMachines::MacroMethods
 
-    state_machine :state, initial: :idle do
+    state_machine :state, initial: ->(t) { t.worker.requested? ? :requested : :idle } do
       before_transition from: any, do: :log_me
 
       after_transition on: :iterate, do: :next_iteration

data/lib/oxaiworkers/tool/converter.rb

@@ -0,0 +1,35 @@
+# def getDocument doc1, &block
+#   document = getFileBin(doc1)
+#   content = nil
+#   unless document.nil?
+#     extension = doc1['file_name'].split('.').last.downcase
+#     if extension == "docx"
+#       docx = Docx::Document.open document#.read
+#       content = docx.instance_variable_get("@doc").xpath('//w:document//w:body').children.map{ |c|
+#         if c.name == 'p' # paragraph
+#           paragraph = docx.send(:parse_paragraph_from, c)
+#           ReverseMarkdown.convert(paragraph.to_html).strip
+#         elsif c.name = 'tbl' # table
+#           table = docx.send(:parse_table_from, c)
+#           table.rows.map { |row| row.cells.map { |cell| cell.paragraphs.map(&:text).reject { |c| c.empty? }.join("\\n ") }.join(" | ") }.join("\n")
+#         else # other types?
+#           c.content
+#         end
+#       }.reject { |c| c.empty? }.join("\n\n")
+#       #content = ReverseMarkdown.convert(docx.to_html)
+#       makeTempFileWithContent(content, ["file_#{@current_user.id}", ".txt"]) do |file|
+#         yield(content, doc1['file_name'], file)
+#       end
+#     elsif %w[xlsx xls ods].include?(extension)
+#       xlsx = Roo::Spreadsheet.open document, extension: extension.to_sym
+#       content = xlsx.to_csv
+#       makeTempFileWithContent(content, ["file_#{@current_user.id}", ".csv"]) do |file|
+#         yield(content, doc1['file_name'], file)
+#       end
+#     elsif %w[csv txt ini asc log kicad_sch cpp h rb c hpp erb md yml].include?(extension)
+#       yield(document.read.force_encoding("UTF-8"), doc1['file_name'], nil)
+#     else
+#       yield(nil, doc1['file_name'], nil)
+#     end
+#   end
+# end

data/lib/oxaiworkers/tool_definition.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "json"
+require 'json'
 
 #
 # Extends a class to be used as a tool in the assistant.
@@ -36,201 +36,220 @@ require "json"
 #     end
 #   end
 #
-module OxAiWorkers::ToolDefinition
-  attr_accessor :white_list
+module OxAiWorkers
+  module ToolDefinition
+    attr_accessor :white_list
 
-  def init_white_list_with only
-    @white_list = only.is_a?(Array) ? only : [only]
-  end
-
-  # Defines a function for the tool
-  #
-  # @param method_name [Symbol] Name of the method to define
-  # @param description [String] Description of the function
-  # @yield Block that defines the parameters for the function
-  def define_function(method_name, description:, &)
-    if @white_list.nil? || @white_list == method_name || @white_list.include?(method_name)
-      function_schemas.add_function(method_name:, description:, &)
-    end
-  end
-
-  # Returns the FunctionSchemas instance for this tool
-  #
-  # @return [FunctionSchemas] The FunctionSchemas instance
-  def function_schemas
-    @function_schemas ||= FunctionSchemas.new(tool_name)
-  end
-
-  # Returns the snake_case version of the class name as the tool's name
-  #
-  # @return [String] The snake_case version of the class name
-  def tool_name
-    @tool_name ||= (self.respond_to?(:name) ? name : self.class.name)
-      .gsub("::", "_")
-      .gsub(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, "_")
-      .downcase
-  end
-
-  def full_function_name(fun)
-    function_schemas.function_name(fun)
-  end
-
-  # Manages schemas for functions
-  class FunctionSchemas
-    def initialize(tool_name)
-      @schemas = {}
-      @tool_name = tool_name
-    end
-
-    def function_name method_name
-      "#{@tool_name}__#{method_name}"
+    # Initializes the white list with the given `only` parameter.
+    #
+    # @param only [Object, Array] The object or array to initialize the white list with.
+    # @return [Array] The initialized white list.
+    def init_white_list_with(only)
+      @white_list = only.is_a?(Array) ? only : [only]
     end
 
-    # Adds a function to the schemas
+    # Defines a function for the tool
     #
-    # @param method_name [Symbol] Name of the method to add
+    # @param method_name [Symbol] Name of the method to define
     # @param description [String] Description of the function
     # @yield Block that defines the parameters for the function
-    # @raise [ArgumentError] If a block is defined and no parameters are specified for the function
-    def add_function(method_name:, description:, &)
-      name = function_name(method_name)
+    def define_function(method_name, description:, &)
+      return unless @white_list.nil? || @white_list == method_name || @white_list.include?(method_name)
 
-      if block_given?
-        parameters = ParameterBuilder.new(parent_type: "object").build(&)
+      function_schemas.add_function(method_name:, description:, &)
+    end
 
-        if parameters[:properties].empty?
-          raise ArgumentError, "Function parameters must have at least one property defined within it, if a block is provided"
-        end
-      end
+    # Returns the FunctionSchemas instance for this tool
+    #
+    # @return [FunctionSchemas] The FunctionSchemas instance
+    def function_schemas
+      @function_schemas ||= FunctionSchemas.new(tool_name)
+    end
 
-      @schemas[method_name] = {
-        type: "function",
-        function: {name:, description:, parameters:}.compact
-      }
+    # Returns the snake_case version of the class name as the tool's name
+    #
+    # @return [String] The snake_case version of the class name
+    def tool_name
+      @tool_name ||= (respond_to?(:name) ? name : self.class.name)
+                     .gsub('::', '_')
+                     .gsub(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, '_')
+                     .downcase
     end
 
-    # Converts schemas to OpenAI-compatible format
+    # Returns the full function name for the given function.
     #
-    # @return [String] JSON string of schemas in OpenAI format
-    def to_openai_format(only: nil)
-      valid_schemas(only: only).values
+    # @param fun [Symbol] The function name.
+    # @return [String] The full function name, which is the tool name concatenated with the function name.
+    def full_function_name(fun)
+      function_schemas.function_name(fun)
     end
 
-    def valid_schemas(only: nil)
-      if only.nil?
-        @schemas
-      else
-        @schemas.select { |name, schema| only.include?(name) }
+    # Manages schemas for functions
+    class FunctionSchemas
+      def initialize(tool_name)
+        @schemas = {}
+        @tool_name = tool_name
       end
-    end
 
-    # Converts schemas to Anthropic-compatible format
-    #
-    # @return [String] JSON string of schemas in Anthropic format
-    def to_anthropic_format(only: nil)
-      valid_schemas(only: only).values.map do |schema|
-        schema[:function].transform_keys("parameters" => "input_schema")
+      # Returns the full function name for the given method name.
+      #
+      # @param method_name [Symbol] The name of the method.
+      # @return [String] The full function name, which is the tool name concatenated with the method name.
+      def function_name(method_name)
+        "#{@tool_name}__#{method_name}"
       end
-    end
 
-    # Converts schemas to Google Gemini-compatible format
-    #
-    # @return [String] JSON string of schemas in Google Gemini format
-    def to_google_gemini_format(only: nil)
-      valid_schemas(only: only).values.map { |schema| schema[:function] }
-    end
-  end
+      # Adds a function to the schemas
+      #
+      # @param method_name [Symbol] Name of the method to add
+      # @param description [String] Description of the function
+      # @yield Block that defines the parameters for the function
+      # @raise [ArgumentError] If a block is defined and no parameters are specified for the function
+      def add_function(method_name:, description:, &)
+        name = function_name(method_name)
+
+        if block_given?
+          parameters = ParameterBuilder.new(parent_type: 'object').build(&)
+
+          if parameters[:properties].empty?
+            raise ArgumentError,
+                  'Function parameters must have at least one property defined within it, if a block is provided'
+          end
+        end
 
-  # Builds parameter schemas for functions
-  class ParameterBuilder
-    VALID_TYPES = %w[object array string number integer boolean].freeze
+        @schemas[method_name] = {
+          type: 'function',
+          function: { name:, description:, parameters: }.compact
+        }
+      end
 
-    def initialize(parent_type:)
-      @schema = (parent_type == "object") ? {type: "object", properties: {}, required: []} : {}
-      @parent_type = parent_type
-    end
+      # Converts schemas to OpenAI-compatible format
+      #
+      # @return [String] JSON string of schemas in OpenAI format
+      def to_openai_format(only: nil)
+        valid_schemas(only:).values
+      end
 
-    # Builds the parameter schema
-    #
-    # @yield Block that defines the properties of the schema
-    # @return [Hash] The built schema
-    def build(&)
-      instance_eval(&)
-      @schema
-    end
+      # Returns a subset of schemas based on the provided filter.
+      #
+      # @param only [Array<Symbol>] An optional array of schema names to filter by.
+      # @return [Hash<Symbol, Hash>] A hash of schemas with their corresponding names as keys.
+      def valid_schemas(only: nil)
+        if only.nil?
+          @schemas
+        else
+          @schemas.select { |name, _schema| only.include?(name) }
+        end
+      end
 
-    # Defines a property in the schema
-    #
-    # @param name [Symbol] Name of the property (required only for a parent of type object)
-    # @param type [String] Type of the property
-    # @param description [String] Description of the property
-    # @param enum [Array] Array of allowed values
-    # @param required [Boolean] Whether the property is required
-    # @yield [Block] Block for nested properties (only for object and array types)
-    # @raise [ArgumentError] If any parameter is invalid
-    def property(name = nil, type:, description: nil, enum: nil, required: false, &)
-      validate_parameters(name:, type:, enum:, required:)
-
-      prop = {type:, description:, enum:}.compact
-
-      if block_given?
-        nested_schema = ParameterBuilder.new(parent_type: type).build(&)
-
-        case type
-        when "object"
-          if nested_schema[:properties].empty?
-            raise ArgumentError, "Object properties must have at least one property defined within it"
-          end
-          prop = nested_schema
-        when "array"
-          if nested_schema.empty?
-            raise ArgumentError, "Array properties must have at least one item defined within it"
-          end
-          prop[:items] = nested_schema
+      # Converts schemas to Anthropic-compatible format
+      #
+      # @return [String] JSON string of schemas in Anthropic format
+      def to_anthropic_format(only: nil)
+        valid_schemas(only:).values.map do |schema|
+          schema[:function].transform_keys('parameters' => 'input_schema')
         end
       end
 
-      if @parent_type == "object"
-        @schema[:properties][name] = prop
-        @schema[:required] << name.to_s if required
-      else
-        @schema = prop
+      # Converts schemas to Google Gemini-compatible format
+      #
+      # @return [String] JSON string of schemas in Google Gemini format
+      def to_google_gemini_format(only: nil)
+        valid_schemas(only:).values.map { |schema| schema[:function] }
       end
     end
 
-    # Alias for property method, used for defining array items
-    alias_method :item, :property
+    # Builds parameter schemas for functions
+    class ParameterBuilder
+      VALID_TYPES = %w[object array string number integer boolean].freeze
 
-    private
+      def initialize(parent_type:)
+        @schema = parent_type == 'object' ? { type: 'object', properties: {}, required: [] } : {}
+        @parent_type = parent_type
+      end
 
-    # Validates the parameters for a property
-    #
-    # @param name [Symbol] Name of the property
-    # @param type [String] Type of the property
-    # @param enum [Array] Array of allowed values
-    # @param required [Boolean] Whether the property is required
-    # @raise [ArgumentError] If any parameter is invalid
-    def validate_parameters(name:, type:, enum:, required:)
-      if @parent_type == "object"
-        if name.nil?
-          raise ArgumentError, "Name must be provided for properties of an object"
+      # Builds the parameter schema
+      #
+      # @yield Block that defines the properties of the schema
+      # @return [Hash] The built schema
+      def build(&)
+        instance_eval(&)
+        @schema
+      end
+
+      # Defines a property in the schema
+      #
+      # @param name [Symbol] Name of the property (required only for a parent of type object)
+      # @param type [String] Type of the property
+      # @param description [String] Description of the property
+      # @param enum [Array] Array of allowed values
+      # @param required [Boolean] Whether the property is required
+      # @yield [Block] Block for nested properties (only for object and array types)
+      # @raise [ArgumentError] If any parameter is invalid
+      def property(name = nil, type:, description: nil, enum: nil, required: false, &)
+        validate_parameters(name:, type:, enum:, required:)
+
+        prop = { type:, description:, enum: }.compact
+
+        if block_given?
+          nested_schema = ParameterBuilder.new(parent_type: type).build(&)
+
+          case type
+          when 'object'
+            if nested_schema[:properties].empty?
+              raise ArgumentError, 'Object properties must have at least one property defined within it'
+            end
+
+            prop = nested_schema
+          when 'array'
+            if nested_schema.empty?
+              raise ArgumentError,
+                    'Array properties must have at least one item defined within it'
+            end
+
+            prop[:items] = nested_schema
+          end
         end
-        unless name.is_a?(Symbol)
-          raise ArgumentError, "Invalid name '#{name}'. Name must be a symbol"
+
+        if @parent_type == 'object'
+          @schema[:properties][name] = prop
+          @schema[:required] << name.to_s if required
+        else
+          @schema = prop
         end
       end
 
-      unless VALID_TYPES.include?(type)
-        raise ArgumentError, "Invalid type '#{type}'. Valid types are: #{VALID_TYPES.join(", ")}"
-      end
+      # Alias for property method, used for defining array items
+      alias item property
+
+      private
+
+      # Validates the parameters for a property
+      #
+      # @param name [Symbol] Name of the property
+      # @param type [String] Type of the property
+      # @param enum [Array] Array of allowed values
+      # @param required [Boolean] Whether the property is required
+      # @raise [ArgumentError] If any parameter is invalid
+      def validate_parameters(name:, type:, enum:, required:)
+        if @parent_type == 'object'
+          raise ArgumentError, 'Name must be provided for properties of an object' if name.nil?
+          raise ArgumentError, "Invalid name '#{name}'. Name must be a symbol" unless name.is_a?(Symbol)
+        end
 
-      unless enum.nil? || enum.is_a?(Array)
-        raise ArgumentError, "Invalid enum '#{enum}'. Enum must be nil or an array"
-      end
+        unless VALID_TYPES.include?(type)
+          raise ArgumentError, "Invalid type '#{type}'. Valid types are: #{VALID_TYPES.join(', ')}"
+        end
+
+        unless enum.nil? || enum.is_a?(Array)
+          raise ArgumentError,
+                "Invalid enum '#{enum}'. Enum must be nil or an array"
+        end
+
+        return if [true, false].include?(required)
 
-      unless [true, false].include?(required)
         raise ArgumentError, "Invalid required '#{required}'. Required must be a boolean"
       end
     end
   end
-end
+end

data/lib/oxaiworkers/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module OxAiWorkers
-  VERSION = '0.5.8'
+  VERSION = '0.6.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ox-ai-workers
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.6.2
 platform: ruby
 authors:
 - Denis Smolev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-05 00:00:00.000000000 Z
+date: 2024-08-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -124,11 +124,18 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".ruby-version"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - LICENSE
 - README.md
 - Rakefile
+- config/locales/en.oxaiworkers.assistant.yml
+- config/locales/en.oxaiworkers.iterator.yml
+- config/locales/en.oxaiworkers.tool.yml
+- config/locales/ru.oxaiworkers.assistant.yml
+- config/locales/ru.oxaiworkers.iterator.yml
+- config/locales/ru.oxaiworkers.tool.yml
 - exe/oxaiworkers
 - exe/start
 - lib/ox-ai-workers.rb
@@ -140,6 +147,7 @@ files:
 - lib/oxaiworkers/contextual_logger.rb
 - lib/oxaiworkers/delayed_request.rb
 - lib/oxaiworkers/dependency_helper.rb
+- lib/oxaiworkers/engine.rb
 - lib/oxaiworkers/iterator.rb
 - lib/oxaiworkers/load_i18n.rb
 - lib/oxaiworkers/module_request.rb
@@ -148,18 +156,13 @@ files:
 - lib/oxaiworkers/state_batch.rb
 - lib/oxaiworkers/state_helper.rb
 - lib/oxaiworkers/state_tools.rb
+- lib/oxaiworkers/tool/converter.rb
 - lib/oxaiworkers/tool/database.rb
 - lib/oxaiworkers/tool/eval.rb
 - lib/oxaiworkers/tool/file_system.rb
 - lib/oxaiworkers/tool_definition.rb
 - lib/oxaiworkers/version.rb
 - lib/ruby/ox-ai-workers.rb
-- locales/en.assistant.yml
-- locales/en.iterator.yml
-- locales/en.tool.yml
-- locales/ru.assistant.yml
-- locales/ru.iterator.yml
-- locales/ru.tool.yml
 - template/my_assistant.rb
 - template/start
 - template/tools/my_tool.rb