ox-ai-workers 0.8.7 → 0.9.1

data/config/locales/ru.oxaiworkers.tool.yml

@@ -29,4 +29,19 @@ ru:
           description: 'Инструмент базы данных: Возвращает схему базы данных'
         execute:
           description: 'Инструмент базы данных: Выполняет SQL-запрос и возвращает результаты'
-          input: 'SQL-запрос для выполнения'
+          input: 'SQL-запрос для выполнения'
+      pipeline:
+        send_message:
+          description: 'Отправить сообщение другому ассистенту'
+          message: 'Сообщение или задача для отправки'
+          result: 'Описание ожидаемого результата, что должно быть получено на выходе'
+          example: 'Пример хорошего результата'
+          to_id: 'ID ассистента получателя'
+        assistant_info: "ID: **%{id}**, Название: %{title}\nРоль: %{role}\nОписание: %{description}\nВозможности: %{capabilities}"
+      pixels:
+        generate_image:
+          description: 'Инструмент генерации изображений: Создает изображение на основе предоставленного текстового запроса. Если указать имя файла, изображение будет сохранено в формате png. В любом случае будет возвращен url изображения.'
+          prompt: 'Текстовое описание изображения для генерации'
+          size: 'Размер генерируемого изображения (1024x1792, 1792x1024, 1024x1024)'
+          quality: 'Качество генерируемого изображения (standard, hd)'
+          file_name: 'Имя файла для сохранения изображения в формате png. Например: image.png'

data/lib/ox-ai-workers.rb

@@ -20,21 +20,31 @@ require_relative 'oxaiworkers/state_batch'
 require_relative 'oxaiworkers/state_tools'
 require_relative 'oxaiworkers/delayed_request'
 require_relative 'oxaiworkers/iterator'
+require_relative 'oxaiworkers/image_iterator'
 require_relative 'oxaiworkers/request'
 
 require_relative 'oxaiworkers/tool/eval'
 require_relative 'oxaiworkers/tool/database'
 require_relative 'oxaiworkers/tool/file_system'
+require_relative 'oxaiworkers/tool/pipeline'
+require_relative 'oxaiworkers/tool/pixels'
 
 require_relative 'oxaiworkers/assistant/module_base'
 require_relative 'oxaiworkers/assistant/sysop'
 require_relative 'oxaiworkers/assistant/coder'
 require_relative 'oxaiworkers/assistant/localizer'
+require_relative 'oxaiworkers/assistant/orchestrator'
+require_relative 'oxaiworkers/assistant/painter'
+
+require_relative 'oxaiworkers/models/module_base'
+require_relative 'oxaiworkers/models/openai_max'
+require_relative 'oxaiworkers/models/openai_mini'
+require_relative 'oxaiworkers/models/openai_nano'
+require_relative 'oxaiworkers/models/deepseek_max'
 
 require_relative 'oxaiworkers/engine' if defined?(Rails)
 
 module OxAiWorkers
-  DEFAULT_MODEL = 'gpt-4o-mini'
   DEFAULT_MAX_TOKEN = 4096
   DEFAULT_TEMPERATURE = 0.7
 
@@ -42,16 +52,15 @@ module OxAiWorkers
   class ConfigurationError < Error; end
 
   class Configuration
-    attr_accessor :model, :max_tokens, :temperature, :access_token, :auto_execute, :wait_for_complete, :uri_base
+    attr_accessor :max_tokens, :temperature, :wait_for_complete, :access_token_deepseek, :access_token_openai
 
     def initialize
-      @access_token = nil
-      @model = DEFAULT_MODEL
       @max_tokens = DEFAULT_MAX_TOKEN
       @temperature = DEFAULT_TEMPERATURE
-      @auto_execute = true
       @wait_for_complete = true
-      @uri_base = nil
+
+      @access_token_deepseek = nil
+      @access_token_openai = nil
 
       [Array, NilClass, String, Symbol, Hash].each do |c|
         c.send(:include, OxAiWorkers::PresentCompat) unless c.method_defined?(:present?)
@@ -63,6 +72,7 @@ module OxAiWorkers
   class << self
     attr_writer :configuration
     attr_reader :logger
