ox-ai-workers 0.8.6 → 0.9.1

data/lib/oxaiworkers/module_request.rb

@@ -2,23 +2,19 @@
 
 module OxAiWorkers
   class ModuleRequest
-    attr_accessor :result, :client, :messages, :model, :max_tokens, :custom_id, :temperature, :tools, :errors,
-                  :tool_calls_raw, :tool_calls, :is_truncated, :finish_reason, :uri_base, :on_stream_proc
+    attr_accessor :result, :client, :messages, :model, :custom_id, :tools, :errors,
+                  :tool_calls_raw, :tool_calls, :is_truncated, :finish_reason, :on_stream_proc
 
-    def initialize_requests(model: nil, max_tokens: nil, temperature: nil, uri_base: nil, on_stream: nil)
-      @max_tokens = max_tokens || OxAiWorkers.configuration.max_tokens
+    def initialize_requests(model:, on_stream: nil)
       @custom_id = SecureRandom.uuid
-      @model = model || OxAiWorkers.configuration.model
-      @temperature = temperature || OxAiWorkers.configuration.temperature
-      @uri_base = uri_base
+      @model = model
       @client = nil
       @is_truncated = false
       @finish_reason = nil
       @on_stream_proc = on_stream
 
-      OxAiWorkers.configuration.access_token ||= ENV['OPENAI']
-      if OxAiWorkers.configuration.access_token.nil?
-        error_text = 'OpenAi access token missing!'
+      if @model.api_key.nil?
+        error_text = "#{@model.model} access token missing!"
         raise OxAiWorkers::ConfigurationError, error_text
       end
 
