rails_console_ai 0.29.0 → 0.31.0

data/lib/rails_console_ai/agent_loader.rb

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'rails_console_ai/storage/database_storage'
 
 module RailsConsoleAi
   class AgentLoader
@@ -9,21 +10,32 @@ module RailsConsoleAi
       @storage = storage || RailsConsoleAi.storage
     end
 
+    # Three-source union: DB > file > built-in.
+    # Each record is tagged with `source: :db | :file | :builtin`. DB records
+    # also carry `status`, `approved_by`, `approved_at`. Proposed (unapproved)
+    # DB agents are surfaced here so the admin UI can render them — use
+    # #load_activatable_agents on AI-facing paths to filter them out.
     def load_all_agents
-      agents = load_builtin_agents
-      app_agents = load_app_agents
-      # App-specific agents override built-ins with the same name
-      app_names = app_agents.map { |a| a['name'].to_s.downcase }.to_set
-      agents.reject! { |a| app_names.include?(a['name'].to_s.downcase) }
-      agents.concat(app_agents)
-      agents
-    rescue => e
-      RailsConsoleAi.logger.warn("RailsConsoleAi: failed to load agents: #{e.message}")
-      []
+      db      = safe_load_db_agents
+      file    = safe_load_file_agents
+      builtin = safe_load_builtin_agents
+
+      db_names = db.map { |a| a['name'].to_s.downcase }
+      file.reject! { |a| db_names.include?(a['name'].to_s.downcase) }
+
+      file_names = file.map { |a| a['name'].to_s.downcase }
+      builtin.reject! { |a| db_names.include?(a['name'].to_s.downcase) || file_names.include?(a['name'].to_s.downcase) }
+
+      (db + file + builtin).sort_by { |a| a['name'].to_s.downcase }
+    end
+
+    # AI-facing: hides proposed DB agents. File + built-in are pre-approved.
+    def load_activatable_agents
+      load_all_agents.reject { |a| a['source'] == :db && a['status'] != 'approved' }
     end
 
     def agent_summaries
-      agents = load_all_agents
+      agents = load_activatable_agents
       return nil if agents.empty?
 
       agents.map { |a|
@@ -31,45 +43,79 @@ module RailsConsoleAi
       }
     end
 
+    # AI-facing — returns nil for proposed DB agents so delegate_task can't reach them.
     def find_agent(name)
-      agents = load_all_agents
-      agents.find { |a| a['name'].to_s.downcase == name.to_s.downcase }
+      load_activatable_agents.find { |a| a['name'].to_s.downcase == name.to_s.downcase }
     end
 
-    def save_agent(name:, description:, body:, max_rounds: nil, model: nil, tools: nil)
-      key = agent_key(name)
-      existing = find_agent(name)
-
-      frontmatter = {
-        'name' => name,
-        'description' => description
-      }
-      frontmatter['max_rounds'] = max_rounds if max_rounds
-      frontmatter['model'] = model if model
-      frontmatter['tools'] = Array(tools) if tools && !tools.empty?
+    # UI-facing — includes proposed DB agents.
+    def find_any_agent(name)
+      load_all_agents.find { |a| a['name'].to_s.downcase == name.to_s.downcase }
+    end
 
-      content = "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{body}\n"
-      @storage.write(key, content)
+    # target: :db (default) | :file
+    # Falls back to :file (with a notice in the return string) if DB tables aren't set up.
+    def save_agent(name:, description:, body:, max_rounds: nil, model: nil, tools: nil, target: :db, edited_by: nil, change_note: nil)
+      target = (target || :db).to_sym
+      db_fell_back = false
+      if target == :db && !Storage::DatabaseStorage.agents_available?
+        target = :file
+        db_fell_back = true
+      end
 
-      path = @storage.respond_to?(:root_path) ? File.join(@storage.root_path, key) : key
-      if existing
-        "Agent updated: \"#{name}\" (#{path})"
+      if target == :file
+        result = save_agent_to_file(
+          name: name, description: description, body: body,
+          max_rounds: max_rounds, model: model, tools: tools
+        )
+        if db_fell_back
+          result += "\nNOTE: DB storage was requested but the rails_console_ai_agents table does not exist. " \
+                    "Run `ai_db_setup` in your Rails console to enable the versioned DB store. " \
+                    "Saved to a file instead."
+        end
+        result
       else
