ox-ai-workers 0.1.0

data/lib/oxaiworkers/module_request.rb

@@ -0,0 +1,83 @@
+class OxAiWorkers::ModuleRequest
+  attr_accessor :result, :client, :messages, :model, :max_tokens, :custom_id, :temperature, :tools, :errors
+  attr_accessor :tool_calls_raw, :tool_calls
+  DEFAULT_MODEL = "gpt-4o-mini"
+  DEFAULT_MAX_TOKEN = 4096
+  DEFAULT_TEMPERATURE = 0.7
+
+  def initializeRequests(model: DEFAULT_MODEL, max_tokens: DEFAULT_MAX_TOKEN, temperature: DEFAULT_TEMPERATURE)
+    puts "call: ModuleRequest::#{__method__}"
+    @max_tokens = max_tokens
+    @custom_id = SecureRandom.uuid
+    @model = model
+    @temperature = 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
+
+    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 = []
+  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
+
+  def params
+    parameters = {
+        model: @model,
+        messages: @messages,
+        temperature: @temperature,
+        max_tokens: @max_tokens
+      }
+    if @tools.present?
+      parameters[:tools] = @tools
+      parameters[:tool_choice] = "required"
+    end
+    parameters
+  end
+
+  def not_found_is_ok &block
+    begin
+      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")
+
+    @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
+
+    # Assistant.send(function_name, **args)
+  end
+end

data/lib/oxaiworkers/present_compat.rb

@@ -0,0 +1,29 @@
+module OxAiWorkers
+	module PresentCompat
+		def present?
+			!self.nil? and !self.empty?
+		end
+	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

data/lib/oxaiworkers/request.rb

@@ -0,0 +1,23 @@
+class OxAiWorkers::Request < OxAiWorkers::ModuleRequest
+  alias_method :initialize, :initializeRequests 
+
+  def finish
+    @custom_id = SecureRandom.uuid
+    cleanup()
+  end
+
+  def request!
+    begin
+      response = @client.chat(parameters: params)
+      parseChoices(response)
+      #@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 @external_call.present?
+  end
+end

data/lib/oxaiworkers/state_batch.rb

@@ -0,0 +1,61 @@
+require 'state_machine/core'
+
+class OxAiWorkers::StateBatch < OxAiWorkers::ModuleRequest
+  include OxAiWorkers::StateHelper
+  extend StateMachine::MacroMethods
+
+  alias_method :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
+
+    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
+
+    event :end do
+      transition [:finished, :canceled] => :idle
+    end
+
+    event :prepare do
+      transition :idle => :prepared
+    end
+
+    event :process do
+      transition :prepared => :requested
+    end
+
+    event :complete do
+      transition [:requested, :failed] => :finished
+    end
+
+    event :cancel do
+      transition [:requested, :failed, :prepared] => :canceled
+    end
+
+    event :fail do
+      transition [:requested, :prepared] => :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 initialize
+    puts "call: StateBatch::#{__method__}"
+    super()
+  end
+end

data/lib/oxaiworkers/state_helper.rb

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

data/lib/oxaiworkers/state_tools.rb

@@ -0,0 +1,47 @@
+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
+
+    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
+
+end

data/lib/oxaiworkers/tool/eval.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module OxAiWorkers::Tool
+  #
+  # A calculator tool that falls back to the Google calculator widget
+  #
+  # Gem requirements:
+  #     gem "eqn", "~> 1.6.5"
+  #     gem "google_search_results", "~> 2.0.0"
+  #
+  # Usage:
+  #     calculator = OxAiWorkers::Tool::Calculator.new
+  #
+  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 :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 sh(input:)
+      puts Rainbow("Executing sh: \"#{input}\"").red
+      stdout_and_stderr_s, _ = Open3.capture2e(input)
+      return stdout_and_stderr_s
+    end
+  end
+end

