ox-ai-workers 0.5.3.1 → 0.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34c154dd79d968e939b91f26e410e0f7a4e51c5099347b3577dc05708ab8b341
-  data.tar.gz: 294f14527bb5ef82e885ee5c93e6577d93c1820f844baad1139fbd385cb895c2
+  metadata.gz: ca54c1ff9c1f4360ddfe986c4b5bc6fb6b7c0cde0484d1b2f88bfe4d8c5707b7
+  data.tar.gz: 2c54e55fedd99af36f7a510ab923c54581faecfc8b36caa4d228f14349e293a8
 SHA512:
-  metadata.gz: 1f2c528093acd8ef4a6214ef65898807f72172f10e211096cbd490589d04e55220ff679c57cc04dd677ab04a211445fe4eb8cfefbc0beb1b453fcb7282dfabd0
-  data.tar.gz: 14f317606790d54f1c735f437145da15243a86af05c28bfcaf63464929c841df1b4de02cc6326b94571ddb0334a3bd13298ffe78078e39e1c24e7314d386fea7
+  metadata.gz: b8915a64826c118706328c89a87c01fdf49f13b63408c64d5af1ea53a2f92dbb326b9e537f36aa755297a5c919239d426da1f38a83b3cd5fdfbc5a9ebc4146f7
+  data.tar.gz: 8614ed16d7771b594bda52de36f87bbd211adfc8c579fff752634fc4ce44a7d554cd25cf7b32bfaa80954830f835a7b3c1f61d0e237c930bc043f433e98534c1

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.5.5] - 2024-08-02
+
+- Added `only` for Tools
+- Addded `locale` for `Iterator` and `Assistant`
+
+## [0.5.4] - 2024-08-01
+
+- def_except and def_only for `Iterator`
+- Renamed on_pack_history to on_summarize
+- Renamed all "pack_history" to "summarize"
+
 ## [0.5.3] - 2024-07-31
 
 - Fixed summarize state

data/README.md