-        "Agent created: \"#{name}\" (#{path})"
+        record, was_new = Storage::DatabaseStorage.save_agent(
+          name: name, description: description, body: body,
+          max_rounds: max_rounds, model: model, tools: Array(tools),
+          edited_by: edited_by || 'ai', change_note: change_note
+        )
+        status_note = if record.respond_to?(:proposed?) && record.proposed?
+                        ' — status: PROPOSED. A human must approve it at /rails_console_ai/agents before delegate_task can invoke it.'
+                      else
+                        ''
+                      end
+        if was_new
+          "Agent created (db): \"#{record.name}\" (id=#{record.id})#{status_note}"
+        else
+          "Agent updated (db): \"#{record.name}\" (id=#{record.id})#{status_note}"
+        end
       end
-    rescue Storage::StorageError => e
+    rescue Storage::StorageError, ::ActiveRecord::RecordInvalid => e
       "FAILED to save agent (#{e.message})."
     end
 
+    # Tries DB first, then file. Built-in agents can't be deleted.
     def delete_agent(name:)
+      if Storage::DatabaseStorage.delete_agent_by_name(name)
+        return "Agent deleted (db): \"#{name}\""
+      end
+
+      # Built-in agents are gem-shipped and not deletable.
+      builtin = safe_load_builtin_agents.find { |a| a['name'].to_s.downcase == name.to_s.downcase }
+      if builtin
+        return "Cannot delete built-in agent \"#{builtin['name']}\". Built-in agents ship with the gem. " \
+               "Create a same-named DB agent to override it instead."
+      end
+
       key = agent_key(name)
       unless @storage.exists?(key)
-        found = load_all_agents.find { |a| a['name'].to_s.downcase == name.to_s.downcase }
+        found = safe_load_file_agents.find { |a| a['name'].to_s.downcase == name.to_s.downcase }
         return "No agent found: \"#{name}\"" unless found
         key = agent_key(found['name'])
       end
 
-      agent = load_agent(key)
+      agent = load_agent_file(key)
       @storage.delete(key)
       "Agent deleted: \"#{agent ? agent['name'] : name}\""
     rescue Storage::StorageError => e
@@ -78,24 +124,53 @@ module RailsConsoleAi
 
     private
 
-    def load_builtin_agents
+    def safe_load_db_agents
+      Storage::DatabaseStorage.all_agents
+    end
+
+    def safe_load_file_agents
+      keys = @storage.list("#{AGENTS_DIR}/*.md")
+      keys.filter_map { |key|
+        agent = load_agent_file(key)
+        next nil unless agent
+        agent.merge('source' => :file, 'file_key' => key)
+      }
+    rescue => e
+      RailsConsoleAi.logger.warn("RailsConsoleAi: failed to load file agents: #{e.message}")
+      []
+    end
+
+    def safe_load_builtin_agents
       return [] unless File.directory?(BUILTIN_DIR)
       Dir.glob(File.join(BUILTIN_DIR, '*.md')).sort.filter_map do |path|
-        content = File.read(path)
+        # Explicit UTF-8 — File.read defaults to the locale encoding, which on
+        # some CI / spec setups is US-ASCII and chokes on em-dashes etc.
+        content = File.read(path, encoding: 'UTF-8')
         agent = parse_agent(content)
-        agent['builtin'] = true if agent
-        agent
+        next nil unless agent
+        agent.merge('source' => :builtin, 'builtin' => true, 'file_key' => path)
       end
     rescue => e
       RailsConsoleAi.logger.debug("RailsConsoleAi: failed to load built-in agents: #{e.message}")
       []
     end
 
-    def load_app_agents
-      keys = @storage.list("#{AGENTS_DIR}/*.md")
-      keys.filter_map { |key| load_agent(key) }
-    rescue => e
-      []
+    def save_agent_to_file(name:, description:, body:, max_rounds:, model:, tools:)
+      key = agent_key(name)
+      existing = load_agent_file(key)
+
+      content = self.class.dump(
+        name: name, description: description, body: body,
+        max_rounds: max_rounds, model: model, tools: tools
+      )
+      @storage.write(key, content)
+
+      path = @storage.respond_to?(:root_path) ? File.join(@storage.root_path, key) : key
+      if existing
+        "Agent updated: \"#{name}\" (#{path})"
+      else
+        "Agent created: \"#{name}\" (#{path})"
+      end
     end
 
     def agent_key(name)
@@ -107,7 +182,7 @@ module RailsConsoleAi
       "#{AGENTS_DIR}/#{slug}.md"
     end
 
-    def load_agent(key)
+    def load_agent_file(key)
       content = @storage.read(key)
       return nil if content.nil? || content.strip.empty?
       parse_agent(content)
@@ -117,10 +192,31 @@ module RailsConsoleAi
     end
 
     def parse_agent(content)
+      self.class.parse(content)
+    end
+
+    # Public: parse a raw .md (YAML frontmatter + body) string into a hash.
+    def self.parse(content)
       return nil unless content =~ /\A---\s*\n(.*?\n)---\s*\n(.*)/m
       frontmatter = YAML.safe_load($1, permitted_classes: [Time, Date]) || {}
       body = $2.strip
       frontmatter.merge('body' => body)
+    rescue Psych::SyntaxError
+      nil
+    end
+
+    # Inverse of parse: emit a canonical .md (frontmatter + body) string from
+    # structured attrs.
+    def self.dump(name:, description:, body:, max_rounds: nil, model: nil, tools: nil)
+      frontmatter = {
+        'name' => name,
+        'description' => description
+      }
+      frontmatter['max_rounds'] = max_rounds if max_rounds
+      frontmatter['model'] = model if model
+      tool_list = Array(tools)
+      frontmatter['tools'] = tool_list unless tool_list.empty?
+      "---\n#{YAML.dump(frontmatter).sub("---\n", '').strip}\n---\n\n#{body}\n"
     end
   end
 end

data/lib/rails_console_ai/agent_runner.rb

@@ -0,0 +1,209 @@
+require 'json'
+require 'rails_console_ai/prefixed_io'
+require 'rails_console_ai/session_logger'
+require 'rails_console_ai/channel/api'
+require 'rails_console_ai/conversation_engine'
+require 'rails_console_ai/context_builder'
+require 'rails_console_ai/providers/base'
+require 'rails_console_ai/executor'
+
+module RailsConsoleAi
+  class RunnerTimeoutError < StandardError; end
+
+  # Long-running worker that polls the sessions table for queued agent_api
+  # rows, claims them atomically, and runs each in its own Thread via
+  # ConversationEngine#one_shot. Started by `rake rails_console_ai:agents`.
+  class AgentRunner
+    POLL_INTERVAL = 2.0
+    DEFAULT_CONCURRENCY = 3
+    DRAIN_TIMEOUT = 60
+
+    def initialize(concurrency: DEFAULT_CONCURRENCY, poll_interval: POLL_INTERVAL)
+      @concurrency = concurrency
+      @poll_interval = poll_interval
+      @threads = {}      # session_id => Thread
+      @mutex = Mutex.new
+      @stopping = false
+    end
+
+    def start
+      $stdout.sync = true
+      $stderr.sync = true
+      $stdout = RailsConsoleAi::PrefixedIO.new($stdout) unless $stdout.is_a?(RailsConsoleAi::PrefixedIO)
+      $stderr = RailsConsoleAi::PrefixedIO.new($stderr) unless $stderr.is_a?(RailsConsoleAi::PrefixedIO)
+
+      install_signal_handlers
+      puts "AgentRunner starting (concurrency=#{@concurrency}, poll=#{@poll_interval}s)"
+      loop do
+        break if @stopping
+        reap_finished
+        fill_slots
+        sleep @poll_interval
+      end
+      drain
+      puts "AgentRunner stopped."
+    end
+
+    private
+
+    def install_signal_handlers
+      %w[INT TERM].each do |sig|
+        Signal.trap(sig) { @stopping = true }
+      end
+    end
+
+    def reap_finished
+      @mutex.synchronize { @threads.reject! { |_, t| !t.alive? } }
+    end
+
+    def slots_available
+      @concurrency - @mutex.synchronize { @threads.size }
+    end
+
+    def fill_slots
+      slots = slots_available
+      return if slots <= 0
+      claim_next(slots).each { |session| spawn(session) }
+    rescue => e
+      warn "AgentRunner fill_slots failed: #{e.class}: #{e.message}"
+    end
+
+    # Returns up to `limit` Session records the runner exclusively owns.
+    # Atomic claim: only the runner whose UPDATE flips the row from
+    # 'queued' to 'running' may execute it.
+    def claim_next(limit)
+      candidates = Session.where(mode: 'agent_api', status: 'queued')
+                          .order(:created_at)
+                          .limit(limit)
+                          .pluck(:id)
+      claimed = []
+      candidates.each do |id|
+        n = Session.where(id: id, status: 'queued', mode: 'agent_api')
+                   .update_all(status: 'running')
+        claimed << Session.find(id) if n == 1
+      end
+      claimed
+    rescue => e
+      warn "AgentRunner claim failed: #{e.class}: #{e.message}"
+      []
+    end
+
+    def spawn(session)
+      tag = "[agent/#{session.id}] @#{session.user_name || '?'}"
+      opts = parse_options(session)
+      banner_extras = []
+      banner_extras << 'thinking' if opts['use_thinking_model']
+      if (cap = opts['max_wall_clock_seconds'])
+        banner_extras << "cap=#{cap}s"
+      end
+      banner = banner_extras.empty? ? '' : " (#{banner_extras.join(', ')})"
+      puts "#{tag}#{banner} << #{session.query.to_s.strip}"
+
+      t = Thread.new do
+        Thread.current.report_on_exception = false
+        Thread.current[:log_prefix] = tag
+        begin
+          run_one(session, opts)
+        ensure
+          ActiveRecord::Base.clear_active_connections! if defined?(ActiveRecord::Base)
+        end
+      end
+      @mutex.synchronize { @threads[session.id] = t }
+    end
+
+    def parse_options(session)
+      raw = session.respond_to?(:options) ? session.options : nil
+      return {} if raw.nil? || raw.to_s.empty?
+      return raw if raw.is_a?(Hash)
+      JSON.parse(raw)
+    rescue => e
+      warn "AgentRunner: failed to parse session.options (#{e.class}: #{e.message}); ignoring."
+      {}
+    end
+
+    def run_one(session, opts = nil)
+      opts ||= parse_options(session)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      channel = Channel::Api.new(user_name: session.user_name)
+      sandbox_binding = Object.new.instance_eval { binding }
+      engine = ConversationEngine.new(binding_context: sandbox_binding, channel: channel)
+      engine.upgrade_to_thinking_model if opts['use_thinking_model']
+
+      exec_result = run_with_deadline(opts['max_wall_clock_seconds']) do
+        engine.one_shot(session.query, existing_session_id: session.id)
+      end
+      result_text = compose_result(channel.captured_output, exec_result)
+
+      SessionLogger.update(session.id, status: 'ready', result: result_text)
+
+      elapsed = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - started) * 1000).round
+      preview = result_text.to_s.strip.lines.first.to_s.strip
+      preview = preview[0, 120] + '…' if preview.length > 120
+      puts ">> ready (#{elapsed}ms) #{preview}"
+    rescue RunnerTimeoutError => e
+      warn ">> TIMEOUT #{e.message}"
+      SessionLogger.update(session.id, status: 'failed', error_message: e.message)
+    rescue => e
+      warn ">> FAILED #{e.class}: #{e.message}"
+      e.backtrace&.first(5)&.each { |line| warn "   #{line}" }
+      SessionLogger.update(session.id,
+        status: 'failed',
+        error_message: "#{e.class}: #{e.message}\n#{Array(e.backtrace).first(10).join("\n")}"
+      )
+    end
+
+    # When cap is nil or non-positive, run inline. Otherwise spawn a nested
+    # worker thread, join with the deadline, and kill + raise on overshoot.
+    # Kept localized (vs Timeout.timeout) so a runaway provider call can't
+    # raise from inside our own bookkeeping code.
+    def run_with_deadline(cap)
+      return yield if cap.nil? || cap.to_f <= 0
+      result = nil
+      error = nil
+      worker = Thread.new do
+        Thread.current.report_on_exception = false
+        begin
+          result = yield
+        rescue => e
+          error = e
+        end
+      end
+      if worker.join(cap.to_f).nil?
+        worker.kill
+        raise RunnerTimeoutError, "exceeded max_wall_clock_seconds (#{cap}s)"
+      end
+      raise error if error
+      result
+    end
+
+    # Build the `result` payload returned via get_agent_response. The
+    # LLM's prose lands in the channel's captured_output; the value the
+    # generated code returned lands in exec_result. Without including the
+    # latter, the consumer gets only the preamble ("Let me query...")
+    # and not the actual answer.
+    def compose_result(prose, exec_result)
+      parts = []
+      trimmed = prose.to_s.strip
+      parts << trimmed unless trimmed.empty?
+      parts << "Result: #{exec_result.inspect}" unless exec_result.nil?
+      parts.empty? ? '' : (parts.join("\n\n") << "\n")
+    end
+
+    def drain
+      n = @mutex.synchronize { @threads.size }
+      return if n.zero?
+      puts "AgentRunner draining #{n} in-flight job(s)..."
+      deadline = Time.now + DRAIN_TIMEOUT
+      loop do
+        reap_finished
+        break unless @mutex.synchronize { @threads.any? }
+        break if Time.now >= deadline
+        sleep 0.5
+      end
+      stuck = @mutex.synchronize { @threads.keys }
+      stuck.each do |id|
+        SessionLogger.update(id, status: 'failed', error_message: 'Runner shut down before completion')
+      end
+    end
+  end
+end

data/lib/rails_console_ai/channel/api.rb

@@ -0,0 +1,139 @@
+require 'rails_console_ai/channel/base'
+
+module RailsConsoleAi
+  module Channel
+    # Non-interactive channel used by the AgentRunner. It owns its own
+    # buffers — there is no parent channel and no user to prompt. The
+    # runner reads `captured_output` back as the agent's `result`.
+    #
+    # Mirrors Channel::Slack's pattern of logging every display event to
+    # STDOUT (tagged) so the rake task log shows progress in real time,
+    # while ALSO buffering display output into `captured_output` for the
+    # runner to compose the final result.
+    class Api < Base
+      ANSI_REGEX = /\e\[[0-9;]*[a-zA-Z]/.freeze
+
+      attr_reader :captured_output, :status_log
+
+      def initialize(user_name: nil)
+        @user_name = user_name
+        @captured_output = +''
+        @status_log = []
+      end
+
+      def display(text)
+        stripped = strip_ansi(text)
+        @captured_output << stripped << "\n"
+        log_prefixed(">>", stripped)
+      end
+
+      def display_result(text)
+        stripped = strip_ansi(text)
+        @captured_output << stripped << "\n"
+        log_prefixed(">>", stripped)
+      end
+
+      def display_result_output(text)
+        stripped = strip_ansi(text)
+        @captured_output << stripped << "\n"
+        log_prefixed(">>", stripped)
+      end
+
+      def display_code(code)
+        # Don't add to captured_output — code itself is persisted on the
+        # session row as code_executed. But DO log it to STDOUT so the
+        # rake task log shows what was generated.
+        log_prefixed("(code)", '')
+        code.to_s.each_line { |line| log_prefixed("(code)", line.rstrip) }
+      end
+
+      def display_thinking(text)
+        stripped = strip_ansi(text).strip
+        return if stripped.empty?
+        @status_log << stripped
+        log_prefixed("(thinking)", stripped)
+      end
+
+      def display_status(text)
+        stripped = strip_ansi(text).strip
+        return if stripped.empty?
+        @status_log << stripped
+        log_prefixed("(status)", stripped)
+      end
+
+      def display_tool_call(text)
+        stripped = strip_ansi(text)
+        @status_log << stripped
+        log_prefixed("->", stripped)
+      end
+
+      def display_warning(text)
+        stripped = strip_ansi(text)
+        @status_log << "WARN: #{stripped}"
+        log_prefixed("(warn)", stripped)
+      end
+
+      def display_error(text)
+        stripped = strip_ansi(text)
+        @status_log << "ERROR: #{stripped}"
+        log_prefixed("(error)", stripped)
+      end
+
+      def prompt(_text)
+        ''  # non-interactive — no user to ask
+      end
+
+      def confirm(_text)
+        # No human present to confirm. Auto-yes matches Channel::SubAgent's
+        # behavior — actual safety comes from the safety guards plus
+        # supports_danger? = false below, not from this prompt.
+        'y'
+      end
+
+      def user_identity
+        @user_name
+      end
+
+      def mode
+        'api'
+      end
+
+      def cancelled?
+        false
+      end
+
+      def supports_danger?
+        false  # like sub_agent: never bypass safety guards without a human
+      end
+
+      def supports_editing?
+        false
+      end
+
+      def wrap_llm_call(&block)
+        yield
+      end
+
+      def system_instructions
+        nil
+      end
+
+      private
+
+      # Mirror of Channel::Slack#log_prefixed — emit each line through
+      # $stdout so PrefixedIO (installed by AgentRunner#start) adds the
+      # per-session tag from Thread.current[:log_prefix].
+      def log_prefixed(tag, text)
+        if text.to_s.strip.empty?
+          $stdout.puts(tag)
+        else
+          text.to_s.each_line { |line| $stdout.puts "#{tag} #{line.rstrip}" }
+        end
+      end
+
+      def strip_ansi(text)
+        text.to_s.gsub(ANSI_REGEX, '')
+      end
+    end
+  end
+end

data/lib/rails_console_ai/conversation_engine.rb

@@ -36,7 +36,7 @@ module RailsConsoleAi
 
     # --- Public API for channels ---
 
-    def one_shot(query)
+    def one_shot(query, existing_session_id: nil)
       start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       console_capture = StringIO.new
       exec_result = with_console_capture(console_capture) do
@@ -61,7 +61,8 @@ module RailsConsoleAi
           code_output: executed ? @executor.last_output : nil,
           code_result: executed && exec_result ? exec_result.inspect : nil,
           executed: executed,
-          start_time: start_time
+          start_time: start_time,
+          existing_session_id: existing_session_id
         }
 
         exec_result