+    attr_accessor :default_model
 
     # @param logger [Logger]
     # @return [ContextualLogger]

data/lib/oxaiworkers/assistant/coder.rb

@@ -5,23 +5,31 @@ module OxAiWorkers
     class Coder
       include OxAiWorkers::Assistant::ModuleBase
 
-      def initialize(delayed: false, model: nil, language: 'ruby')
+      def initialize(current_dir: nil, delayed: false, model: nil, language: 'ruby')
         store_locale
+
+        with_locale do
+          @id = 'coder'
+          @role = format(I18n.t('oxaiworkers.assistant.coder.role'), language)
+          @description = I18n.t('oxaiworkers.assistant.coder.description')
+          @capabilities = I18n.t('oxaiworkers.assistant.coder.capabilities').split(',').map(&:strip)
+          @title = I18n.t('oxaiworkers.assistant.coder.title')
+        end
+
         @iterator = Iterator.new(
-          worker: init_worker(delayed: delayed, model: model),
-          role: format(I18n.t('oxaiworkers.assistant.coder.role'), language),
-          tools: [Tool::Eval.new, Tool::FileSystem.new],
+          worker: init_worker(delayed:, model:),
+          role: @role,
+          tools: [Tool::Eval.new(current_dir:), Tool::FileSystem.new(current_dir:)],
           locale: @locale,
           on_inner_monologue: ->(text:) { puts "monologue: #{text}".colorize(:yellow) },
-          on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) },
-          on_action_request: ->(text:) { puts "action: #{text}".colorize(:red) },
-          on_summarize: ->(text:) { puts "summary: #{text}".colorize(:blue) }
+          on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) }
         )
       end
 
       def language=(language)
         with_locale do
-          @iterator.role = format(I18n.t('oxaiworkers.assistant.coder.role'), language)
+          @role = format(I18n.t('oxaiworkers.assistant.coder.role'), language)
+          @iterator.role = @role
         end
       end
     end

data/lib/oxaiworkers/assistant/localizer.rb

@@ -5,22 +5,29 @@ module OxAiWorkers
     class Localizer
       include OxAiWorkers::Assistant::ModuleBase
 
-      def initialize(delayed: false, model: nil, language: 'русский', locale: :ru, source: 'english')
+      def initialize(delayed: false, model: nil, language: 'русский', locale: :ru, source: 'english', current_dir: nil)
         store_locale
+
+        with_locale do
+          @id = 'localizer'
+          @role = format(I18n.t('oxaiworkers.assistant.localizer.role'), source_lang: source)
+          @description = I18n.t('oxaiworkers.assistant.localizer.description')
+          @capabilities = I18n.t('oxaiworkers.assistant.localizer.capabilities').split(',').map(&:strip)
+          @title = I18n.t('oxaiworkers.assistant.localizer.title')
+        end
+
         @iterator = Iterator.new(
-          worker: init_worker(delayed: delayed, model: model),
-          role: format(I18n.t('oxaiworkers.assistant.localizer.role'), language),
-          tools: [Tool::Eval.new, Tool::FileSystem.new],
+          worker: init_worker(delayed:, model:),
+          role: @role,
+          tools: [Tool::Eval.new(current_dir:), Tool::FileSystem.new(current_dir:)],
           locale: @locale,
           on_inner_monologue: ->(text:) { puts "monologue: #{text}".colorize(:yellow) },
-          on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) },
-          on_action_request: ->(text:) { puts "action: #{text}".colorize(:red) },
-          on_summarize: ->(text:) { puts "summary: #{text}".colorize(:blue) }
+          on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) }
         )
-        @iterator.add_context(format(I18n.t('oxaiworkers.assistant.localizer.source'), source))
+        @iterator.add_context(format(I18n.t('oxaiworkers.assistant.localizer.source'), source_lang: source))
 
         @iterator.add_context(format(I18n.t('oxaiworkers.assistant.localizer.locale'),
-                                     language, locale))
+                                     target_lang: language, locale:))
       end
     end
   end

data/lib/oxaiworkers/assistant/module_base.rb

@@ -5,14 +5,14 @@ module OxAiWorkers
     module ModuleBase
       include OxAiWorkers::LoadI18n
 
