ox-ai-workers 0.2.5 → 0.3.1

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/load_i18n.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require 'i18n'
+I18n.load_path += Dir["#{File.expand_path('locales')}/*.yml"]

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