data/lib/oxaiworkers/tool_definition.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "json"
+
+#
+# Extends a class to be used as a tool in the assistant.
+# A tool is a collection of functions (methods) used to perform specific tasks.
+#
+# == Usage
+#
+# 1. Extend your class with {OxAiWorkers::ToolDefinition}
+# 2. Use {#define_function} to define each function of the tool
+#
+# == Key Concepts
+#
+# - {#define_function}: Defines a new function (method) for the tool
+# - {ParameterBuilder#property}: Defines properties for the function parameters
+# - {ParameterBuilder#item}: Alias for {ParameterBuilder#property}, used for array items
+#
+# These methods support various data types and nested structures, allowing for flexible and expressive tool definitions.
+#
+# @example Defining a tool with various property types and configurations
+#   define_function :sample_function, description: "Demonstrates various property types and configurations" do
+#     property :string_prop, type: "string", description: "A simple string property"
+#     property :number_prop, type: "number", description: "A number property"
+#     property :integer_prop, type: "integer", description: "An integer property"
+#     property :boolean_prop, type: "boolean", description: "A boolean property"
+#     property :enum_prop, type: "string", description: "An enum property", enum: ["option1", "option2", "option3"]
+#     property :required_prop, type: "string", description: "A required property", required: true
+#     property :array_prop, type: "array", description: "An array property" do
+#       item type: "string", description: "Array item"
+#     end
+#     property :object_prop, type: "object", description: "An object property" do
+#       property :nested_string, type: "string", description: "Nested string property"
+#       property :nested_number, type: "number", description: "Nested number property"
+#     end
+#   end
+#
+module OxAiWorkers::ToolDefinition
+  # 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:, &)
+  end
+
+  # Returns the FunctionSchemas instance for this tool
+  #
+  # @return [FunctionSchemas] The FunctionSchemas instance
+  def function_schemas
+    @function_schemas ||= FunctionSchemas.new(tool_name)
+  end
+
+  # Returns the snake_case version of the class name as the tool's name
+  #
+  # @return [String] The snake_case version of the class name
+  def tool_name
+    @tool_name ||= name
+      .gsub("::", "_")
+      .gsub(/(?<=[A-Z])(?=[A-Z][a-z])|(?<=[a-z\d])(?=[A-Z])/, "_")
+      .downcase
+  end
+
+  # Manages schemas for functions
+  class FunctionSchemas
+    def initialize(tool_name)
+      @schemas = {}
+      @tool_name = tool_name
+    end
+
+    # Adds a function to the schemas
+    #
+    # @param method_name [Symbol] Name of the method to add
+    # @param description [String] Description of the function
+    # @yield Block that defines the parameters for the function
+    # @raise [ArgumentError] If a block is defined and no parameters are specified for the function
+    def add_function(method_name:, description:, &)
+      name = "#{@tool_name}__#{method_name}"
+
+      if block_given?
+        parameters = ParameterBuilder.new(parent_type: "object").build(&)
+
+        if parameters[:properties].empty?
+          raise ArgumentError, "Function parameters must have at least one property defined within it, if a block is provided"
+        end
+      end
+
+      @schemas[method_name] = {
+        type: "function",
+        function: {name:, description:, parameters:}.compact
+      }
+    end
+
+    # 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] }
+    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|
+        schema[:function].transform_keys("parameters" => "input_schema")
+      end
+    end
+
+    # 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] }
+    end
+  end
+
+  # Builds parameter schemas for functions
+  class ParameterBuilder
+    VALID_TYPES = %w[object array string number integer boolean].freeze
+
+    def initialize(parent_type:)
+      @schema = (parent_type == "object") ? {type: "object", properties: {}, required: []} : {}
+      @parent_type = parent_type
+    end
+
+    # Builds the parameter schema
+    #
+    # @yield Block that defines the properties of the schema
+    # @return [Hash] The built schema
+    def build(&)
+      instance_eval(&)
+      @schema
+    end
+
+    # Defines a property in the schema
+    #
+    # @param name [Symbol] Name of the property (required only for a parent of type object)
+    # @param type [String] Type of the property
+    # @param description [String] Description of the property
+    # @param enum [Array] Array of allowed values
+    # @param required [Boolean] Whether the property is required
+    # @yield [Block] Block for nested properties (only for object and array types)
+    # @raise [ArgumentError] If any parameter is invalid
+    def property(name = nil, type:, description: nil, enum: nil, required: false, &)
+      validate_parameters(name:, type:, enum:, required:)
+
+      prop = {type:, description:, enum:}.compact
+
+      if block_given?
+        nested_schema = ParameterBuilder.new(parent_type: type).build(&)
+
+        case type
+        when "object"
+          if nested_schema[:properties].empty?
+            raise ArgumentError, "Object properties must have at least one property defined within it"
+          end
+          prop = nested_schema
+        when "array"
+          if nested_schema.empty?
+            raise ArgumentError, "Array properties must have at least one item defined within it"
+          end
+          prop[:items] = nested_schema
+        end
+      end
+
+      if @parent_type == "object"
+        @schema[:properties][name] = prop
+        @schema[:required] << name.to_s if required
+      else
+        @schema = prop
+      end
+    end
+
+    # Alias for property method, used for defining array items
+    alias_method :item, :property
+
+    private
+
+    # Validates the parameters for a property
+    #
+    # @param name [Symbol] Name of the property
+    # @param type [String] Type of the property
+    # @param enum [Array] Array of allowed values
+    # @param required [Boolean] Whether the property is required
+    # @raise [ArgumentError] If any parameter is invalid
+    def validate_parameters(name:, type:, enum:, required:)
+      if @parent_type == "object"
+        if name.nil?
+          raise ArgumentError, "Name must be provided for properties of an object"
+        end
+        unless name.is_a?(Symbol)
+          raise ArgumentError, "Invalid name '#{name}'. Name must be a symbol"
+        end
+      end
+
+      unless VALID_TYPES.include?(type)
+        raise ArgumentError, "Invalid type '#{type}'. Valid types are: #{VALID_TYPES.join(", ")}"
+      end
+
+      unless enum.nil? || enum.is_a?(Array)
+        raise ArgumentError, "Invalid enum '#{enum}'. Enum must be nil or an array"
+      end
+
+      unless [true, false].include?(required)
+        raise ArgumentError, "Invalid required '#{required}'. Required must be a boolean"
+      end
+    end
+  end
+end