-      attr_accessor :iterator
+      attr_accessor :iterator, :role, :description, :capabilities, :id, :title
 
       def task=(task)
         @iterator.cleanup
         @iterator.add_task task
       end
 
-      def add_response(text)
+      def add_task(text)
         @iterator.add_task text
       end
 
@@ -20,10 +20,19 @@ module OxAiWorkers
         @iterator.execute
       end
 
+      def run_task(text)
+        self.task = text
+        execute
+      end
+
       def init_worker(delayed: false, model: nil, on_stream: nil)
-        worker = delayed ? DelayedRequest.new : Request.new(on_stream:)
-        worker.model = model || OxAiWorkers.configuration.model
-        worker
+        model ||= OxAiWorkers.default_model
+        delayed ? DelayedRequest.new(model:) : Request.new(model:, on_stream:)
+      end
+
+      def replace_context(context)
+        @iterator.clear_context
+        @iterator.add_context context
       end
     end
   end

data/lib/oxaiworkers/assistant/orchestrator.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module OxAiWorkers
+  module Assistant
+    class Orchestrator
+      include OxAiWorkers::Assistant::ModuleBase
+
+      attr_accessor :workflow
+
+      def initialize(delayed: false, model: nil, role: nil, workflow: nil)
+        store_locale
+
+        @pipeline = Tool::Pipeline.new(
+          on_message: ->(text:) { @iterator.add_queue text, role: :system }
+        )
+
+        with_locale do
+          @id = 'orchestrator'
+          @role = role || I18n.t('oxaiworkers.assistant.orchestrator.role')
+          @description = I18n.t('oxaiworkers.assistant.orchestrator.description')
+          @capabilities = I18n.t('oxaiworkers.assistant.orchestrator.capabilities').split(',').map(&:strip)
+          @title = I18n.t('oxaiworkers.assistant.orchestrator.title')
+          @workflow = I18n.t('oxaiworkers.assistant.orchestrator.workflow_task',
+                             workflow_description: workflow)
+        end
+
+        @iterator = Iterator.new(
+          worker: init_worker(delayed:, model:),
+          role: @role,
+          tools: [@pipeline],
+          locale: @locale,
+          on_inner_monologue: ->(text:) { @pipeline.recive_monologue(from_id: @id, message: text) },
+          on_outer_voice: ->(text:) { @pipeline.recive_voice(from_id: @id, message: text) }
+        )
+
+        @iterator.add_task @workflow
+      end
+
+      def add_assistant(assistant)
+        @pipeline.add_assistant(assistant)
+      end
+    end
+  end
+end

data/lib/oxaiworkers/assistant/painter.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module OxAiWorkers
+  module Assistant
+    class Painter
+      include OxAiWorkers::Assistant::ModuleBase
+
+      def initialize(current_dir: nil, delayed: false, model: nil)
+        store_locale
+        @current_dir = current_dir
+
+        with_locale do
+          @id = 'painter'
+          @role = I18n.t('oxaiworkers.assistant.painter.role')
+          @description = I18n.t('oxaiworkers.assistant.painter.description')
+          @capabilities = I18n.t('oxaiworkers.assistant.painter.capabilities').split(',').map(&:strip)
+          @title = I18n.t('oxaiworkers.assistant.painter.title')
+        end
+
+        @iterator = Iterator.new(
+          worker: init_worker(delayed:, model:),
+          role: @role,
+          tools: [Tool::Pixels.new(worker: init_worker(delayed: false, model:), current_dir:)],
+          locale: @locale,
+          on_inner_monologue: ->(text:) { puts "monologue: #{text}".colorize(:yellow) },
+          on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) }
+        )
+      end
+
+      def cleanup
+        Dir.glob(File.join(@current_dir, '*.png')).each do |file|
+          File.delete(file) if File.exist?(file)
+        end
+      end
+    end
+  end
+end

data/lib/oxaiworkers/assistant/sysop.rb

@@ -5,17 +5,25 @@ module OxAiWorkers
     class Sysop
       include OxAiWorkers::Assistant::ModuleBase
 
-      def initialize(delayed: false, model: nil)
+      def initialize(current_dir: nil, delayed: false, model: nil)
         store_locale