@@ -1,7 +1,7 @@
-[![Gem Version](https://badge.fury.io/rb/ox-ai-workers.svg)](https://rubygems.org/gems/ox-ai-workers)
-
 # OxAiWorkers (ox-ai-workers)
 
+[![Gem Version](https://badge.fury.io/rb/ox-ai-workers.svg)](https://rubygems.org/gems/ox-ai-workers)
+
 OxAiWorkers is a Ruby gem that implements a finite state machine (using the `state_machine` gem) to solve tasks using generative intelligence (with the `ruby-openai` gem). This approach enhances the final result by utilizing internal monologue and external tools.
 
 ## Installation
@@ -63,7 +63,7 @@ worker = OxAiWorkers::Request.new(
     temperature: 0.7 )
 
 # Initialize a tool
-my_tool = OxAiWorkers::Tool::Eval.new()
+my_tool = OxAiWorkers::Tool::Eval.new(only: :sh)
 
 # Create an iterator with the worker and tool
 iterator = OxAiWorkers::Iterator.new(
@@ -86,9 +86,9 @@ 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
-    config.temperature = 0.7
-    config.auto_execute = true
+    config.max_tokens = 4096 # Default
+    config.temperature = 0.7 # Default
+    config.auto_execute = true # Default
 end
 ```
 
@@ -96,17 +96,26 @@ Then you can create an assistant like this:
 
 ```ruby
 assistant = OxAiWorkers::Assistant::Sysop.new()
-assistant.task = "your task"
+assistant.task = "Remove all cron jobs."
 
 # Provide a response to the assistant's question
 assistant.add_response("blah-blah-blah")
 ```
 
+Besides, you can create assistants with different locales
+
+```ruby
+I18n.with_locale(:en) { @sysop_en = OxAiWorkers::Assistant::Sysop.new() }
+
+# Assign tasks and responses in different languages
+@sysop_en.task = "Remove all cron jobs."
+```
+
 Or you can create a lower-level iterator for more control:
 
 ```ruby
 my_worker = OxAiWorkers::Request.new
-my_tool = OxAiWorkers::Tool::Eval.new
+my_tool = OxAiWorkers::Tool::Eval.new(only: [:sh])
 
 iterator = OxAiWorkers::Iterator.new(
     worker: my_worker, 
@@ -115,7 +124,7 @@ iterator = OxAiWorkers::Iterator.new(
     on_inner_monologue: ->(text:) { puts "monologue: #{text}".colorize(:yellow) },
     on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) },
     on_action_request: ->(text:) { puts "action: #{text}".colorize(:red) },
-    on_pack_history: ->(text:) { puts "summary: #{text}".colorize(:blue) }
+    on_summarize: ->(text:) { puts "summary: #{text}".colorize(:blue) }
   )
 
 iterator.add_task("Show files in current directory.")
@@ -130,20 +139,26 @@ This way, you have the flexibility to choose between a higher-level assistant fo
 ```ruby
 steps = []
 steps << 'Step 1. Develop your own solution to the problem, taking initiative and making assumptions.'
-steps << 'Step 2. Enclose all your developments from the previous step in the ox_ai_workers_iterator__inner_monologue function.'
+steps << "Step 2. Enclose all your developments from the previous step in the #{OxAiWorkers::Iterator.full_function_name(:inner_monologue)} function."
 steps << 'Step 3. Call the necessary functions one after another until the desired result is achieved.'
-steps << 'Step 4. When all intermediate steps are completed and the exact content of previous messages is no longer relevant, use the ox_ai_workers_iterator__pack_history function.'
+steps << "Step 4. When all intermediate steps are completed and the exact content of previous messages is no longer relevant, use the #{OxAiWorkers::Iterator.full_function_name(:summarize)} function."
 steps << "Step 5. When the solution is ready, notify about it and wait for the user's response."
 
+# To retain the locale if you have assistants in different languages in your project.
+store_locale # Optional
+
 @iterator = OxAiWorkers::Iterator.new(
   worker: init_worker(delayed: delayed, model: model),
   role: 'You are a software agent inside my computer',
   tools: [MyTool.new],
+  locale: @locale || I18n.locale,
   steps: steps,
+  # def_except: [:summarize], # It's except steps with that functions
+  # def_only: [:inner_monologue, :outer_voice], # Use it only with your steps
   on_inner_monologue: ->(text:) { puts "monologue: #{text}".colorize(:yellow) },
   on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) },
   on_action_request: ->(text:) { puts "action: #{text}".colorize(:red) },
-  on_pack_history: ->(text:) { puts "summary: #{text}".colorize(:blue) }
+  on_summarize: ->(text:) { puts "summary: #{text}".colorize(:blue) }
 )
 ```
 
@@ -165,7 +180,7 @@ As a worker, you can use different classes depending on your needs:
 oxaiworkers init
 ```
 
-This will create a `.oxaiworkers-local` directory with the necessary initial source code. 
+This will create a `.oxaiworkers-local` directory with the necessary initial source code.
 
 Additionally, you can initialize a more comprehensive example using the command:
 
@@ -199,7 +214,7 @@ OxAiWorkers.logger.level = :debug
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/neonix20b/ox-ai-workers. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/neonix20b/ox-ai-workers/blob/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at <https://github.com/neonix20b/ox-ai-workers>. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/neonix20b/ox-ai-workers/blob/main/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -207,4 +222,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the OxAiWorkers project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/neonix20b/ox-ai-workers/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in the OxAiWorkers project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/neonix20b/ox-ai-workers/blob/main/CODE_OF_CONDUCT.md).

data/exe/start

@@ -17,4 +17,8 @@ end
 
 @assistant = OxAiWorkers::Assistant::Sysop.new
 
+# Anything you want
+
+puts 'Type and Run: @assistant.task = "show files in current directory"'
+
 IRB.start(__FILE__)

data/lib/ox-ai-workers.rb

@@ -11,13 +11,14 @@ require_relative 'oxaiworkers/version'
 require_relative 'oxaiworkers/contextual_logger'
 require_relative 'oxaiworkers/load_i18n'
 require_relative 'oxaiworkers/present_compat'
+require_relative 'oxaiworkers/tool_definition'
+require_relative 'oxaiworkers/dependency_helper'
+
 require_relative 'oxaiworkers/module_request'
 require_relative 'oxaiworkers/state_helper'
 require_relative 'oxaiworkers/state_batch'
 require_relative 'oxaiworkers/state_tools'
-require_relative 'oxaiworkers/tool_definition'
 require_relative 'oxaiworkers/delayed_request'
-require_relative 'oxaiworkers/dependency_helper'
 require_relative 'oxaiworkers/iterator'
 require_relative 'oxaiworkers/request'
 

data/lib/oxaiworkers/assistant/coder.rb

@@ -6,14 +6,16 @@ module OxAiWorkers
       include OxAiWorkers::Assistant::ModuleBase
 
       def initialize(delayed: false, model: nil, language: 'ruby')
+        store_locale
         @iterator = Iterator.new(
           worker: init_worker(delayed: delayed, model: model),
           role: format(I18n.t('oxaiworkers.assistant.coder.role'), language),
           tools: [Tool::Eval.new, Tool::FileSystem.new],
+          locale: @locale,
           on_inner_monologue: ->(text:) { puts "monologue: #{text}".colorize(:yellow) },
           on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) },
           on_action_request: ->(text:) { puts "action: #{text}".colorize(:red) },
-          on_pack_history: ->(text:) { puts "summary: #{text}".colorize(:blue) }
+          on_summarize: ->(text:) { puts "summary: #{text}".colorize(:blue) }
         )
       end
     end

data/lib/oxaiworkers/assistant/localizer.rb

@@ -6,14 +6,16 @@ module OxAiWorkers
       include OxAiWorkers::Assistant::ModuleBase
 
       def initialize(delayed: false, model: nil, language: 'русский', locale: :ru, source: 'english')
+        store_locale
         @iterator = Iterator.new(
           worker: init_worker(delayed: delayed, model: model),
           role: format(I18n.t('oxaiworkers.assistant.localizer.role'), language),
           tools: [Tool::Eval.new, Tool::FileSystem.new],
+          locale: @locale,
           on_inner_monologue: ->(text:) { puts "monologue: #{text}".colorize(:yellow) },
           on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) },
           on_action_request: ->(text:) { puts "action: #{text}".colorize(:red) },
-          on_pack_history: ->(text:) { puts "summary: #{text}".colorize(:blue) }
+          on_summarize: ->(text:) { puts "summary: #{text}".colorize(:blue) }
         )
         @iterator.add_context(format(I18n.t('oxaiworkers.assistant.localizer.source'), source))
 

data/lib/oxaiworkers/assistant/module_base.rb

@@ -3,6 +3,8 @@
 module OxAiWorkers
   module Assistant
     module ModuleBase
+      include OxAiWorkers::LoadI18n
+
       attr_accessor :iterator
 
       def task=(task)

data/lib/oxaiworkers/assistant/sysop.rb

@@ -6,14 +6,16 @@ module OxAiWorkers
       include OxAiWorkers::Assistant::ModuleBase
 
       def initialize(delayed: false, model: nil)
+        store_locale
         @iterator = Iterator.new(
           worker: init_worker(delayed: delayed, model: model),
           role: I18n.t('oxaiworkers.assistant.sysop.role'),
-          tools: [Tool::Eval.new],
+          tools: [Tool::Eval.new(only: :sh), Tool::FileSystem.new(only: %i[read_file write_to_file])],
+          locale: @locale,
           on_inner_monologue: ->(text:) { puts "monologue: #{text}".colorize(:yellow) },
           on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) },
           on_action_request: ->(text:) { puts "action: #{text}".colorize(:red) },
-          on_pack_history: ->(text:) { puts "summary: #{text}".colorize(:blue) }
+          on_summarize: ->(text:) { puts "summary: #{text}".colorize(:blue) }
         )
       end
     end

data/lib/oxaiworkers/iterator.rb

@@ -2,40 +2,52 @@
 
 module OxAiWorkers
   class Iterator < OxAiWorkers::StateTools
-    extend OxAiWorkers::ToolDefinition
-    attr_accessor :worker, :role, :messages, :context, :result, :tools, :queue, :monologue, :tasks, :milestones
-    attr_accessor :on_inner_monologue, :on_outer_voice, :on_action_request, :on_pack_history
+    ITERATOR_FUNCTIONS = %i[inner_monologue outer_voice action_request summarize].freeze
 
-    define_function :inner_monologue, description: I18n.t('oxaiworkers.iterator.inner_monologue.description') do
-      property :speach, type: 'string', description: I18n.t('oxaiworkers.iterator.inner_monologue.speach'),
-                        required: true
-    end
+    include OxAiWorkers::ToolDefinition
+    include OxAiWorkers::LoadI18n
 
-    define_function :outer_voice, description: I18n.t('oxaiworkers.iterator.outer_voice.description') do
-      property :text, type: 'string', description: I18n.t('oxaiworkers.iterator.outer_voice.text'), required: true
-    end
+    attr_accessor :worker, :role, :messages, :context, :result, :tools, :queue, :monologue, :tasks, :milestones,
+                  :on_inner_monologue, :on_outer_voice, :on_action_request, :on_summarize, :def_except, :def_only
 
-    define_function :action_request, description: I18n.t('oxaiworkers.iterator.action_request.description') do
-      property :action, type: 'string', description: I18n.t('oxaiworkers.iterator.action_request.action'),
-                        required: true
-    end
+    def initialize(worker:, role: nil, tools: [], on_inner_monologue: nil, on_outer_voice: nil, on_action_request: nil,
+                   on_summarize: nil, steps: nil, def_except: [], def_only: nil, locale: nil)
 
-    define_function :summarize, description: I18n.t('oxaiworkers.iterator.pack_history.description') do
-      property :text, type: 'string', description: I18n.t('oxaiworkers.iterator.pack_history.text'), required: true
-    end
+      @locale = locale || I18n.locale
+
+      with_locale do
+        define_function :inner_monologue, description: I18n.t('oxaiworkers.iterator.inner_monologue.description') do
+          property :speach, type: 'string', description: I18n.t('oxaiworkers.iterator.inner_monologue.speach'),
+                            required: true
+        end
+
+        define_function :outer_voice, description: I18n.t('oxaiworkers.iterator.outer_voice.description') do
+          property :text, type: 'string', description: I18n.t('oxaiworkers.iterator.outer_voice.text'), required: true
+        end
+
+        define_function :action_request, description: I18n.t('oxaiworkers.iterator.action_request.description') do
+          property :action, type: 'string', description: I18n.t('oxaiworkers.iterator.action_request.action'),
+                            required: true
+        end
+
+        define_function :summarize, description: I18n.t('oxaiworkers.iterator.summarize.description') do
+          property :text, type: 'string', description: I18n.t('oxaiworkers.iterator.summarize.text'), required: true
+        end
+
+        @monologue = steps || I18n.t('oxaiworkers.iterator.monologue')
+      end
 
-    def initialize(worker:, role: nil, tools: [], on_inner_monologue: nil, on_outer_voice: nil, on_action_request: nil,
-                   on_pack_history: nil, steps: nil)
       @worker = worker
-      @tools = [self] + tools
+      @tools = tools
       @role = role
       @context = []
-      @monologue = steps || I18n.t('oxaiworkers.iterator.monologue')
+      @def_only = def_only || ITERATOR_FUNCTIONS
+      @def_except = def_except
 
       @on_inner_monologue = on_inner_monologue
       @on_outer_voice = on_outer_voice
       @on_action_request = on_action_request
-      @on_pack_history = on_pack_history
+      @on_summarize = on_summarize
 
       cleanup
 
@@ -61,6 +73,7 @@ module OxAiWorkers
     def outer_voice(text:)
       # @queue.pop
       @queue << { role: :assistant, content: text.to_s }
+      complete! unless available_defs.include?(:action_request)
       @on_outer_voice&.call(text: text)
       nil
     end
@@ -77,11 +90,13 @@ module OxAiWorkers
     def summarize(text:)
       @milestones << text.to_s
       @messages = []
-      @queue << { role: :assistant, content: I18n.t('oxaiworkers.iterator.pack_history.result') }
+      with_locale do
+        @queue << { role: :assistant, content: I18n.t('oxaiworkers.iterator.summarize.result') }
+      end
       @worker.finish
       rebuild_worker
-      # complete! if can_complete?
-      @on_pack_history&.call(text: text)
+      complete! if can_complete?
+      @on_summarize&.call(text: text)
       nil
     end
 
@@ -93,12 +108,29 @@ module OxAiWorkers
     def rebuild_worker
       @worker.messages = []
       @worker.append(role: :system, content: @role) if @role.present?
-      @worker.append(role: :system, content: @monologue.join("\n"))
+      @worker.append(role: :system, content: valid_monologue.join("\n"))
       @worker.append(messages: @context) if @context.present?
       @tasks.each { |task| @worker.append(role: :user, content: task) }
       @milestones.each { |milestone| @worker.append(role: :assistant, content: milestone) }
       @worker.append(messages: @messages)
-      @worker.tools = @tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten if @tools.present?
+      @worker.tools = function_schemas.to_openai_format(only: available_defs)
+      return unless @tools.present?
+
+      @worker.tools += @tools.map do |tool|
+        if tool.respond_to?(:function_schemas)
+          tool.function_schemas.to_openai_format
+        else
+          tool.class.function_schemas.to_openai_format
+        end
+      end.flatten
+    end
+
+    def available_defs
+      @def_only - @def_except
+    end
+
+    def valid_monologue
+      @monologue.reject { |item| @def_except.any? { |fun| item.include?(self.class.full_function_name(fun)) } }
     end
 
     def next_iteration
@@ -123,12 +155,13 @@ module OxAiWorkers
       if @worker.tool_calls.present?
         @queue << { role: :assistant, content: @worker.tool_calls_raw.to_s }
         @worker.tool_calls.each do |external_call|
-          tool = @tools.select do |t|
-            t.class.tool_name == external_call[:class] && t.respond_to?(external_call[:name])
+          tool = ([self] + @tools).select do |t|
+            tool_name = t.respond_to?(:tool_name) ? t.tool_name : t.class.tool_name
+            tool_name == external_call[:class] && t.respond_to?(external_call[:name])
           end.first
           unless tool.nil?
             out = tool.send(external_call[:name], **external_call[:args])
-            @queue << { role: :user, content: out.to_s } if out.present?
+            @queue << { role: :system, content: out.to_s } if out.present?
           end
         end
         @worker.finish

data/lib/oxaiworkers/load_i18n.rb

@@ -2,3 +2,18 @@
 
 require 'i18n'
 I18n.load_path += Dir["#{File.expand_path('../../locales', __dir__)}/*.yml"]
+
+module OxAiWorkers
+  module LoadI18n
+    attr_accessor :locale
+
+    def with_locale(&action)
+      # locale = respond_to?(:locale) ? self.locale : OxAiWorkers.configuration.locale
+      I18n.with_locale(@locale, &action)
+    end
+
+    def store_locale
+      @locale = I18n.locale
+    end
+  end
+end

data/lib/oxaiworkers/tool/database.rb

@@ -10,28 +10,9 @@ module OxAiWorkers
     #     database = OxAiWorkers::Tool::Database.new(connection_string: "postgres://user:password@localhost:5432/db_name")
     #
     class Database
-      extend OxAiWorkers::ToolDefinition
+      include OxAiWorkers::ToolDefinition
       include OxAiWorkers::DependencyHelper
-
-      define_function :list_tables,
-                      description: I18n.t('oxaiworkers.tool.database_tool.list_tables.description')
-
-      define_function :describe_tables,
-                      description: I18n.t('oxaiworkers.tool.database_tool.describe_tables.description') do
-        property :tables, type: 'string',
-                          description: I18n.t('oxaiworkers.tool.database_tool.describe_tables.tables'),
-                          required: true
-      end
-
-      define_function :dump_schema,
-                      description: I18n.t('oxaiworkers.tool.database_tool.dump_schema.description')
-
-      define_function :execute,
-                      description: I18n.t('oxaiworkers.tool.database_tool.execute.description') do
-        property :input, type: 'string',
-                         description: I18n.t('oxaiworkers.tool.database_tool.execute.input'),
-                         required: true
-      end
+      include OxAiWorkers::LoadI18n
 
       attr_reader :db, :requested_tables, :excluded_tables
 
@@ -41,11 +22,35 @@ module OxAiWorkers
       # @param tables [Array<Symbol>] The tables to use. Will use all if empty.
       # @param except_tables [Array<Symbol>] The tables to exclude. Will exclude none if empty.
       # @return [Database] Database object
-      def initialize(connection_string:, tables: [], exclude_tables: [])
+      def initialize(connection_string:, tables: [], exclude_tables: [], only: nil)
         depends_on 'sequel'
 
         raise StandardError, 'connection_string parameter cannot be blank' if connection_string.empty?
 
+        store_locale
+
+        init_white_list_with only
+
+        define_function :list_tables,
+                        description: I18n.t('oxaiworkers.tool.database_tool.list_tables.description')
+
+        define_function :describe_tables,
+                        description: I18n.t('oxaiworkers.tool.database_tool.describe_tables.description') do
+          property :tables, type: 'string',
+                            description: I18n.t('oxaiworkers.tool.database_tool.describe_tables.tables'),
+                            required: true
+        end
+
+        define_function :dump_schema,
+                        description: I18n.t('oxaiworkers.tool.database_tool.dump_schema.description')
+
+        define_function :execute,
+                        description: I18n.t('oxaiworkers.tool.database_tool.execute.description') do
+          property :input, type: 'string',
+                           description: I18n.t('oxaiworkers.tool.database_tool.execute.input'),
+                           required: true
+        end
+
         @db = Sequel.connect(connection_string)
         @requested_tables = tables
         @excluded_tables = exclude_tables

data/lib/oxaiworkers/tool/eval.rb

@@ -5,21 +5,28 @@ require 'open3'
 module OxAiWorkers
   module Tool
     class Eval
-      extend OxAiWorkers::ToolDefinition
+      include OxAiWorkers::ToolDefinition
       include OxAiWorkers::DependencyHelper
+      include OxAiWorkers::LoadI18n
 
-      # define_function :ruby, description: I18n.t('oxaiworkers.tool.eval.ruby.description') do
-      #   property :input, type: 'string', description: I18n.t('oxaiworkers.tool.eval.ruby.input'), required: true
-      # end
+      def initialize(only: nil)
+        store_locale
 
-      define_function :sh, description: I18n.t('oxaiworkers.tool.eval.sh.description') do
-        property :input, type: 'string', description: I18n.t('oxaiworkers.tool.eval.sh.input'), required: true
+        init_white_list_with only
+
+        define_function :ruby, description: I18n.t('oxaiworkers.tool.eval.ruby.description') do
+          property :input, type: 'string', description: I18n.t('oxaiworkers.tool.eval.ruby.input'), required: true
+        end
+
+        define_function :sh, description: I18n.t('oxaiworkers.tool.eval.sh.description') do
+          property :input, type: 'string', description: I18n.t('oxaiworkers.tool.eval.sh.input'), required: true
+        end
       end
 
-      # def ruby(input:)
-      #   puts "Executing ruby: \"#{input}\"".colorize(:red)
-      #   eval(input)
-      # end
+      def ruby(input:)
+        puts "Executing ruby: \"#{input}\"".colorize(:red)
+        eval(input)
+      end
 
       def sh(input:)
         OxAiWorkers.logger.info("Executing sh: \"#{input}\"", for: self.class)

data/lib/oxaiworkers/tool/file_system.rb

@@ -11,30 +11,35 @@ module OxAiWorkers
     #    file_system = OxAiWorkers::Tool::FileSystem.new
     #
     class FileSystem
-      extend OxAiWorkers::ToolDefinition
+      include OxAiWorkers::ToolDefinition
       include OxAiWorkers::DependencyHelper
+      include OxAiWorkers::LoadI18n
 
-      define_function :list_directory,
-                      description: I18n.t('oxaiworkers.tool.file_system.list_directory.description') do
-        property :directory_path, type: 'string',
-                                  description: I18n.t('oxaiworkers.tool.file_system.list_directory.directory_path'),
-                                  required: true
-      end
+      def initialize(only: nil)
+        depends_on 'ptools'
 
-      define_function :read_file, description: I18n.t('oxaiworkers.tool.file_system.read_file.description') do
-        property :file_path, type: 'string', description: I18n.t('oxaiworkers.tool.file_system.read_file.file_path'),
-                             required: true
-      end
+        store_locale
 
-      define_function :write_to_file, description: I18n.t('oxaiworkers.tool.file_system.write_to_file.description') do
-        property :file_path, type: 'string',
-                             description: I18n.t('oxaiworkers.tool.file_system.write_to_file.file_path'), required: true
-        property :content, type: 'string', description: I18n.t('oxaiworkers.tool.file_system.write_to_file.content'),
-                           required: true
-      end
+        init_white_list_with only
 
-      def initialize
-        depends_on 'ptools'
+        define_function :list_directory,
+                        description: I18n.t('oxaiworkers.tool.file_system.list_directory.description') do
+          property :directory_path, type: 'string',
+                                    description: I18n.t('oxaiworkers.tool.file_system.list_directory.directory_path'),
+                                    required: true
+        end
+
+        define_function :read_file, description: I18n.t('oxaiworkers.tool.file_system.read_file.description') do
+          property :file_path, type: 'string', description: I18n.t('oxaiworkers.tool.file_system.read_file.file_path'),
+                               required: true
+        end
+
+        define_function :write_to_file, description: I18n.t('oxaiworkers.tool.file_system.write_to_file.description') do
+          property :file_path, type: 'string',
+                               description: I18n.t('oxaiworkers.tool.file_system.write_to_file.file_path'), required: true
+          property :content, type: 'string', description: I18n.t('oxaiworkers.tool.file_system.write_to_file.content'),
+                             required: true
+        end
       end
 
       def list_directory(directory_path:)
@@ -42,31 +47,31 @@ module OxAiWorkers
         list = Dir.entries(directory_path)
         list.delete_if { |f| f.start_with?('.') }
         if list.present?
-          "Contents of directory \"#{directory_path}\":\n #{list.join("\n")}"
+          with_locale { "Contents of directory \"#{directory_path}\":\n #{list.join("\n")}" }
         else
-          "Directory is empty: #{directory_path}"
+          with_locale { "Directory is empty: #{directory_path}" }
         end
       rescue Errno::ENOENT
-        "No such directory: #{directory_path}"
+        with_locale { "No such directory: #{directory_path}" }
       end
 
       def read_file(file_path:)
         OxAiWorkers.logger.info("Reading file: #{file_path}", for: self.class)
         if File.binary?(file_path)
-          "File is binary: #{file_path}"
+          with_locale { "File is binary: #{file_path}" }
         else
           File.read(file_path).to_s
         end
       rescue Errno::ENOENT
-        "No such file: #{file_path}"
+        with_locale { "No such file: #{file_path}" }
       end
 
       def write_to_file(file_path:, content:)
         OxAiWorkers.logger.info("Writing to file: #{file_path}", for: self.class)
         File.write(file_path, content)
-        "Content was successfully written to the file: #{file_path}"
+        with_locale { "Content was successfully written to the file: #{file_path}" }
       rescue Errno::EACCES
-        "Permission denied: #{file_path}"
+        with_locale { "Permission denied: #{file_path}" }
       end
     end
   end

data/lib/oxaiworkers/tool_definition.rb

@@ -37,13 +37,21 @@ require "json"
 #   end
 #
 module OxAiWorkers::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:, &)
-    function_schemas.add_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
@@ -57,12 +65,16 @@ module OxAiWorkers::ToolDefinition
   #
   # @return [String] The snake_case version of the class name
   def tool_name
-    @tool_name ||= 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)
@@ -70,6 +82,10 @@ module OxAiWorkers::ToolDefinition
       @tool_name = tool_name
     end
 
+    def function_name method_name
+      "#{@tool_name}__#{method_name}"
+    end
+
     # Adds a function to the schemas
     #
     # @param method_name [Symbol] Name of the method to add
@@ -77,7 +93,7 @@ module OxAiWorkers::ToolDefinition
     # @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 = "#{@tool_name}__#{method_name}"
+      name = function_name(method_name)
 
       if block_given?
         parameters = ParameterBuilder.new(parent_type: "object").build(&)
@@ -96,15 +112,23 @@ module OxAiWorkers::ToolDefinition
     # Converts schemas to OpenAI-compatible format
     #
     # @return [String] JSON string of schemas in OpenAI format
-    def to_openai_format
-      @schemas.values#.map { |schema| schema[:function] }
+    def to_openai_format(only: nil)
+      valid_schemas(only: only).values
+    end
+
+    def valid_schemas(only: nil)
+      if only.nil?
+        @schemas
+      else
+        @schemas.select { |name, schema| only.include?(name) }
+      end
     end
 
     # Converts schemas to Anthropic-compatible format
     #
     # @return [String] JSON string of schemas in Anthropic format
-    def to_anthropic_format
-      @schemas.values.map do |schema|
+    def to_anthropic_format(only: nil)
+      valid_schemas(only: only).values.map do |schema|
         schema[:function].transform_keys("parameters" => "input_schema")
       end
     end
@@ -112,8 +136,8 @@ module OxAiWorkers::ToolDefinition
     # Converts schemas to Google Gemini-compatible format
     #
     # @return [String] JSON string of schemas in Google Gemini format
-    def to_google_gemini_format
-      @schemas.values.map { |schema| schema[:function] }
+    def to_google_gemini_format(only: nil)
+      valid_schemas(only: only).values.map { |schema| schema[:function] }
     end
   end
 

data/lib/oxaiworkers/version.rb

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

data/locales/en.iterator.yml

@@ -10,7 +10,7 @@ en:
       action_request:
         description: A function for interactive interaction with the user. Allows you to ask a clarifying question, request actions, or complete the current step. The function waits for the user's response and returns it.
         action: Text of the request or action
-      pack_history:
+      summarize:
         description: The function saves key facts, nuances, and actions from previous messages, including the provided response. After calling this function, all previous messages will be deleted. Use it only after all intermediate steps are completed and when the exact content of previous messages is no longer relevant.
         text: Enumeration of important facts and nuances
         result: Messages deleted
@@ -18,5 +18,5 @@ en:
         - Step 1. Develop your own solution to the problem, taking initiative and making assumptions.
         - Step 2. Enclose all your developments from the previous step in the ox_ai_workers_iterator__inner_monologue function.
         - Step 3. Call the necessary functions one after another until the desired result is achieved.
-        - Step 4. When all intermediate steps are completed and the exact content of previous messages is no longer relevant, use the ox_ai_workers_iterator__pack_history function.
+        - Step 4. When all intermediate steps are completed and the exact content of previous messages is no longer relevant, use the ox_ai_workers_iterator__summarize function.
         - Step 5. When the solution is ready, notify about it and wait for the user's response.

data/locales/ru.iterator.yml

@@ -10,7 +10,7 @@ ru:
       action_request:
         description: Функция для интерактивного взаимодействия с пользователем. Позволяет задать уточняющий вопрос, запросить выполнение действий или завершить текущий шаг. Функция ожидает ответ пользователя и возвращает его.
         action: Текст запроса или действия
-      pack_history:
+      summarize:
         description: Функция сохраняет ключевые факты, нюансы и действия из предыдущих сообщений, включая предоставленный ответ. После вызова этой функции все предыдущие сообщения будут удалены. Используйте её только после завершения всех промежуточных шагов и когда точное содержание предыдущих сообщений больше не имеет значения.
         text: Перечисление важных фактов и нюансов
         result: Сообщения удалены
@@ -18,5 +18,5 @@ ru:
         - Шаг 1. Разработай собственное решение проблемы, проявляя инициативу и делая предположения.
         - Шаг 2. Заключи все свои наработки из предыдущего шага в функцию ox_ai_workers_iterator__inner_monologue.
         - Шаг 3. Вызывай необходимые функции друг за другом, пока желаемый результат не будет достигнут.
-        - Шаг 4. Когда все промежуточные шаги завершены и точное содержание предыдущих сообщений больше не имеет значения, используй функцию ox_ai_workers_iterator__pack_history.
+        - Шаг 4. Когда все промежуточные шаги завершены и точное содержание предыдущих сообщений больше не имеет значения, используй функцию ox_ai_workers_iterator__summarize.
         - Шаг 5. Когда решение готово, сообщи об этом и ожидай ответ пользователя.

data/template/my_assistant.rb

@@ -10,20 +10,26 @@ class MyAssistant
     # Optional instructions
     # steps = []
     # steps << 'Step 1. Develop your own solution to the problem, taking initiative and making assumptions.'
-    # steps << 'Step 2. Enclose all your developments from the previous step in the ox_ai_workers_iterator__inner_monologue function.'
+    # steps << "Step 2. Enclose all your developments from the previous step in the #{OxAiWorkers::Iterator.full_function_name(:inner_monologue)} function."
     # steps << 'Step 3. Call the necessary functions one after another until the desired result is achieved.'
-    # steps << 'Step 4. When all intermediate steps are completed and the exact content of previous messages is no longer relevant, use the ox_ai_workers_iterator__pack_history function.'
+    # steps << "Step 4. When all intermediate steps are completed and the exact content of previous messages is no longer relevant, use the #{OxAiWorkers::Iterator.full_function_name(:summarize)} function."
     # steps << "Step 5. When the solution is ready, notify about it and wait for the user's response."
 
+    # To retain the locale if you have assistants in different languages in your project.
+    # store_locale # Optional
+
     @iterator = OxAiWorkers::Iterator.new(
       worker: init_worker(delayed: delayed, model: model),
       role: 'You are a software agent inside my computer',
       tools: [MyTool.new],
+      # locale: @locale || I18n.locale,
       # steps: steps,
+      # def_except: [:summarize], # It's except steps with that functions
+      # def_only: [:inner_monologue, :outer_voice], # Use it only with your steps
       on_inner_monologue: ->(text:) { puts "monologue: #{text}".colorize(:yellow) },
       on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) },
       on_action_request: ->(text:) { puts "action: #{text}".colorize(:red) },
-      on_pack_history: ->(text:) { puts "summary: #{text}".colorize(:blue) }
+      on_summarize: ->(text:) { puts "summary: #{text}".colorize(:blue) }
     )
   end
 end

data/template/tools/my_tool.rb

@@ -1,13 +1,24 @@
 # frozen_string_literal: true
 
 class MyTool
-  extend OxAiWorkers::ToolDefinition
-  include OxAiWorkers::DependencyHelper
+  extend OxAiWorkers::ToolDefinition # (!) extend
 
   define_function :sh, description: 'Execute a sh command and get the result (stdout + stderr)' do
     property :input, type: 'string', description: 'Source command', required: true
   end
 
+  # Alternative implementation if you need to filter functions during initialization.
+  # include OxAiWorkers::ToolDefinition # (!) include
+  # include OxAiWorkers::LoadI18n # to support multiple languages
+  #
+  # def initialize(only: nil)
+  #   store_locale # To retain the locale if you have MyTool in different languages.
+  #   init_white_list_with only
+  #   define_function :sh, description:  I18n.t('Execute a sh command and get the result (stdout + stderr)') do
+  #     property :input, type: 'string', description:  I18n.t('Source command'), required: true
+  #   end
+  # end
+
   def sh(input:)
     OxAiWorkers.logger.info("Executing sh: \"#{input}\"", for: self.class)
     stdout_and_stderr_s, = Open3.capture2e(input)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ox-ai-workers
 version: !ruby/object:Gem::Version
-  version: 0.5.3.1
+  version: 0.5.5
 platform: ruby
 authors:
 - Denis Smolev
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-07-31 00:00:00.000000000 Z
+date: 2024-08-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize
@@ -108,17 +108,17 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1'
-description: |
-  OxAiWorkers (ox-ai-workers) is a Ruby gem that provides a powerful and flexible state machine with
-  integration of generative intelligence using the ruby-openai gem. This gem allows you to create state
-  machines for solving complex tasks, enhancing the final result by leveraging internal logic (state machine)
-  and external tools (OpenAI generative intelligence).
+description: |2
+      OxAiWorkers (ox-ai-workers) is a Ruby gem that provides a powerful and flexible state machine with
+      integration of generative intelligence using the ruby-openai gem. This gem allows you to create state
+      machines for solving complex tasks, enhancing the final result by leveraging internal logic (state machine)
+      and external tools (OpenAI generative intelligence).
 
-  Features:
-  - State Machine: Easily create and manage state machines to model various states and transitions in your application.
-  - OpenAI Integration: Utilize the capabilities of generative intelligence to make decisions and perform tasks, improving the quality and accuracy of results.
-  - Flexibility and Extensibility: Customize the behavior of the state machine and OpenAI integration according to your needs.
-  - Ease of Use: Intuitive syntax and documentation make it easy to get started with the gem.
+      Features:
+      - State Machine: Easily create and manage state machines to model various states and transitions in your application.
+      - OpenAI Integration: Utilize the capabilities of generative intelligence to make decisions and perform tasks, improving the quality and accuracy of results.
+      - Flexibility and Extensibility: Customize the behavior of the state machine and OpenAI integration according to your needs.
+      - Ease of Use: Intuitive syntax and documentation make it easy to get started with the gem.
 email:
 - smolev@me.com
 executables: