ox-ai-workers 0.2.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68e329b2bdf72c3b0d75acc50542f1af17bfde774f5e1ad26b4d28ae8b2eb3d4
-  data.tar.gz: 7e233262b802841e7a3c6241864376d5d25668391a9b482f441b47617e556703
+  metadata.gz: 2e3f7b60a9ac9e53b673390eb9a81a1607fc47890325e80dc659ce2050756f73
+  data.tar.gz: 818318dd86e9bb1b2e0b39492196cf1b1bc3e86095b94ab2bca7546cca8a8998
 SHA512:
-  metadata.gz: ed6cb48bbf7ed1069fc29a4e3ca8e288f8c4e7af4fd08cd4ef4cf1a599de3720edb220afe52cb56db3b01f694cff197924b7d66908a7513979a64d818672b7c0
-  data.tar.gz: bceb85175f975cd69100186012a4429f37e78e01f91962921979d7c27bf4e09dd0150dc8fa83d20711a62073ffb6ad58bf99bac756fdb6cf8c34de785bdf2c37
+  metadata.gz: ceeb35b06b858251cb880e4041e355df5fae35ad444658d2285e3f281870884e7773d2249fc88545b5db28604a14139f2baf74fc0d2c4480d6308c05e24a49b4
+  data.tar.gz: 17ffe3062ce9108fc83cad218aa461b9a68bca0b7e97c77aa3ed4e2f4dec388bf25a7bf06ec217f0e1dd19fcdab77921b7109ff0103ec22696536c1a26ae003b

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [Unreleased]
 
+## [0.3.0] - 2024-07-30
+
+- on_inner_monologue: ->(text:) { puts Rainbow("monologue: #{text}").yellow }
+- on_outer_voice: ->(text:) { puts Rainbow("voice: #{text}").green }
+- on_action_request: ->(text:) { puts Rainbow("action: #{text}").red }
+- on_pack_history: ->(text:) { puts Rainbow("summary: #{text}").blue }
+
+## [0.2.5] - 2024-07-30
+
+- Improved start template
+
 ## [0.2.4] - 2024-07-30
 
 - Complete template for initialization: `oxaiworkers init full`

data/README.md

@@ -101,10 +101,18 @@ assistant.addResponse("blah-blah-blah")
 Or you can create a lower-level iterator for more control:
 
 ```ruby
+my_worker = OxAiWorkers::Request.new
+my_tool = OxAiWorkers::Tool::Eval.new
+
 iterator = OxAiWorkers::Iterator.new(
-  worker: OxAiWorkers::Request.new, 
-  tools: [OxAiWorkers::Tool::Eval.new],
-  role: "You are a software agent inside my computer" )
+    worker: my_worker, 
+    tools: [my_tool],
+    role: "You are a software agent inside my computer",
+    on_inner_monologue: ->(text:) { puts Rainbow("monologue: #{text}").yellow },
+    on_outer_voice: ->(text:) { puts Rainbow("voice: #{text}").green },
+    on_action_request: ->(text:) { puts Rainbow("action: #{text}").red },
+    on_pack_history: ->(text:) { puts Rainbow("summary: #{text}").blue } 
+  )
 
 iterator.addTask("Show files in current directory.")
 # ...
@@ -131,15 +139,17 @@ As a worker, you can use different classes depending on your needs:
 oxaiworkers init
 ```
 
-or 
+This will create a `.oxaiworkers-local` directory with the necessary initial source code. 
+
+Additionally, you can initialize a more comprehensive example using the command:
 
 ```sh
 oxaiworkers init full
 ```
 
-This will create a `.oxaiworkers-local` directory with the necessary initial settings.
+After this, in the `my_assistant.rb` file, you can find an example of an assistant that uses a tool from the `tools/my_tool.rb` file. In the `start` file, you will find the algorithm for applying this assistant.
 
-3. Modify the settings as needed and run:
+3. Modify the code as needed and run:
 
 ```sh
 .oxaiworkers-local/start

data/lib/oxaiworkers/assistant/sysop.rb

@@ -9,7 +9,11 @@ module OxAiWorkers
         @iterator = OxAiWorkers::Iterator.new(
           worker: initWorker(delayed: delayed, model: model),
           role: I18n.t('oxaiworkers.assistant.sysop.role'),
-          tools: [OxAiWorkers::Tool::Eval.new]
+          tools: [OxAiWorkers::Tool::Eval.new],
+          on_inner_monologue: ->(text:) { puts Rainbow("monologue: #{text}").yellow },
+          on_outer_voice: ->(text:) { puts Rainbow("voice: #{text}").green },
+          on_action_request: ->(text:) { puts Rainbow("action: #{text}").red },
+          on_pack_history: ->(text:) { puts Rainbow("summary: #{text}").blue }
         )
       end
     end

data/lib/oxaiworkers/compatibility.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ruby
   module OxAiWorkers
     VERSION = ::OxAiWorkers::VERSION

data/lib/oxaiworkers/delayed_request.rb

@@ -1,107 +1,109 @@
-class OxAiWorkers::DelayedRequest < OxAiWorkers::StateBatch
-  def initialize(batch_id: nil, model: nil, max_tokens: nil, temperature: nil)
-    initializeRequests(model: model, max_tokens: max_tokens, temperature: temperature)
-    @custom_id = nil if batch_id.present?
-    @batch_id = batch_id
-    @file_id = nil
-    super()
-  end
-  
-  def postBatch
-    response = @client.batches.create(
-                          parameters: {
-                              input_file_id: @file_id,
-                              endpoint: "/v1/chat/completions",
-                              completion_window: "24h"
-                            }
-                          )
-    @batch_id = response["id"]
-  end
+# frozen_string_literal: true
 
-  def cancelBatch
-    not_found_is_ok{ @client.batches.cancel(id: @batch_id) }
-  end
+module OxAiWorkers
+  class DelayedRequest < OxAiWorkers::StateBatch
+    def initialize(batch_id: nil, model: nil, max_tokens: nil, temperature: nil)
+      initializeRequests(model: model, max_tokens: max_tokens, temperature: temperature)
+      @custom_id = nil if batch_id.present?
+      @batch_id = batch_id
+      @file_id = nil
+      super()
+    end
 
-  def cleanStorage
-    if @batch_id.present?
-      batch = @client.batches.retrieve(id: @batch_id)
-      if !batch["output_file_id"].nil?
-        not_found_is_ok{ @client.files.delete(id: batch["output_file_id"]) }
-      elsif !batch["error_file_id"].nil?
-        not_found_is_ok{ @client.files.delete(id: batch["error_file_id"]) }
-      end
-      not_found_is_ok{ @client.files.delete(id: batch["input_file_id"]) }
-      not_found_is_ok{ @client.files.delete(id: @file_id) } if @file_id.present? && @file_id != batch["input_file_id"]
-    elsif @file_id.present?
-      not_found_is_ok{ @client.files.delete(id: @file_id) }
+    def postBatch
+      response = @client.batches.create(
+        parameters: {
+          input_file_id: @file_id,
+          endpoint: '/v1/chat/completions',
+          completion_window: '24h'
+        }
+      )
+      @batch_id = response['id']
     end
-  end
 
-  def finish
-    @custom_id = SecureRandom.uuid
-    end_batch! unless batch_idle?
-  end
+    def cancelBatch
+      not_found_is_ok { @client.batches.cancel(id: @batch_id) }
+    end
 
-  def uploadToStorage
-    item = {
-      "custom_id": @custom_id, 
-      "method": "POST", 
-      "url": "/v1/chat/completions", 
-      "body": params
-    }
+    def cleanStorage
+      if @batch_id.present?
+        batch = @client.batches.retrieve(id: @batch_id)
+        if !batch['output_file_id'].nil?
+          not_found_is_ok { @client.files.delete(id: batch['output_file_id']) }
+        elsif !batch['error_file_id'].nil?
+          not_found_is_ok { @client.files.delete(id: batch['error_file_id']) }
+        end
+        not_found_is_ok { @client.files.delete(id: batch['input_file_id']) }
+        if @file_id.present? && @file_id != batch['input_file_id']
+          not_found_is_ok do
+            @client.files.delete(id: @file_id)
+          end
+        end
+      elsif @file_id.present?
+        not_found_is_ok { @client.files.delete(id: @file_id) }
+      end
+    end
 
-    file = Tempfile.new(["batch_#{@custom_id}", ".jsonl"])
-    file.write item.to_json
-    file.close
-    begin
-      response = @client.files.upload(parameters: { file: file.path, purpose: "batch"} )
-      @file_id = response["id"]
-      process_batch!
-    rescue OpenAI::Error => e
-      puts e.inspect
-      fail_batch!
+    def finish
+      @custom_id = SecureRandom.uuid
+      end_batch! unless batch_idle?
     end
-    file.unlink
-  end
 
-  def request!
-    prepare_batch! if @messages.any?
-  end
+    def uploadToStorage
+      item = {
+        "custom_id": @custom_id,
+        "method": 'POST',
+        "url": '/v1/chat/completions',
+        "body": params
+      }
 
-  def cancel
-    cancel_batch!
-  end
+      file = Tempfile.new(["batch_#{@custom_id}", '.jsonl'])
+      file.write item.to_json
+      file.close
+      begin
+        response = @client.files.upload(parameters: { file: file.path, purpose: 'batch' })
+        @file_id = response['id']
+        process_batch!
+      rescue OpenAI::Error => e
+        puts e.inspect
+        fail_batch!
+      end
+      file.unlink
+    end
 
-  def completed?
-    return false if @batch_id.nil?
-    batch = @client.batches.retrieve(id: @batch_id)
-    if batch["status"] == "failed"
-      @errors = batch["errors"]["data"].map{|e| e["message"]}
-      fail_batch!
-      return true
-    elsif batch["status"] != "completed"
-      return false 
+    def request!
+      prepare_batch! if @messages.any?
     end
 
-    if !batch["output_file_id"].nil?
-			output = @client.files.content(id: batch["output_file_id"])
-			output.each do |line|
-				@custom_id = line["custom_id"]
-				# @result = line.dig("response", "body", "choices", 0, "message", "content")
-        parseChoices(line.dig("response", "body"))
-        complete_batch!
-			end
-		elsif !batch["error_file_id"].nil?
-			@errors = @client.files.content(id: batch["error_file_id"])
-      fail_batch!
-		end
-    return true
+    def cancel
+      cancel_batch!
+    end
+
+    def completed?
+      return false if @batch_id.nil?
+
+      batch = @client.batches.retrieve(id: @batch_id)
+      if batch['status'] == 'failed'
+        @errors = batch['errors']['data'].map { |e| e['message'] }
+        fail_batch!
+        return true
+      elsif batch['status'] != 'completed'
+        return false
+      end
+
+      if !batch['output_file_id'].nil?
+        output = @client.files.content(id: batch['output_file_id'])
+        output.each do |line|
+          @custom_id = line['custom_id']
+          # @result = line.dig("response", "body", "choices", 0, "message", "content")
+          parseChoices(line.dig('response', 'body'))
+          complete_batch!
+        end
+      elsif !batch['error_file_id'].nil?
+        @errors = @client.files.content(id: batch['error_file_id'])
+        fail_batch!
+      end
+      true
+    end
   end
 end
-
-# r = OxAiWorkers::DelayedRequest.new
-# r.append(role: "user", content: "сколько будет 2+2?")
-# r.request!
-# r.completed?
-# r.result
-# r.finish

data/lib/oxaiworkers/iterator.rb

@@ -1,187 +1,182 @@
-class OxAiWorkers::Iterator < OxAiWorkers::StateTools
-  extend OxAiWorkers::ToolDefinition
-  attr_accessor :worker, :role, :messages, :context, :result, :tools, :queue, :monologue, :tasks, :milestones
+# frozen_string_literal: true
 
-  define_function :innerMonologue, description: I18n.t("oxaiworkers.iterator.inner_monologue.description") do
-    property :speach, type: "string", description: I18n.t("oxaiworkers.iterator.inner_monologue.speach"), required: true
-  end
+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
 
-  define_function :outerVoice, 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 :innerMonologue, 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 :actionRequest, 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 :outerVoice, 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 :packHistory, description: I18n.t("oxaiworkers.iterator.pack_history.description") do
-    property :text, type: "string", description: I18n.t("oxaiworkers.iterator.pack_history.text"), required: true
-  end
+    define_function :actionRequest, 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: [])
-    puts "call: #{__method__}"
-    @worker = worker
-    @tools = [self] + tools
-    @role = role
-    @context = nil
-    @monologue = I18n.t("oxaiworkers.iterator.monologue")
-    cleanup()
+    define_function :packHistory, description: I18n.t('oxaiworkers.iterator.pack_history.description') do
+      property :text, type: 'string', description: I18n.t('oxaiworkers.iterator.pack_history.text'), required: true
+    end
 
-    super()
-  end
+    def initialize(worker:, role: nil, tools: [], on_inner_monologue: nil, on_outer_voice: nil, on_action_request: nil,
+                   on_pack_history: nil)
+      puts "call: #{__method__}"
+      @worker = worker
+      @tools = [self] + tools
+      @role = role
+      @context = nil
+      @monologue = I18n.t('oxaiworkers.iterator.monologue')
 
-  def cleanup
-    @result = nil
-    @queue = []
-    @tasks = []
-    @milestones = []
-    @messages = []
-    completeIteration()
-  end
+      @on_inner_monologue = on_inner_monologue
+      @on_outer_voice = on_outer_voice
+      @on_action_request = on_action_request
+      @on_pack_history = on_pack_history
 
-  def innerMonologue speach:
-    puts Rainbow("monologue: #{speach}").yellow
-    @queue.pop
-    @queue << {role: :system, content: "#{__method__}: #{speach}"}
-    return nil
-  end
+      cleanup
 
-  def outerVoice text:
-    puts Rainbow("voice: #{text}").green
-    @queue.pop
-    @queue << {role: :system, content:  "#{__method__}: #{text}"}
-    return nil
-  end
+      super()
+    end
 
-  def actionRequest action:
-    puts Rainbow("action: #{action}").red
-    @result = action
-    @queue.pop
-    @messages << {role: :system, content:  "#{__method__}: #{action}"}
-    complete! if can_complete?
-    return nil
-  end
+    def cleanup
+      @result = nil
+      @queue = []
+      @tasks = []
+      @milestones = []
+      @messages = []
+      completeIteration
+    end
 
-  def packHistory text:
-    puts Rainbow("summarize: #{text}").blue
-    @milestones << "#{__method__}: #{text}"
-    @messages = []
-    @worker.finish()
-    rebuildWorker()
-    complete! if can_complete?
-    return nil
-  end
+    def innerMonologue(speach:)
+      @queue.pop
+      @queue << { role: :system, content: "#{__method__}: #{speach}" }
+      @on_inner_monologue&.call(text: speach)
+      nil
+    end
 
-  def init
-    puts "call: #{__method__} state: #{state_name}"
-    rebuildWorker()
-    request!
-  end
+    def outerVoice(text:)
+      @queue.pop
+      @queue << { role: :system, content: "#{__method__}: #{text}" }
+      @on_outer_voice&.call(text: text)
+      nil
+    end
 
-  def rebuildWorker
-    @worker.messages = []
-    @worker.append(role: :system, content: @role) if !@role.nil? && @role.present?
-    @worker.append(role: :system, content: @monologue.join("\n"))
-    @worker.append(messages: @context) if !@context.nil? and @context.any?
-    @tasks.each { |task| @worker.append(role: :user, content: task) }
-    @milestones.each { |milestone| @worker.append(role: :system, content: milestone) }
-    @worker.append(messages: @messages)
-    @worker.tools = @tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten if @tools.any?
-  end
+    def actionRequest(action:)
+      @result = action
+      @queue.pop
+      @messages << { role: :system, content: "#{__method__}: #{action}" }
+      complete! if can_complete?
+      @on_action_request&.call(text: action)
+      nil
+    end
 
-  def nextIteration
-    puts "call: #{__method__} state: #{state_name}"
-    @worker.append(messages: @queue)
-    @messages += @queue
-    @queue = []
-    request!
-  end
+    def packHistory(text:)
+      @milestones << "#{__method__}: #{text}"
+      @messages = []
+      @worker.finish
+      rebuildWorker
+      complete! if can_complete?
+      @on_pack_history&.call(text: text)
+      nil
+    end
 
-  def externalRequest
-    puts "call: #{__method__} state: #{state_name}"
-    @worker.request!()
-    ticker()
-  end
+    def init
+      puts "call: #{__method__} state: #{state_name}"
+      rebuildWorker
+      request!
+    end
 
-  def ticker
-    puts "call: #{__method__} state: #{state_name}"
-    while !@worker.completed? do 
-      sleep(60) 
+    def rebuildWorker
+      @worker.messages = []
+      @worker.append(role: :system, content: @role) if !@role.nil? && @role.present?
+      @worker.append(role: :system, content: @monologue.join("\n"))
+      @worker.append(messages: @context) if !@context.nil? and @context.any?
+      @tasks.each { |task| @worker.append(role: :user, content: task) }
+      @milestones.each { |milestone| @worker.append(role: :system, content: milestone) }
+      @worker.append(messages: @messages)
+      @worker.tools = @tools.map { |tool| tool.class.function_schemas.to_openai_format }.flatten if @tools.any?
+    end
+
+    def nextIteration
+      puts "call: #{__method__} state: #{state_name}"
+      @worker.append(messages: @queue)
+      @messages += @queue
+      @queue = []
+      request!
+    end
+
+    def externalRequest
+      puts "call: #{__method__} state: #{state_name}"
+      @worker.request!
+      ticker
+    end
+
+    def ticker
+      puts "call: #{__method__} state: #{state_name}"
+      sleep(60) until @worker.completed?
+      analyze!
     end
-    analyze!
-  end
 
-  def processResult(transition)
-    puts "call: #{__method__} state: #{state_name}"
-    @result = @worker.result || @worker.errors
-    if @worker.tool_calls.present?
-      @queue << {role: :system, content: @worker.tool_calls_raw.to_s}
-      @worker.tool_calls.each do |external_call|
-        tool = @tools.select{|t| t.class.tool_name == external_call[:class] && t.respond_to?(external_call[:name]) }.first
-        unless tool.nil?
-          out = tool.send(external_call[:name], **external_call[:args])
-          @queue << {role: :system, content: out.to_s} if out.present?
+    def processResult(_transition)
+      puts "call: #{__method__} state: #{state_name}"
+      @result = @worker.result || @worker.errors
+      if @worker.tool_calls.present?
+        @queue << { role: :system, 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])
+          end.first
+          unless tool.nil?
+            out = tool.send(external_call[:name], **external_call[:args])
+            @queue << { role: :system, content: out.to_s } if out.present?
+          end
         end
-      end
-      @worker.finish()
-      iterate! if can_iterate?
-
-      # tool = @tools.select{|t| t.class.tool_name == @worker.external_call[:class] && t.respond_to?(@worker.external_call[:name]) }.first
-      # out = tool.send(@worker.external_call[:name], **@worker.external_call[:args])
-      # if can_iterate?
-      #   @queue << {role: :system, content: out.to_s} if out.present?
-      #   iterate!
-      # end
-    elsif @worker.result.present?
+        @worker.finish
+        iterate! if can_iterate?
+
+        # tool = @tools.select{|t| t.class.tool_name == @worker.external_call[:class] && t.respond_to?(@worker.external_call[:name]) }.first
+        # out = tool.send(@worker.external_call[:name], **@worker.external_call[:args])
+        # if can_iterate?
+        #   @queue << {role: :system, content: out.to_s} if out.present?
+        #   iterate!
+        # end
+      elsif @worker.result.present?
         actionRequest action: @worker.result
+      end
     end
-  end
 
-  def completeIteration
-    @queue = []
-    @worker.finish()
-  end
-  
-  def addTask task, auto_execute: true
-    @tasks << task
-    @messages << {role: :user, content: task}
-    execute() if auto_execute
-  end
+    def completeIteration
+      @queue = []
+      @worker.finish
+    end
 
-  def appendContext text, role: :system
-    @context << {role: role, content: text}
-  end
+    def addTask(task, auto_execute: true)
+      @tasks << task
+      @messages << { role: :user, content: task }
+      execute if auto_execute
+    end
 
-  def execute
-    puts "call: #{__method__} state: #{state_name}"
-    prepare! if valid?
-  end
+    def appendContext(text, role: :system)
+      @context << { role: role, content: text }
+    end
 
-  def cancel
-    puts "call: #{__method__} state: #{state_name}"
-    @worker.cancel if @worker.respond_to?(:cancel)
-  end
+    def execute
+      puts "call: #{__method__} state: #{state_name}"
+      prepare! if valid?
+    end
 
-  def valid?
-    @messages.any?
-  end
+    def cancel
+      puts "call: #{__method__} state: #{state_name}"
+      @worker.cancel if @worker.respond_to?(:cancel)
+    end
 
+    def valid?
+      @messages.any?
+    end
+  end
 end
-
-# r = OxAiWorkers::Iterator.new(worker: OxAiWorkers::Request.new)
-# r.addTask("сколько будет 2+2?")
-# r.execute
-# r.result
-
-
-# @worker.append(role: "user", content: "сколько будет 2+2?")
-# @worker.request!
-# @worker.completed?
-# @worker.result
-# @worker.finish
-# 
-# r = OxAiWorkers::Iterator.new(worker: OxAiWorkers::Request.new)
-# r.role = "ты программный агент внутри моего компьютера"
-# r.tools = [OxAiWorkers::Tool::Eval.new]
-# r.addTask("покажи мне файлы на диске, используй код на ruby")
-# r.execute

data/lib/oxaiworkers/module_request.rb

@@ -1,82 +1,82 @@
-class OxAiWorkers::ModuleRequest
-  attr_accessor :result, :client, :messages, :model, :max_tokens, :custom_id, :temperature, :tools, :errors
-  attr_accessor :tool_calls_raw, :tool_calls
+# frozen_string_literal: true
 
-  def initializeRequests(model: nil, max_tokens: nil, temperature: nil)
-    puts "call: ModuleRequest::#{__method__}"
-    @max_tokens = max_tokens || OxAiWorkers.configuration.max_tokens
-    @custom_id = SecureRandom.uuid
-    @model = model || OxAiWorkers.configuration.model
-    @temperature = temperature || OxAiWorkers.configuration.temperature
-    @client = nil
-    
-    OxAiWorkers.configuration.access_token ||= ENV["OPENAI"]
-    if OxAiWorkers.configuration.access_token.nil?
-      error_text = "OpenAi access token missing!"
-      raise OxAiWorkers::ConfigurationError, error_text
-    end
+module OxAiWorkers
+  class ModuleRequest
+    attr_accessor :result, :client, :messages, :model, :max_tokens, :custom_id, :temperature, :tools, :errors,
+                  :tool_calls_raw, :tool_calls
 
-    cleanup()
-  end
+    def initializeRequests(model: nil, max_tokens: nil, temperature: nil)
+      puts "call: ModuleRequest::#{__method__}"
+      @max_tokens = max_tokens || OxAiWorkers.configuration.max_tokens
+      @custom_id = SecureRandom.uuid
+      @model = model || OxAiWorkers.configuration.model
+      @temperature = temperature || OxAiWorkers.configuration.temperature
+      @client = nil
 
-  def cleanup
-    puts "call: ModuleRequest::#{__method__}"
-    @client ||= OpenAI::Client.new(
-                    access_token: OxAiWorkers.configuration.access_token,
-                    log_errors: true # Highly recommended in development, so you can see what errors OpenAI is returning. Not recommended in production because it could leak private data to your logs.
-                  )
-    @result = nil
-    @errors = nil
-    @messages = []
-    @tool_calls = nil
-    @tool_calls_raw = nil
-  end
+      OxAiWorkers.configuration.access_token ||= ENV['OPENAI']
+      if OxAiWorkers.configuration.access_token.nil?
+        error_text = 'OpenAi access token missing!'
+        raise OxAiWorkers::ConfigurationError, error_text
+      end
 
-  def append role: nil, content: nil, messages: nil
-    @messages << {role: role, content: content} if role.present? and content.present?
-    @messages += messages if messages.present?
-  end
+      cleanup
+    end
+
+    def cleanup
+      puts "call: ModuleRequest::#{__method__}"
+      @client ||= OpenAI::Client.new(
+        access_token: OxAiWorkers.configuration.access_token,
+        log_errors: true # Highly recommended in development, so you can see what errors OpenAI is returning. Not recommended in production because it could leak private data to your logs.
+      )
+      @result = nil
+      @errors = nil
+      @messages = []
+      @tool_calls = nil
+      @tool_calls_raw = nil
+    end
 
-  def params
-    parameters = {
+    def append(role: nil, content: nil, messages: nil)
+      @messages << { role: role, content: content } if role.present? and content.present?
+      @messages += messages if messages.present?
+    end
+
+    def params
+      parameters = {
         model: @model,
         messages: @messages,
         temperature: @temperature,
         max_tokens: @max_tokens
       }
-    if @tools.present?
-      parameters[:tools] = @tools
-      parameters[:tool_choice] = "required"
+      if @tools.present?
+        parameters[:tools] = @tools
+        parameters[:tool_choice] = 'required'
+      end
+      parameters
     end
-    parameters
-  end
 
-  def not_found_is_ok &block
-    begin
+    def not_found_is_ok
       yield
     rescue Faraday::ResourceNotFound => e
       nil
     end
-  end
 
-  def parseChoices(response)
-    # puts response.inspect
-    @tool_calls = []
-    @result = response.dig("choices", 0, "message", "content")
-    @tool_calls_raw = response.dig("choices", 0, "message", "tool_calls")
+    def parseChoices(response)
+      # puts response.inspect
+      @tool_calls = []
+      @result = response.dig('choices', 0, 'message', 'content')
+      @tool_calls_raw = response.dig('choices', 0, 'message', 'tool_calls')
 
-    @tool_calls_raw.each do |tool|
-      function = tool["function"]
-      args = JSON.parse(YAML.load(function["arguments"]).to_json, { symbolize_names: true } )
-      @tool_calls << {
-        class: function["name"].split("__").first,
-        name: function["name"].split("__").last,
-        args: args
-      }
-    end
-
-    @tool_calls
+      @tool_calls_raw.each do |tool|
+        function = tool['function']
+        args = JSON.parse(YAML.load(function['arguments']).to_json, { symbolize_names: true })
+        @tool_calls << {
+          class: function['name'].split('__').first,
+          name: function['name'].split('__').last,
+          args: args
+        }
+      end
 
-    # Assistant.send(function_name, **args)
+      @tool_calls
+    end
   end
-end
+end

data/lib/oxaiworkers/present_compat.rb

@@ -1,29 +1,33 @@
+# frozen_string_literal: true
+
 module OxAiWorkers
-	module PresentCompat
-		def present?
-			!self.nil? and !self.empty?
-		end
-	end
+  module PresentCompat
+    def present?
+      !nil? and !empty?
+    end
+  end
+
+  module CamelizeCompat
+    def camelize(first_letter = :upper)
+      string = dup
+      string = if first_letter == :upper
+                 string.sub(/^[a-z\d]*/) { |match| match.capitalize }
+               else
+                 string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
+               end
+      string.gsub(%r{(?:_|(/))([a-z\d]*)}) do
+        "#{::Regexp.last_match(1)}#{::Regexp.last_match(2).capitalize}"
+      end.gsub('/', '::')
+    end
 
-	module CamelizeCompat
-		def camelize(first_letter = :upper)
-		    string = self.dup
-			if first_letter == :upper
-				string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
-			else
-				string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
-			end
-			string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub("/", "::")
-		end
-		
-		def underscore
-			word = self.dup
-			word.gsub!(/::/, '/')
-			word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
-			word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-			word.tr!("-", "_")
-			word.downcase!
-			word
-		end
-	end
-end
+    def underscore
+      word = dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!('-', '_')
+      word.downcase!
+      word
+    end
+  end
+end

data/lib/oxaiworkers/request.rb

@@ -1,23 +1,25 @@
-class OxAiWorkers::Request < OxAiWorkers::ModuleRequest
-  alias_method :initialize, :initializeRequests 
+# frozen_string_literal: true
 
-  def finish
-    @custom_id = SecureRandom.uuid
-    cleanup()
-  end
+module OxAiWorkers
+  class Request < OxAiWorkers::ModuleRequest
+    alias initialize initializeRequests
+
+    def finish
+      @custom_id = SecureRandom.uuid
+      cleanup
+    end
 
-  def request!
-    begin
+    def request!
       response = @client.chat(parameters: params)
       parseChoices(response)
-      #@result = response.dig("choices", 0, "message", "content")
-      #puts response.inspect
+      # @result = response.dig("choices", 0, "message", "content")
+      # puts response.inspect
     rescue OpenAI::Error => e
       puts e.inspect
     end
-  end
 
-  def completed?
-    @result.present? or @errors.present? or @tool_calls.present?
+    def completed?
+      @result.present? or @errors.present? or @tool_calls.present?
+    end
   end
 end

data/lib/oxaiworkers/state_batch.rb

@@ -1,61 +1,65 @@
+# frozen_string_literal: true
+
 require 'state_machine/core'
 
-class OxAiWorkers::StateBatch < OxAiWorkers::ModuleRequest
-  include OxAiWorkers::StateHelper
-  extend StateMachine::MacroMethods
+module OxAiWorkers
+  class StateBatch < OxAiWorkers::ModuleRequest
+    include OxAiWorkers::StateHelper
+    extend StateMachine::MacroMethods
 
-  alias_method :state_initialize, :initialize
-  attr_accessor :file_id, :batch_id
+    alias state_initialize initialize
+    attr_accessor :file_id, :batch_id
 
-  state_machine :batch_state, initial: ->(t){t.batch_id.present? ? :requested : :idle}, namespace: :batch do
-    before_transition from: any, do: :log_me
+    state_machine :batch_state, initial: ->(t) { t.batch_id.present? ? :requested : :idle }, namespace: :batch do
+      before_transition from: any, do: :log_me
 
-    after_transition on: :end, do: :cleanup
-    before_transition on: :process, do: :postBatch
-    after_transition on: :cancel, do: [:cancelBatch, :complete_batch!]
-    after_transition on: :complete, do: [:cleanStorage]
-    after_transition on: :prepare, do: :uploadToStorage
+      after_transition on: :end, do: :cleanup
+      before_transition on: :process, do: :postBatch
+      after_transition on: :cancel, do: %i[cancelBatch complete_batch!]
+      after_transition on: :complete, do: [:cleanStorage]
+      after_transition on: :prepare, do: :uploadToStorage
 
-    event :end do
-      transition [:finished, :canceled] => :idle
-    end
+      event :end do
+        transition %i[finished canceled] => :idle
+      end
 
-    event :prepare do
-      transition :idle => :prepared
-    end
+      event :prepare do
+        transition idle: :prepared
+      end
 
-    event :process do
-      transition :prepared => :requested
-    end
+      event :process do
+        transition prepared: :requested
+      end
 
-    event :complete do
-      transition [:requested, :failed] => :finished
-    end
+      event :complete do
+        transition %i[requested failed] => :finished
+      end
 
-    event :cancel do
-      transition [:requested, :failed, :prepared] => :canceled
-    end
+      event :cancel do
+        transition %i[requested failed prepared] => :canceled
+      end
 
-    event :fail do
-      transition [:requested, :prepared] => :failed
-    end
+      event :fail do
+        transition %i[requested prepared] => :failed
+      end
 
-    state :requested
-    state :idle
-    state :prepared
-    state :canceled
-    state :finished
-    state :failed
-  end
+      state :requested
+      state :idle
+      state :prepared
+      state :canceled
+      state :finished
+      state :failed
+    end
 
-  def cleanup
-    @file_id = nil
-    @batch_id = nil
-    super()
-  end
+    def cleanup
+      @file_id = nil
+      @batch_id = nil
+      super()
+    end
 
-  def initialize
-    puts "call: StateBatch::#{__method__}"
-    super()
+    def initialize
+      puts "call: StateBatch::#{__method__}"
+      super()
+    end
   end
-end
+end

data/lib/oxaiworkers/state_helper.rb

@@ -1,5 +1,9 @@
-module OxAiWorkers::StateHelper
-  def log_me(transition)
-    # puts "`#{transition.event}` was called to transition from :#{transition.from} to :#{transition.to}"
+# frozen_string_literal: true
+
+module OxAiWorkers
+  module StateHelper
+    def log_me(transition)
+      # puts "`#{transition.event}` was called to transition from :#{transition.from} to :#{transition.to}"
+    end
   end
-end
+end

data/lib/oxaiworkers/state_tools.rb

@@ -1,47 +1,50 @@
-require 'state_machine/core'
-
-class OxAiWorkers::StateTools
-  include OxAiWorkers::StateHelper
-  extend StateMachine::MacroMethods
-
-  state_machine :state, initial: :idle do
-    before_transition from: any, do: :log_me
-    
-    after_transition on: :iterate, do: :nextIteration
-    after_transition on: :request, do: :externalRequest
-    after_transition on: :prepare, do: :init
-    after_transition on: :analyze, do: :processResult
-    after_transition on: :complete, do: :completeIteration
-
-    event :prepare do
-      transition [:idle, :finished] => :prepared
-    end
-
-    event :request do
-      transition :prepared => :requested
-    end
-
-    event :analyze do
-      transition [:requested] => :analyzed
-    end
-
-    event :complete do
-      transition [:analyzed] => :finished
-    end
+# frozen_string_literal: true
 
-    event :iterate do
-      transition :analyzed => :prepared
-    end
+require 'state_machine/core'
 
-    event :end do
-      transition :finished => :idle
+module OxAiWorkers
+  class StateTools
+    include OxAiWorkers::StateHelper
+    extend StateMachine::MacroMethods
+
+    state_machine :state, initial: :idle do
+      before_transition from: any, do: :log_me
+
+      after_transition on: :iterate, do: :nextIteration
+      after_transition on: :request, do: :externalRequest
+      after_transition on: :prepare, do: :init
+      after_transition on: :analyze, do: :processResult
+      after_transition on: :complete, do: :completeIteration
+
+      event :prepare do
+        transition %i[idle finished] => :prepared
+      end
+
+      event :request do
+        transition prepared: :requested
+      end
+
+      event :analyze do
+        transition [:requested] => :analyzed
+      end
+
+      event :complete do
+        transition [:analyzed] => :finished
+      end
+
+      event :iterate do
+        transition analyzed: :prepared
+      end
+
+      event :end do
+        transition finished: :idle
+      end
+
+      state :idle
+      state :prepared
+      state :requested
+      state :analyzed
+      state :finished
     end
-    
-    state :idle
-    state :prepared
-    state :requested
-    state :analyzed
-    state :finished
   end
-
-end
+end

data/lib/oxaiworkers/tool/eval.rb

@@ -2,28 +2,30 @@
 
 require 'open3'
 
-module OxAiWorkers::Tool
-  class Eval
-    extend OxAiWorkers::ToolDefinition
-    include OxAiWorkers::DependencyHelper
+module OxAiWorkers
+  module Tool
+    class Eval
+      extend OxAiWorkers::ToolDefinition
+      include OxAiWorkers::DependencyHelper
 
-    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 :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
+      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
 
-    def ruby(input:)
-      puts Rainbow("Executing ruby: \"#{input}\"").red
-      eval(input)
-    end
+      def ruby(input:)
+        puts Rainbow("Executing ruby: \"#{input}\"").red
+        eval(input)
+      end
 
-    def sh(input:)
-      puts Rainbow("Executing sh: \"#{input}\"").red
-      stdout_and_stderr_s, = Open3.capture2e(input)
-      stdout_and_stderr_s
+      def sh(input:)
+        puts Rainbow("Executing sh: \"#{input}\"").red
+        stdout_and_stderr_s, = Open3.capture2e(input)
+        stdout_and_stderr_s
+      end
     end
   end
 end