+
+        with_locale do
+          @id = 'sysop'
+          @role = I18n.t('oxaiworkers.assistant.sysop.role')
+          @description = I18n.t('oxaiworkers.assistant.sysop.description')
+          @capabilities = I18n.t('oxaiworkers.assistant.sysop.capabilities').split(',').map(&:strip)
+          @title = I18n.t('oxaiworkers.assistant.sysop.title')
+        end
+
         @iterator = Iterator.new(
-          worker: init_worker(delayed: delayed, model: model),
-          role: I18n.t('oxaiworkers.assistant.sysop.role'),
-          tools: [Tool::Eval.new(only: :sh), Tool::FileSystem.new(only: %i[read_file write_to_file])],
+          worker: init_worker(delayed:, model:),
+          role: @role,
+          tools: [Tool::Eval.new(only: :sh, current_dir:),
+                  Tool::FileSystem.new(only: %i[read_file write_to_file], current_dir:)],
           locale: @locale,
           on_inner_monologue: ->(text:) { puts "monologue: #{text}".colorize(:yellow) },
-          on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) },
-          on_action_request: ->(text:) { puts "action: #{text}".colorize(:red) },
-          on_summarize: ->(text:) { puts "summary: #{text}".colorize(:blue) }
+          on_outer_voice: ->(text:) { puts "voice: #{text}".colorize(:green) }
         )
       end
     end

data/lib/oxaiworkers/delayed_request.rb

@@ -2,8 +2,8 @@
 
 module OxAiWorkers
   class DelayedRequest < OxAiWorkers::StateBatch
-    def initialize(batch_id: nil, model: nil, max_tokens: nil, temperature: nil, uri_base: nil)
-      initialize_requests(model:, max_tokens:, temperature:, uri_base:)
+    def initialize(model:, batch_id: nil)
+      initialize_requests(model:)
       @custom_id = nil if batch_id.present?
       @batch_id = batch_id
       @file_id = nil

data/lib/oxaiworkers/image_iterator.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module OxAiWorkers
+  class ImageIterator
+    attr_accessor :worker, :on_inner_monologue, :on_outer_voice, :on_finish, :task
+
+    def initialize(worker:, on_inner_monologue: nil, on_outer_voice: nil, on_finish: nil)
+      @worker = worker
+      @on_inner_monologue = on_inner_monologue
+      @on_outer_voice = on_outer_voice
+      @on_finish = on_finish
+    end
+
+    def execute
+      response = @worker.client.images.generate(
+        parameters: {
+          prompt: @task,
+          model: 'dall-e-3',
+          size: '1024x1792',
+          quality: 'standard'
+        }
+      )
+
+      url = response.dig('data', 0, 'url')
+      puts url
+      puts response.inspect
+      @on_inner_monologue&.call(text: I18n.t('oxaiworkers.iterator.image_iterator.url', url:))
+      @on_outer_voice&.call(text: url)
+      @on_finish&.call(result: url)
+      response
+    end
+
+    def cleanup
+      @worker.cleanup
+    end
+
+    def add_task(task)
+      @task = task
+    end
+  end
+end

data/lib/oxaiworkers/iterator.rb

@@ -2,16 +2,16 @@
 
 module OxAiWorkers
   class Iterator < OxAiWorkers::StateTools
-    ITERATOR_FUNCTIONS = %i[inner_monologue outer_voice action_request summarize finish_it].freeze
+    ITERATOR_FUNCTIONS = %i[inner_monologue outer_voice finish_it].freeze
 
     include OxAiWorkers::ToolDefinition
     include OxAiWorkers::LoadI18n
 
-    attr_accessor :worker, :role, :messages, :context, :result, :tools, :queue, :monologue, :tasks, :milestones,
-                  :on_inner_monologue, :on_outer_voice, :on_action_request, :on_summarize, :on_finish, :def_except, :def_only
+    attr_accessor :worker, :role, :messages, :context, :tools, :queue, :monologue, :tasks,
+                  :on_inner_monologue, :on_outer_voice, :on_finish, :def_except, :def_only
 
-    def initialize(worker:, role: nil, tools: [], on_inner_monologue: nil, on_outer_voice: nil, on_action_request: nil,
-                   on_summarize: nil, on_finish: nil, steps: nil, def_except: [], def_only: nil, locale: nil)
+    def initialize(worker:, role: nil, tools: [], on_inner_monologue: nil, on_outer_voice: nil,
+                   on_finish: nil, steps: nil, def_except: [], def_only: nil, locale: nil)
 
       @locale = locale || I18n.locale
 
@@ -25,15 +25,6 @@ module OxAiWorkers
           property :text, type: 'string', description: I18n.t('oxaiworkers.iterator.outer_voice.text'), required: true
         end
 
-        define_function :action_request, description: I18n.t('oxaiworkers.iterator.action_request.description') do
-          property :action, type: 'string', description: I18n.t('oxaiworkers.iterator.action_request.action'),
-                            required: true
-        end
-
-        define_function :summarize, description: I18n.t('oxaiworkers.iterator.summarize.description') do
-          property :text, type: 'string', description: I18n.t('oxaiworkers.iterator.summarize.text'), required: true
-        end
-
         define_function :finish_it, description: I18n.t('oxaiworkers.iterator.finish_it.description')
 
         @monologue = steps || I18n.t('oxaiworkers.iterator.monologue')
@@ -48,8 +39,6 @@ module OxAiWorkers
 
       @on_inner_monologue = on_inner_monologue
       @on_outer_voice = on_outer_voice
-      @on_action_request = on_action_request
-      @on_summarize = on_summarize
       @on_finish = on_finish
 
       cleanup
@@ -65,10 +54,8 @@ module OxAiWorkers
     # Returns nothing.
     #
     def cleanup
-      @result = nil
       @queue = []
       @tasks = []
-      @milestones = []
       @messages = []
       complete_iteration
     end
@@ -79,26 +66,24 @@ module OxAiWorkers
     #
     # @return [nil] This method does not return a value.
     def inner_monologue(speach:)
-      # @queue.pop
-      @queue << { role: :assistant, content: speach.to_s }
-      @on_inner_monologue&.call(text: speach)
+      if available_defs.include?(:inner_monologue)
+        @queue << { role: :assistant, content: speach.to_s }
+        @on_inner_monologue&.call(text: speach)
+      else
+        OxAiWorkers.logger.warn "Iterator::inner_monologue is not available: #{speach}"
+      end
       nil
     end
 
     def outer_voice(text:)
-      # @queue.pop
-      @queue << { role: :assistant, content: text.to_s }
-      complete! unless available_defs.include?(:action_request)
-      @on_outer_voice&.call(text:)
-      nil
-    end
+      if available_defs.include?(:outer_voice)
+        @queue << { role: :assistant, content: text.to_s }
+        @on_outer_voice&.call(text:)
+      else
+        OxAiWorkers.logger.warn "Iterator::outer_voice is not available: #{text}"
+        inner_monologue(speach: text)
+      end
 
-    def action_request(action:)
-      @result = action
-      # @queue.pop
-      @messages << { role: :assistant, content: action.to_s }
-      complete! if can_complete?
-      @on_action_request&.call(text: action)
       nil
     end
 
@@ -108,19 +93,6 @@ module OxAiWorkers
       nil
     end
 
-    def summarize(text:)
-      @milestones << text.to_s
-      @messages = []
-      with_locale do
-        @queue << { role: :assistant, content: I18n.t('oxaiworkers.iterator.summarize.result') }
-      end
-      @worker.finish
-      rebuild_worker
-      complete! if can_complete?
-      @on_summarize&.call(text:)
-      nil
-    end
-
     def init
       rebuild_worker
       request!
@@ -129,12 +101,15 @@ module OxAiWorkers
     def rebuild_worker
       @worker.messages = []
       @worker.append(role: :system, content: @role) if @role.present?
+
       @tasks.each { |task| @worker.append(role: :user, content: task) }
       @worker.append(role: :system, content: valid_monologue.join("\n"))
       @worker.append(messages: @context) if @context.present?
-      @milestones.each { |milestone| @worker.append(role: :assistant, content: milestone) }
-      @tasks.each { |task| @worker.append(role: :user, content: task) }
+      @tools.each do |tool|
+        @worker.append(role: :user, content: tool.context) if tool.respond_to?(:context) && tool.context.present?
+      end
       @worker.append(messages: @messages)