@@ -1016,18 +1017,23 @@ module RailsConsoleAi
 
     def log_session(attrs)
       require 'rails_console_ai/session_logger'
-      start_time = attrs.delete(:start_time)
-      duration_ms = if start_time
-                      ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
-                    end
-      SessionLogger.log(
-        attrs.merge(
-          input_tokens: @total_input_tokens,
-          output_tokens: @total_output_tokens,
-          duration_ms: duration_ms,
-          model: effective_model
-        )
+      start_time   = attrs.delete(:start_time)
+      existing_id  = attrs.delete(:existing_session_id)
+      duration_ms  = if start_time
+                       ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).round
+                     end
+      merged = attrs.merge(
+        input_tokens: @total_input_tokens,
+        output_tokens: @total_output_tokens,
+        duration_ms: duration_ms,
+        model: effective_model
       )
+      if existing_id
+        SessionLogger.update(existing_id, merged)
+        existing_id
+      else
+        SessionLogger.log(merged)
+      end
     end
 
     # --- Formatting helpers ---

data/lib/rails_console_ai/session_logger.rb

@@ -25,6 +25,13 @@ module RailsConsoleAi
         }
         create_attrs[:slack_thread_ts] = attrs[:slack_thread_ts] if attrs[:slack_thread_ts]
         create_attrs[:slack_channel_name] = attrs[:slack_channel_name] if attrs[:slack_channel_name]
+        create_attrs[:status]            = attrs[:status]            if attrs.key?(:status)
+        create_attrs[:result]            = attrs[:result]            if attrs.key?(:result)
+        create_attrs[:error_message]     = attrs[:error_message]     if attrs.key?(:error_message)
+        if attrs.key?(:options)
+          opts = attrs[:options]
+          create_attrs[:options] = opts.is_a?(String) ? opts : opts.to_json
+        end
         record = session_class.create!(create_attrs)
         record.id
       rescue => e
@@ -59,6 +66,9 @@ module RailsConsoleAi
         updates[:executed]      = attrs[:executed]       if attrs.key?(:executed)
         updates[:duration_ms]   = attrs[:duration_ms]    if attrs.key?(:duration_ms)
         updates[:name]          = attrs[:name]           if attrs.key?(:name)
+        updates[:status]        = attrs[:status]         if attrs.key?(:status)
+        updates[:result]        = attrs[:result]         if attrs.key?(:result)
+        updates[:error_message] = attrs[:error_message]  if attrs.key?(:error_message)
 
         session_class.where(id: id).update_all(updates) unless updates.empty?
       rescue => e