data/lib/oxaiworkers/version.rb

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

data/template/my_assistant.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'rainbow'
 require_relative 'tools/my_tool'
 
 class MyAssistant
@@ -8,8 +9,12 @@ class MyAssistant
   def initialize(delayed: false, model: nil)
     @iterator = OxAiWorkers::Iterator.new(
       worker: initWorker(delayed: delayed, model: model),
-      role: 'You are a helpful assistant',
-      tools: [MyTool.new]
+      role: 'You are a software agent inside my computer',
+      tools: [MyTool.new],
+      on_inner_monologue: ->(text:) { puts Rainbow("monologue: #{text}").yellow },
+      on_outer_voice: ->(text:) { puts Rainbow("voice: #{text}").green },
+      on_action_request: ->(text:) { puts Rainbow("action: #{text}").red },
+      on_pack_history: ->(text:) { puts Rainbow("summary: #{text}").blue }
     )
   end
 end

data/template/start

@@ -5,18 +5,24 @@ require 'i18n'
 I18n.load_path += Dir["#{File.expand_path('.oxaiworkers-local/locales')}/*.yml"]
 I18n.default_locale = :en
 
-# Start your code here
+# ### Start your code here
+
+# Required external gems
 require 'ox-ai-workers'
 require 'irb'
+
+# Required my libs
 require_relative 'my_assistant'
 
 puts "OxAiWorkers #{OxAiWorkers::VERSION}"
 
+# Configure
 OxAiWorkers.configure do |config|
   config.access_token = ENV.fetch('OPENAI')
   config.model = 'gpt-4o-mini'
 end
 
+# Main algorithm
 @assistant = MyAssistant.new
 
 IRB.start(__FILE__)

data/template/tools/my_tool.rb

@@ -4,11 +4,13 @@ class MyTool
   extend OxAiWorkers::ToolDefinition
   include OxAiWorkers::DependencyHelper
 
-  define_function :printHello, description: 'Print hello' do
-    property :name, type: 'string', description: 'Your name', required: true
+  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
 
-  def printHello(name:)
-    puts "Hello #{name}"
+  def sh(input:)
+    puts "Executing sh: \"#{input}\""
+    stdout_and_stderr_s, = Open3.capture2e(input)
+    stdout_and_stderr_s
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ox-ai-workers
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Denis Smolev