+      @tasks.each { |task| @worker.append(role: :user, content: task) }
       @worker.tools = function_schemas.to_openai_format(only: available_defs)
       return unless @tools.present?
 
@@ -222,7 +197,6 @@ module OxAiWorkers
         return
       end
 
-      @result = @worker.result || @worker.errors
       if @worker.tool_calls.present?
         @queue << { role: :assistant, content: @worker.tool_calls_raw.to_s }
         @worker.tool_calls.each do |external_call|
@@ -239,9 +213,9 @@ module OxAiWorkers
         end
         @worker.finish
         iterate! if can_iterate?
-      elsif @worker.result.present?
-        action_request action: @worker.result
       end
+      result = @worker.result || @worker.errors
+      outer_voice text: result if result.present?
     end
 
     def complete_iteration
@@ -251,8 +225,10 @@ module OxAiWorkers
 
     def add_task(task)
       @tasks << task
-      @messages << { role: :user, content: task }
-      execute if OxAiWorkers.configuration.auto_execute
+    end
+
+    def add_queue(text, role: :assistant)
+      @queue << { role:, content: text }
     end
 
     def add_context(text, role: :system)
@@ -263,6 +239,10 @@ module OxAiWorkers
       @context << c
     end
 
+    def clear_context
+      @context = []
+    end
+
     def execute
       prepare! if valid?
     end
@@ -272,7 +252,7 @@ module OxAiWorkers
     end
 
     def valid?
-      @messages.present? || @milestones.present?
+      @messages.present? || @tasks.present?
     end
   end
 end

data/lib/oxaiworkers/models/deepseek_max.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module OxAiWorkers
+  module Models
+    class DeepseekMax
+      include OxAiWorkers::Models::ModuleBase
+
+      def initialize(uri_base: nil, api_key: nil, model: nil, max_tokens: nil, temperature: nil)
+        @model = model || 'deepseek-chat'
+        @uri_base = uri_base || 'https://api.deepseek.com/'
+        @api_key = api_key || OxAiWorkers.configuration.access_token_deepseek
+        super(uri_base: @uri_base, api_key: @api_key, model: @model, max_tokens:, temperature:)
+      end
+    end
+  end
+end

data/lib/oxaiworkers/models/module_base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module OxAiWorkers
+  module Models
+    module ModuleBase
+      attr_accessor :uri_base, :api_key, :model, :max_tokens, :temperature
+
+      def initialize(uri_base:, api_key:, model:, max_tokens: nil, temperature: nil)
+        @max_tokens = max_tokens || OxAiWorkers.configuration.max_tokens
+        @temperature = temperature || OxAiWorkers.configuration.temperature
+        @api_key = api_key
+        @uri_base = uri_base
+        @model = model
+      end
+    end
+  end
+end

data/lib/oxaiworkers/models/openai_max.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module OxAiWorkers
+  module Models
+    class OpenaiMax
+      include OxAiWorkers::Models::ModuleBase
+
+      def initialize(uri_base: nil, api_key: nil, model: nil, max_tokens: nil, temperature: nil)
+        @model = model || 'gpt-4.1'
+        @api_key = api_key || OxAiWorkers.configuration.access_token_openai
+        super(uri_base:, api_key: @api_key, model: @model, max_tokens:, temperature:)
+      end
+    end
+  end
+end

data/lib/oxaiworkers/models/openai_mini.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module OxAiWorkers
+  module Models
+    class OpenaiMini < OpenaiMax
+      def initialize(uri_base: nil, api_key: nil, model: nil, max_tokens: nil, temperature: nil)
+        @model = model || 'gpt-4.1-mini'
+        super(uri_base:, api_key:, model: @model, max_tokens:, temperature:)
+      end
+    end
+  end
+end

data/lib/oxaiworkers/models/openai_nano.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module OxAiWorkers
+  module Models
+    class OpenaiNano < OpenaiMax
+      def initialize(uri_base: nil, api_key: nil, model: nil, max_tokens: nil, temperature: nil)
+        @model = model || 'gpt-4.1-nano'
+        super(uri_base:, api_key:, model: @model, max_tokens:, temperature:)
+      end
+    end
+  end
+end