ox-ai-workers 0.5.7 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f97adfcdeeb14f6f57403788275ac90ade86abbd8e5ad6710b933efa1a51b694
-  data.tar.gz: a6bcefa3d9b9f99410d4c299334dbab6f8e8db1aff6d6fdde44b5f528fa371de
+  metadata.gz: 173694a4b29ea7a2c690add1cdbf322d62b005427c1310f5ea6dde2dea0a8c81
+  data.tar.gz: 1687d91cffe2ca48a50a4b5669ab3bcf2874a2e8b649d668a7ee6a3806e3eb8f
 SHA512:
-  metadata.gz: 2cf1ce163398cbd83f922e8cb8f48aa160bd2de5fab062c916804f4def0976a68a6cb7d8643be478b677b8303b7a4e77e17b5125c31533f0eec432f5ce519d07
-  data.tar.gz: 8eb1c9f7f3e7c020f48190bda26dfc3f37febe5df1d31283a5849bcc81bc8277a1c6de5971017d9b00a93e86eb42b54282919024ce93694476c29df1388a891d
+  metadata.gz: a162f9ef5c72938e502cd5c491a018643d75f833aad9a767388d222e440526b33d85aac263d9db4ab3448429ce97e16fba90bf1a70358c672ac4fe4c1b74b22d
+  data.tar.gz: 8c807fdaac63f3c75cfe770b966ac3e1f6e537a7a4942d253ee2385b449ce0c37205ecd98e07c68e8aa4a0b1a2b3dd86c53a2355d2378b3e6e6e21b0b9d83f8a

data/.ruby-version

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

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 ## [Unreleased]
 
+## [0.6.0] - 2024-08-02
+
+- Added rails compatibility
+- Added `wait_for_complete` option
+
+## [0.5.8] - 2024-08-02
+
+- Fixed gem `state_machines`
+
 ## [0.5.7] - 2024-08-02
 
 - Added monkey patch for `full_function_name`

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
 ```
 

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

@@ -54,6 +54,11 @@ module OxAiWorkers
       super()
     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 +68,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 +84,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 +106,7 @@ module OxAiWorkers
       @worker.finish
       rebuild_worker
       complete! if can_complete?
-      @on_summarize&.call(text: text)
+      @on_summarize&.call(text:)
       nil
     end
 
@@ -158,11 +168,24 @@ module OxAiWorkers
 
     def external_request
       @worker.request!
-      ticker
+      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 +222,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_batch.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'state_machine/core'
+require 'state_machines/core'
 
 module OxAiWorkers
   class StateBatch < OxAiWorkers::ModuleRequest
     include OxAiWorkers::StateHelper
-    extend StateMachine::MacroMethods
+    extend StateMachines::MacroMethods
 
     alias state_initialize initialize
     attr_accessor :file_id, :batch_id

data/lib/oxaiworkers/state_tools.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require 'state_machine/core'
+require 'state_machines/core'
 
 module OxAiWorkers
   class StateTools
     include OxAiWorkers::StateHelper
-    extend StateMachine::MacroMethods
+    extend StateMachines::MacroMethods
 
     state_machine :state, initial: :idle do
       before_transition from: any, do: :log_me

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.7'
+  VERSION = '0.6.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ox-ai-workers
 version: !ruby/object:Gem::Version
-  version: 0.5.7
+  version: 0.6.0
 platform: ruby
 authors:
 - Denis Smolev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-03 00:00:00.000000000 Z
+date: 2024-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -95,19 +95,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '7'
 - !ruby/object:Gem::Dependency
-  name: state_machine
+  name: state_machines
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1'
+        version: '0.6'
 description: |2
       OxAiWorkers (ox-ai-workers) is a cutting-edge Ruby gem designed to seamlessly integrate
       a sophisticated state machine with the powerful capabilities of generative intelligence
@@ -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
@@ -154,12 +162,6 @@ files:
 - 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
@@ -178,14 +180,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.17
 signing_key:
 specification_version: 4
 summary: A powerful state machine with OpenAI generative intelligence integration