@@ -27,8 +23,8 @@ module OxAiWorkers
 
     def cleanup
       @client ||= OpenAI::Client.new(
-        access_token: OxAiWorkers.configuration.access_token,
-        uri_base: @uri_base || OxAiWorkers.configuration.uri_base,
+        access_token: @model.api_key,
+        uri_base: @model.uri_base,
         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
@@ -47,10 +43,10 @@ module OxAiWorkers
 
     def params
       parameters = {
-        model: @model,
+        model: @model.model,
         messages: @messages,
-        temperature: @temperature,
-        max_tokens: @max_tokens
+        temperature: @model.temperature,
+        max_tokens: @model.max_tokens
       }
       if @tools.present?
         parameters[:tools] = @tools
@@ -81,53 +77,62 @@ module OxAiWorkers
       return if choices.nil? || choices.empty?
 
       choices.each do |choice|
+        # Parse basic info and accumulate raw tool calls
         parse_one_choice(choice)
       end
 
-      # @tool_calls is already populated by parse_one_choice
-      # @result, @finish_reason, @is_truncated are updated with the last relevant values
+      # Only parse tool calls if the response wasn't truncated
+      _parse_tool_calls unless @is_truncated || @tool_calls_raw.empty?
     end
 
     def parse_one_choice(choice)
       message = choice['message']
       return unless message # Skip if there's no message in this choice
 
-      # Accumulate raw tool calls
-      if message['tool_calls']
-        @tool_calls_raw.concat(message['tool_calls'])
-        message['tool_calls'].each do |tool_call|
-          next unless tool_call['type'] == 'function' # Ensure it's a function call
-
-          function = tool_call['function']
-          next unless function && function['name'] && function['arguments']
-
-          begin
-            # Attempt to parse arguments, handle potential JSON errors
-            args = JSON.parse(function['arguments'], symbolize_names: true)
-          rescue JSON::ParserError => e
-            OxAiWorkers.logger.error("Failed to parse tool call arguments: #{e.message}", for: self.class)
-            OxAiWorkers.logger.debug("Raw arguments: #{function['arguments']}", for: self.class)
-            args = {} # Assign empty args or handle error as appropriate
-          end
-
-          # Accumulate parsed tool calls
-          @tool_calls << {
-            class: function['name'].split('__').first,
-            name: function['name'].split('__').last,
-            args: args
-          }
-        end
-      end
+      # Accumulate raw tool calls if present
+      @tool_calls_raw.concat(message['tool_calls']) if message['tool_calls']
 
       # Update result with the content if present
       current_result = message['content']
       @result = current_result if current_result.present?
 
-      # Update finish reason and truncation status
+      # Update finish reason and truncation status based on the *last* choice's reason
       current_finish_reason = choice['finish_reason']
       if current_finish_reason.present?
         @finish_reason = current_finish_reason
-        @is_truncated = @finish_reason == 'length'
+        @is_truncated = (@finish_reason == 'length')
+      end
+    end
+
+    private
+
+    # Parses the accumulated raw tool calls into the structured @tool_calls array.
+    # This should only be called after confirming the response is not truncated.
+    def _parse_tool_calls
+      @tool_calls = [] # Ensure it's clean before parsing
+      @tool_calls_raw.each do |tool_call|
+        next unless tool_call['type'] == 'function' # Ensure it's a function call
+
+        function = tool_call['function']
+        next unless function && function['name'] && function['arguments']
+
+        begin
+          # Attempt to parse arguments, handle potential JSON errors
+          args = JSON.parse(function['arguments'], symbolize_names: true)
+        rescue JSON::ParserError => e
+          OxAiWorkers.logger.error("Failed to parse tool call arguments: #{e.message}", for: self.class)
+          OxAiWorkers.logger.debug("Raw arguments: #{function['arguments']}", for: self.class)
+          # Decide how to handle parsing errors, e.g., skip this call or add with empty args
+          # Skipping for now, as partial args are likely useless.
+          next
+        end
+
+        # Accumulate parsed tool calls
+        @tool_calls << {
+          class: function['name'].split('__').first,
+          name: function['name'].split('__').last,
+          args: args
+        }
       end
     end
   end

data/lib/oxaiworkers/tool/eval.rb

@@ -9,10 +9,13 @@ module OxAiWorkers
       include OxAiWorkers::DependencyHelper
       include OxAiWorkers::LoadI18n
 
-      def initialize(only: nil)
+      attr_accessor :current_dir
+
+      def initialize(only: nil, current_dir: nil)
         store_locale
 
         init_white_list_with only
+        @current_dir = current_dir
 
         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
@@ -25,20 +28,28 @@ module OxAiWorkers
 
       def ruby(input:)
         OxAiWorkers.logger.info("Executing ruby: \"#{input}\"", for: self.class)
-        eval(input)
+        execute_in_directory { eval(input) }
       end
 
       def sh(input:)
         OxAiWorkers.logger.info("Executing sh: \"#{input}\"", for: self.class)
-        begin
+        execute_in_directory do
           stdout_and_stderr_s, status = Open3.capture2e(input)
-          return stdout_and_stderr_s if stdout_and_stderr_s.present?
+          stdout_and_stderr_s.present? ? stdout_and_stderr_s : status.to_s
+        end
+      end
+
+      private
 
-          status.to_s
-        rescue StandardError => e
-          OxAiWorkers.logger.debug(e.message, for: self.class)
-          e.message
+      def execute_in_directory(&block)
+        if @current_dir.present?
+          Dir.chdir(@current_dir, &block)
+        else
+          yield
         end
+      rescue StandardError => e
+        OxAiWorkers.logger.debug(e.message, for: self.class)
+        e.message
       end
     end
   end

data/lib/oxaiworkers/tool/file_system.rb

@@ -15,7 +15,9 @@ module OxAiWorkers
       include OxAiWorkers::DependencyHelper
       include OxAiWorkers::LoadI18n
 
-      def initialize(only: nil)
+      attr_accessor :current_dir
+
+      def initialize(current_dir: nil, only: nil)
         depends_on 'ptools'
 
         store_locale
@@ -40,38 +42,51 @@ module OxAiWorkers
           property :content, type: 'string', description: I18n.t('oxaiworkers.tool.file_system.write_to_file.content'),
                              required: true
         end
+
+        @current_dir = current_dir
       end
 
       def list_directory(directory_path:)
-        OxAiWorkers.logger.info("Listing directory: #{directory_path}", for: self.class)
-        list = Dir.entries(directory_path)
+        path = full_path(directory_path)
+        OxAiWorkers.logger.info("Listing directory: #{path}", for: self.class)
+        list = Dir.entries(path)
         list.delete_if { |f| f.start_with?('.') }
         if list.present?
-          with_locale { "Contents of directory \"#{directory_path}\":\n #{list.join("\n")}" }
+          "Contents of directory \"#{path}\":\n #{list.join("\n")}"
         else
-          with_locale { "Directory is empty: #{directory_path}" }
+          "Directory is empty: #{path}"
         end
       rescue Errno::ENOENT
-        with_locale { "No such directory: #{directory_path}" }
+        "No such directory: #{path}"
       end
 
       def read_file(file_path:)
-        OxAiWorkers.logger.info("Reading file: #{file_path}", for: self.class)
-        if File.binary?(file_path)
-          with_locale { "File is binary: #{file_path}" }
+        path = full_path(file_path)
+        OxAiWorkers.logger.info("Reading file: #{path}", for: self.class)
+        if File.binary?(path)
+          "File is binary: #{path}"
         else
-          File.read(file_path).to_s
+          File.read(path).to_s
         end
       rescue Errno::ENOENT
-        with_locale { "No such file: #{file_path}" }
+        "No such 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)
-        with_locale { "Content was successfully written to the file: #{file_path}" }
+        path = full_path(file_path)
+        OxAiWorkers.logger.info("Writing to file: #{path}", for: self.class)
+        # Ensure directory exists if using current_dir
+        FileUtils.mkdir_p(File.dirname(path)) if @current_dir.present? && !Dir.exist?(File.dirname(path))
+        File.write(path, content)
+        "Content was successfully written to the file: #{path}"
       rescue Errno::EACCES
-        with_locale { "Permission denied: #{file_path}" }
+        "Permission denied: #{path}"
+      end
+
+      private
+
+      def full_path(path)
+        @current_dir.present? ? File.join(@current_dir, path) : path
       end
     end
   end

data/lib/oxaiworkers/tool/pipeline.rb

@@ -0,0 +1,106 @@
+module OxAiWorkers
+  module Tool
+    class Pipeline
+      include OxAiWorkers::ToolDefinition
+      include OxAiWorkers::DependencyHelper
+      include OxAiWorkers::LoadI18n
+
+      attr_accessor :assistants, :messages
+
+      def initialize(only: nil, on_message: nil)
+        store_locale
+
+        init_white_list_with only
+
+        define_function :send_message, description: I18n.t('oxaiworkers.tool.pipeline.send_message.description') do
+          property :message, type: 'string', description: I18n.t('oxaiworkers.tool.pipeline.send_message.message'),
+                             required: true
+          property :result, type: 'string', description: I18n.t('oxaiworkers.tool.pipeline.send_message.result'),
+                            required: true
+          property :example, type: 'string', description: I18n.t('oxaiworkers.tool.pipeline.send_message.example')
+          property :to_id, type: 'string', description: I18n.t('oxaiworkers.tool.pipeline.send_message.to_id'),
+                           required: true
+        end
+
+        @messages = []
+        @on_message = on_message
+      end
+
+      def send_message(message:, result:, example:, to_id:)
+        puts "send_message to #{to_id}: #{message}".colorize(:red)
+        puts " Result: #{result}"
+        puts " Example: #{example}"
+        context = context_for(to_id)
+        @assistants[to_id].replace_context(context)
+        @assistants[to_id].add_task message
+        @assistants[to_id].add_task "#{I18n.t('oxaiworkers.tool.pipeline.send_message.result')}: #{result}"
+        @assistants[to_id].add_task "#{I18n.t('oxaiworkers.tool.pipeline.send_message.example')}: #{example}"
+        @assistants[to_id].execute
+        nil
+      end
+
+      def add_assistant(assistant)
+        unless assistant.id.present? &&
+               assistant.title.present? &&
+               assistant.role.present? &&
+               assistant.description.present? &&
+               assistant.capabilities.present?
+          raise 'Assistant is not valid: id, title, role, description and capabilities are required'
+        end
+
+        assistant.iterator.on_inner_monologue = ->(text:) { recive_monologue(from_id: assistant.id, message: text) }
+        assistant.iterator.on_outer_voice = ->(text:) { recive_voice(from_id: assistant.id, message: text) }
+
+        @assistants ||= {}
+        @assistants[assistant.id] = assistant
+      end
+
+      def recive_monologue(from_id:, message:)
+        recive_message(id: from_id, type: 'monologue', message:, color: :yellow)
+      end
+
+      def recive_voice(from_id:, message:)
+        recive_message(id: from_id, type: 'voice', message:, color: :green)
+      end
+
+      def recive_message(id:, type:, message:, color: :grey)
+        puts "#{id} [#{type}]: #{message}".colorize(color)
+        @messages ||= []
+        m = { id:, type:, message: }
+        @messages << m
+        @on_message.call(text: format_message(m)) if !@on_message.nil? && @assistants.key?(id)
+        # @assistants.each_value do |assistant|
+        #   assistant.iterator.add_queue format_message(m), role: :system if assistant.id != id
+        # end
+      end
+
+      def context_for(id)
+        array = @messages.select { |message| message[:id] == id || message[:type] == 'voice' }
+        array.map { |m| format_message(m) }.join("\n\n")
+      end
+
+      def context
+        "#{assistants_info}\n\n#{@messages.map { |m| format_message(m) }.join("\n\n")}"
+      end
+
+      def assistants_info
+        @assistants.values.map { |assistant| format_assistant(assistant) }.join("\n\n")
+      end
+
+      def format_message(message)
+        "**#{message[:id]}**\n: #{message[:message]}"
+      end
+
+      def format_assistant(assistant)
+        with_locale do
+          I18n.t('oxaiworkers.tool.pipeline.assistant_info',
+                 id: assistant.id,
+                 title: assistant.title,
+                 role: assistant.role,
+                 description: assistant.description,
+                 capabilities: assistant.capabilities.join(', '))
+        end
+      end
+    end
+  end
+end

data/lib/oxaiworkers/tool/pixels.rb

@@ -0,0 +1,76 @@
+require 'fileutils'
+require 'open-uri'
+
+module OxAiWorkers
+  module Tool
+    class Pixels
+      include OxAiWorkers::ToolDefinition
+      include OxAiWorkers::DependencyHelper
+      include OxAiWorkers::LoadI18n
+
+      attr_accessor :worker, :url, :current_dir
+
+      def initialize(worker:, current_dir: nil, only: nil)
+        store_locale
+
+        init_white_list_with only
+
+        define_function :generate_image, description: I18n.t('oxaiworkers.tool.pixels.generate_image.description') do
+          property :prompt, type: 'string', description: I18n.t('oxaiworkers.tool.pixels.generate_image.prompt'),
+                            required: true
+          property :size, type: 'string', description: I18n.t('oxaiworkers.tool.pixels.generate_image.size'),
+                          enum: %w[1024x1792 1792x1024 1024x1024]
+          if current_dir.present?
+            property :file_name, type: 'string',
+                                 description: I18n.t('oxaiworkers.tool.pixels.generate_image.file_name'),
+                                 required: true
+          end
+          property :quality, type: 'string', description: I18n.t('oxaiworkers.tool.pixels.generate_image.quality'),
+                             enum: %w[standard hd]
+        end
+
+        @worker = worker
+        @current_dir = current_dir
+      end
+
+      def generate_image(prompt:, file_name: nil, size: '1024x1792', quality: 'standard')
+        puts "generate_image: #{prompt}"
+
+        response = @worker.client.images.generate(
+          parameters: {
+            prompt:,
+            model: 'dall-e-3',
+            size:,
+            quality:
+          }
+        )
+
+        @url = response.dig('data', 0, 'url')
+        revised_prompt = response.dig('data', 0, 'revised_prompt')
+        if file_name.present?
+          path = save_generated_image(file_name:)
+          "url: #{@url}\nfile_name: #{path}\n\nrevised_prompt: #{revised_prompt}"
+        else
+          "url: #{@url}\n\nrevised_prompt: #{revised_prompt}"
+        end
+      end
+
+      def save_generated_image(file_name:)
+        unless @current_dir.present?
+          return 'Current directory not set for OxAiWorkers::Tool::Pixels. Please set current directory first.'
+        end
+
+        # Ensure current_dir exists
+        FileUtils.mkdir_p(@current_dir) unless Dir.exist?(@current_dir)
+
+        path = File.join(@current_dir, file_name)
+
+        File.open(path, 'wb') do |file|
+          file.write(URI.open(@url).read)
+        end
+
+        file_name
+      end
+    end
+  end
+end

data/lib/oxaiworkers/version.rb

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

data/template/start

@@ -18,18 +18,16 @@ puts "OxAiWorkers #{OxAiWorkers::VERSION}"
 
 # Configure
 OxAiWorkers.configure do |config|
-  config.access_token = ENV.fetch('OPENAI')
-  config.model = 'gpt-4o-mini'
-  # config.auto_execute = false
+  config.access_token_openai = ENV.fetch('OPENAI')
 end
 
+OxAiWorkers.default_model = OxAiWorkers::Models::OpenaiMini.new
+
 # OxAiWorkers.logger.level = :debug
 
 # Main algorithm
 @assistant = MyAssistant.new
 @assistant.task = '2 + 2 is ?'
-
-# Uncomment this if auto_execute is false
-# @assistant.execute
+@assistant.execute
 
 IRB.start(__FILE__)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ox-ai-workers
 version: !ruby/object:Gem::Version
-  version: 0.8.6
+  version: 0.9.1
 platform: ruby
 authors:
 - Denis Smolev
@@ -143,14 +143,22 @@ files:
 - lib/oxaiworkers/assistant/coder.rb
 - lib/oxaiworkers/assistant/localizer.rb
 - lib/oxaiworkers/assistant/module_base.rb
+- lib/oxaiworkers/assistant/orchestrator.rb
+- lib/oxaiworkers/assistant/painter.rb
 - lib/oxaiworkers/assistant/sysop.rb
 - lib/oxaiworkers/compatibility.rb
 - lib/oxaiworkers/contextual_logger.rb
 - lib/oxaiworkers/delayed_request.rb
 - lib/oxaiworkers/dependency_helper.rb
 - lib/oxaiworkers/engine.rb
+- lib/oxaiworkers/image_iterator.rb
 - lib/oxaiworkers/iterator.rb
 - lib/oxaiworkers/load_i18n.rb
+- lib/oxaiworkers/models/deepseek_max.rb
+- lib/oxaiworkers/models/module_base.rb
+- lib/oxaiworkers/models/openai_max.rb
+- lib/oxaiworkers/models/openai_mini.rb
+- lib/oxaiworkers/models/openai_nano.rb
 - lib/oxaiworkers/module_request.rb
 - lib/oxaiworkers/present_compat.rb
 - lib/oxaiworkers/request.rb
@@ -161,6 +169,8 @@ files:
 - lib/oxaiworkers/tool/database.rb
 - lib/oxaiworkers/tool/eval.rb
 - lib/oxaiworkers/tool/file_system.rb
+- lib/oxaiworkers/tool/pipeline.rb
+- lib/oxaiworkers/tool/pixels.rb
 - lib/oxaiworkers/tool_definition.rb
 - lib/oxaiworkers/version.rb
 - lib/ruby/ox-ai-workers.rb