data/lib/oxaiworkers/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module OxAiWorkers
+  VERSION = "0.1.0"
+end
+

data/lib/ruby/ox-ai-workers.rb

@@ -0,0 +1,2 @@
+require_relative "../oxaiworkers"
+require_relative "../oxaiworkers/compatibility"

data/locales/en.system.yml

@@ -0,0 +1,35 @@
+en:
+  oxaiworkers:
+    iterator:
+      inner_monologue:
+        description: "Use inner monologue to plan the response and articulate main points"
+        speech: "Text"
+      outer_voice:
+        description: "Provide the user with necessary information without expecting a response"
+        text: "Text"
+      action_request:
+        description: "Ask a clarifying question or request an action with a response from the user"
+        action: "Text"
+      pack_history:
+        description: "Save facts, nuances, and actions before clearing messages"
+        text: "Listing important facts and nuances"
+      monologue:
+        steps:
+          - "Step 1: Develop your own solution to the problem. Take initiative and make assumptions."
+          - "Step 1.1: Wrap all your work for this step in the innerMonologue function."
+          - "Step 2: Relate your solution to the task, improve it, and call the necessary functions step by step."
+          - "Step 2.1: Interact with the user using the outerVoice and actionRequest functions during the process."
+          - "Step 3: When the solution is ready, report it using the outerVoice function."
+          - "Step 3.1: Save facts, nuances, and actions using the packHistory function."
+          - "Step 4: Conclude the work with the actionRequest function, without repeating the response if it was already given with outerVoice."
+    tool:
+      eval:
+        ruby:
+          description: "Execute Ruby code and return the result of the last expression"
+          input: "Ruby source code"
+        sh:
+          description: "Execute a sh command and get the result (stdout + stderr)"
+          input: "Source command"
+    assistant:
+      sysop:
+        role: "You are a software agent inside my computer"

data/locales/ru.system.yml

@@ -0,0 +1,34 @@
+ru:
+  oxaiworkers:
+    iterator:
+      inner_monologue:
+        description: Используй внутренний монолог для планирования ответа и проговаривания основных тезисов
+        speach: Текст
+      outer_voice:
+        description: Сообщить пользователю необходимую информацию без ожидания ответа
+        text: Текст
+      action_request:
+        description: Задать уточняющий вопрос или попросить о действии с получением ответа от пользователя
+        action: Текст
+      pack_history:
+        description: Сохранение фактов, нюансов и действий (в том числе что ответ был дан) перед очисткой сообщений
+        text: Перечисление важных фактов и нюансов
+      monologue:
+        - Шаг 1. Разработай собственное решение проблемы. Проявляй инициативу и делай предположения. 
+        - Шаг 1.1. Заключи все свои наработки для этого шага в функцию innerMonologue.
+        - Шаг 2. Соотнеси свое решение с задачей, улучшай его и вызывай необходимые функции шаг за шагом.
+        - Шаг 2.1. Во время работы используй функции outerVoice и actionRequest.
+        - Шаг 3. Когда решение готово, сообщи о нем с помощью функции outerVoice.
+        - Шаг 3.1. Сохрани факты, нюансы и действия с помощью функции packHistory.
+        - Шаг 4. Заверши работу с помощью функции actionRequest, не повторяя ответ, если он уже был дан.
+    tool:
+      eval:
+        ruby:
+          description: Выполнить код на ruby и вернуть результат последней строки
+          input: Исходный код на Ruby
+        sh:
+          description: Выполнить sh-команду и получить результат (stdout + stderr)
+          input: Исходная команда
+    assistant:
+      sysop:
+        role: Ты программный агент внутри моего компьютера