robot_lab-rails 0.1.0 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 93f8a8d257c9dfe599fde397b4be1cc979df53eed8d38a3adca987e493852311
-  data.tar.gz: a41afb0b4132c1c245a10f44d3b5d9dd40ced45ad264e0a7e08c342cf9fb5711
+  metadata.gz: 363024a9b53fc93e6bee9f45d93ade96b62f8e2fcc86172eb1233baea141b525
+  data.tar.gz: 3ad6bf319772440866cb90ac41169e99eff28e9137143281685c48e46d652774
 SHA512:
-  metadata.gz: d84d9c25a0379bca316619e0268c9f727228572c09048cb2717591acf145f1459c4292617f3ba836d756a9bd0f79b4922fdec43812cf3d111ab57d8dc591d945
-  data.tar.gz: e908c4bee35578e1ecd313b126ea87b7cc3719eba286cbe01ed11000fdd65dc09b41ba49fc069da64137d783d8c19076ae5dac4dd5418b8aac7b8b89c32b31ad
+  metadata.gz: ec1fcbe29db8f114c0ce38a942a1582d1d018ac0a834412368763cb02d4bd5e3886cfa55da2d914d2408e7dca553bc1c86c63512f4f717bcb7e8a8dafa1b4ba2
+  data.tar.gz: 5332b0bd26088e36c01610ceae13b34ca3850c3a58a91a82a4fac264239f3dfae6b9625ace7c0f495e91e7d60d31c9b1ac98ce80aa561131d27021a35725d0fe

data/.envrc

@@ -1 +1,3 @@
+source_up
 export RR=`pwd`
+export BUNDLE_GEMFILE=Gemfile

data/.loki

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+# robot_lab-rails — ActiveJob, generators, Turbo broadcasts for Rails apps.
+
+import_up "repo_dev.loki"
+
+class Tasks
+  @@gem_name ||= "robot_lab-rails".freeze
+
+  header "robot_lab-rails v#{gem_version} — Rails integration for RobotLab"
+
+  desc "Run Rails-specific integration tests"
+  def integration
+    sh "bundle exec rake test"
+  end
+end

data/.quality/reek_baseline.txt

@@ -0,0 +1,3 @@
+2	lib/generators/robot_lab/install_generator.rb
+1	lib/robot_lab/rails_integration/engine.rb
+3	lib/robot_lab/rails_integration/job.rb

data/.rubocop.yml

@@ -0,0 +1 @@
+inherit_from: ../.rubocop-base.yml

data/CHANGELOG.md

@@ -1,5 +1,31 @@
 ## [Unreleased]
 
+### Added
+- `.loki` Asgard task file: `test`, `rubocop`, `rubocop_fix`, `flog`, `flay`, `quality`, `build`, `install`, `release`, and `console` tasks via the Asgard task runner
+- `flay_check` Rake task: structural code duplication gate (mass threshold 50); integrated into the `quality` Rake task
+- `flay` and `minitest-reporters` gems added to development dependencies
+- `test_output.txt`, `flay_output.txt`, `flog_output.txt`, and `rubocop_output.txt` added to `.gitignore`
+
+### Changed
+- `test/test_helper.rb`: test output redirected to `test_output.txt` via `$stdout` reassignment; `TerminalSummaryReporter` prints a single PASS/FAIL summary line to the terminal
+- `Rakefile`: `rubocop` and `rubocop_fix` tasks removed (now owned by Asgard); `flay_check` integrated into the `quality` gate
+
+## [0.2.1] - 2026-05-19
+
+### Added
+- Rails Engine — autoloads `app/robots/` and `app/tools/` in the host application via Zeitwerk
+- Railtie — wires `RobotLab.config.logger` to `Rails.logger` on boot and applies Rails-specific defaults
+- `RobotLab::Job` (`RobotLab::RailsIntegration::Job`) — ActiveJob base class handling robot-class resolution, `RobotLabThread` persistence, Turbo Stream wiring, and completion/error broadcasting
+- `robot_class` DSL on `RobotLab::Job` subclasses — binds a dedicated job to a specific robot class without requiring `robot_class:` at enqueue time
+- `TurboStreamCallbacks` — streams content tokens and tool-call badges to `#robot_response` and `#robot_tools` targets in real time; graceful no-op when `turbo-rails` is absent
+- Generator `robot_lab:install` — creates initializer, migration, models (`RobotLabThread`, `RobotLabResult`), `RobotRunJob`, and `app/robots/` / `app/tools/` directories
+- Generator `robot_lab:robot NAME` — generates a robot class stub in `app/robots/`
+- Generator `robot_lab:job NAME [--queue QUEUE]` — generates a dedicated job subclass pre-bound to a robot class
+- Default retry/discard policy on `RobotLab::Job`: `retry_on StandardError` (3 attempts, 5 s wait); `discard_on ActiveJob::DeserializationError`
+
+### Changed
+- Version synchronized with robot_lab core 0.2.1
+
 ## [0.1.0] - 2026-05-07
 
 - Initial release

data/CLAUDE.md

@@ -0,0 +1,71 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What This Gem Does
+
+`robot_lab-rails` is a Rails Engine that integrates RobotLab into Rails applications. It provides a Railtie for configuration, an ActiveJob base class with optional Turbo Stream broadcasting, generators for scaffolding, and autoloading for `app/robots/` and `app/tools/`.
+
+## Commands
+
+```bash
+bundle exec rake test        # Run full test suite
+ruby -Ilib:test test/<file>  # Run a single test file
+
+# Inside a Rails app using this gem:
+rails g robot_lab:install            # migration, models, initializer, job
+rails g robot_lab:robot MyRobot      # app/robots/my_robot.rb + test
+rails g robot_lab:robot MyRouter --routing  # routing robot variant
+rails g robot_lab:job MyRobot        # app/jobs/my_robot_job.rb
+```
+
+## Architecture
+
+**`RailsIntegration::Engine`** (`rails_integration/engine.rb`) — Rails Engine with `isolate_namespace RobotLab`. Adds `app/robots/` and `app/tools/` to Rails autoload paths so robot and tool classes are autoloaded like models.
+
+**`RailsIntegration::Railtie`** (`rails_integration/railtie.rb`) — Reads `config.robot_lab.default_model` and `config.robot_lab.default_provider` from the Rails app config and applies them to `RobotLab.configure`. Sets `RobotLab.config.logger = Rails.logger` so all RobotLab log output goes through Rails logging.
+
+**`RailsIntegration::Job`** (`rails_integration/job.rb`) — `ActiveJob::Base` subclass. Subclass with `robot_class MyRobot` DSL, or pass `robot_class:` at enqueue time.
+
+```ruby
+class SupportRobotJob < RobotLab::Job
+  queue_as :default
+  robot_class SupportRobot
+end
+
+SupportRobotJob.perform_later(message: "Hello", thread_id: session_id)
+```
+
+When `thread_id` is provided and Turbo is available, the job streams content and tool-call badges live via `Turbo::StreamsChannel`, and persists the result to `RobotLabThread` / `RobotLabResult` ActiveRecord models. Built-in retry (3 attempts, 5 second wait) and discard on `DeserializationError`.
+
+**`RailsIntegration::TurboStreamCallbacks`** (`rails_integration/turbo_stream_callbacks.rb`) — Stateless module. Safe to require without turbo-rails installed (guards with `defined?(Turbo::StreamsChannel)` at call time).
+
+```ruby
+cb = TurboStreamCallbacks.build_content_callback(stream_name: "robot_lab_thread_42")
+# => Proc that broadcasts each content chunk as HTML-escaped text
+
+tool_cb = TurboStreamCallbacks.build_tool_call_callback(stream_name: "robot_lab_thread_42")
+# => Proc that broadcasts a tool-badge span per tool call
+```
+
+## Generator Templates
+
+Templates live in `lib/generators/robot_lab/templates/`. The install generator creates:
+- `config/initializers/robot_lab.rb`
+- `db/migrate/create_robot_lab_tables.rb` (RobotLabThread + RobotLabResult tables)
+- `app/models/robot_lab_thread.rb` / `app/models/robot_lab_result.rb`
+- `app/jobs/robot_run_job.rb`
+- Empty `app/robots/` and `app/tools/` directories
+
+## Key Constraints
+
+- `Engine` and `Railtie` are only loaded when `defined?(Rails)` — the gem is safe to require in non-Rails contexts (e.g. test helpers that stub Rails).
+- `Job#setup_thread` calls `"RobotLabThread".constantize` — this is a string reference to avoid a hard dependency; ensure the model is generated before using `thread_id`.
+- `TurboStreamCallbacks` HTML-escapes all content via `ERB::Util.html_escape` — do not bypass this.
+- The Railtie uses `ActiveSupport.on_load(:active_record)` for AR setup — place any ActiveRecord extensions there, not in the initializer.
+
+## Testing
+
+- Minitest with SimpleCov (branch coverage tracked, no minimum threshold enforced yet)
+- Tests stub Rails, ActiveJob, and Turbo — no Rails app is loaded
+- Coverage baseline: ~80% line / ~82% branch

data/README.md

@@ -78,6 +78,31 @@ SupportJob.perform_later(message: params[:message], thread_id: session_id)
 
 Omitting `thread_id` runs the robot in fire-and-forget mode — no persistence, no broadcasting.
 
+## Recurring Tasks (Solid Queue)
+
+When using [Solid Queue](https://github.com/rails/solid_queue), skip the wrapper job and call a class method directly via the `command:` key in `config/recurring.yml`:
+
+```ruby
+# app/services/daily_digest.rb
+class DailyDigest
+  def self.run
+    User.digest_subscribers.find_each do |user|
+      DailyDigestJob.perform_later(user_id: user.id)
+    end
+  end
+end
+```
+
+```yaml
+# config/recurring.yml
+daily_digest:
+  command: "DailyDigest.run"
+  schedule: "every day at 06:00"
+  queue: ai   # optional; defaults to solid_queue_recurring
+```
+
+The orchestrator class is independently testable. For overnight autonomous runs, `RobotLab::To.run` works as a recurring command directly. See the [Rails Integration Guide](https://madbomber.github.io/robot_lab-rails/guides/rails-integration#recurring-tasks-solid-queue) for queue configuration details and the `robot_lab-to` pattern.
+
 ## Turbo Stream Streaming
 
 When `thread_id` is provided and [turbo-rails](https://github.com/hotwired/turbo-rails) is installed, `RobotLab::Job` automatically:

data/Rakefile

@@ -1,8 +1,132 @@
 # frozen_string_literal: true
 
-require "bundler/gem_tasks"
-require "minitest/test_task"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
-Minitest::TestTask.create
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb', 'test/**/test_*.rb'].exclude('**/*_helper.rb')
+  t.verbose = true
+  t.ruby_opts << '-rtest_helper'
+end
 
 task default: :test
+
+desc 'Run tests with verbose output'
+task :test_verbose do
+  ENV['TESTOPTS'] = '--verbose'
+  Rake::Task[:test].invoke
+end
+
+desc 'Run a single test file'
+task :test_file, [:file] do |_t, args|
+  ruby "test/#{args[:file]}"
+end
+
+desc 'Check code complexity with Flog (warn >=20, fail >=50)'
+task :flog_check do
+  require 'flog'
+
+  method_warn = 20.0
+  method_fail = 50.0
+
+  flogger = Flog.new(all: true)
+  flogger.flog(*Dir.glob('lib/**/*.rb'))
+
+  warnings = []
+  failures = []
+
+  flogger.each_by_score do |method, score|
+    next if method.end_with?('#none')
+
+    if score > method_fail
+      failures << "#{format('%.1f', score)}: #{method}"
+    elsif score > method_warn
+      warnings << "#{format('%.1f', score)}: #{method}"
+    end
+  end
+
+  unless warnings.empty?
+    puts "\nFlog warnings (#{method_warn}–#{method_fail}) — target for future refactoring:"
+    warnings.each { |v| puts "  #{v}" }
+  end
+
+  if failures.empty?
+    puts "\nFlog: no methods exceed the failure threshold (>=#{method_fail})"
+  else
+    puts "\nFlog failures (>=#{method_fail}) — must be refactored:"
+    failures.each { |v| puts "  #{v}" }
+    abort "\nFlog quality gate failed: #{failures.size} method(s) exceed #{method_fail}"
+  end
+end
+
+desc 'Check for structural code duplication with Flay (mass >= 50)'
+task :flay_check do
+  require 'flay'
+
+  mass_threshold = 50
+
+  flay = Flay.new({ mass: mass_threshold, diff: false, verbose: false, summary: false, timeout: 60 })
+  flay.process(*Dir.glob('lib/**/*.rb'))
+  flay.analyze
+
+  if flay.hashes.empty?
+    puts "\nFlay: no structural duplication detected (mass >= #{mass_threshold})"
+  else
+    puts "\nFlay found structural duplication (mass >= #{mass_threshold}):"
+    flay.report
+    abort "\nFlay quality gate failed: #{flay.hashes.length} pattern(s) detected"
+  end
+end
+
+desc 'Run all quality checks: tests (with coverage), RuboCop, Flog, and Flay'
+task :quality do
+  gates = [
+    ['Tests + Coverage', 'bundle exec rake test'],
+    ['RuboCop',          'bundle exec rubocop'],
+    ['Flog Complexity',  'bundle exec rake flog_check'],
+    ['Flay Duplication', 'bundle exec rake flay_check']
+  ]
+
+  results = gates.map do |label, command|
+    puts "\n#{'=' * 60}"
+    puts "Quality Gate: #{label}"
+    puts '=' * 60
+    [label, system(command) ? :pass : :fail]
+  end
+
+  green = ->(s) { "\e[32m#{s}\e[0m" }
+  red   = ->(s) { "\e[31m#{s}\e[0m" }
+  width = results.map { |label, _| label.length }.max
+
+  puts "\n#{'=' * 60}"
+  puts 'Quality Gate Summary'
+  puts '=' * 60
+  results.each do |label, status|
+    badge = status == :pass ? green.call('PASS') : red.call('FAIL')
+    puts "  [#{badge}] #{label.ljust(width)}"
+  end
+  puts '-' * 60
+
+  passed = results.count { |_, s| s == :pass }
+  failed = results.count { |_, s| s == :fail }
+  tally  = "#{passed} passed, #{failed} failed"
+  puts "  #{failed.zero? ? green.call(tally) : red.call(tally)}"
+  puts '=' * 60
+
+  abort "\n#{red.call('Quality gate failed.')}" unless failed.zero?
+  puts "\n#{green.call('All quality gates passed.')}"
+end
+
+namespace :docs do
+  desc 'Build MkDocs documentation'
+  task :build do
+    sh 'mkdocs build'
+  end
+
+  desc 'Serve MkDocs documentation locally on http://localhost:8000'
+  task :serve do
+    sh 'mkdocs serve'
+  end
+end

data/docs/guides/rails-integration.md

@@ -35,7 +35,7 @@ rails db:migrate
 
 ## Configuration
 
-RobotLab uses [MywayConfig](https://github.com/madbomber/myway_config) for configuration. There is no `RobotLab.configure` block. Instead, settings are loaded from YAML files and environment variables in the following priority order:
+RobotLab uses [MywayConfig](https://github.com/madbomber/myway_config) for static configuration. Settings are loaded from YAML files and environment variables in the following priority order:
 
 1. **Bundled defaults** (`lib/robot_lab/config/defaults.yml`)
 2. **Environment-specific overrides** (development, test, production sections)
@@ -85,14 +85,21 @@ ROBOT_LAB_RUBY_LLM__REQUEST_TIMEOUT=180
 
 RobotLab also falls back to standard provider environment variables (e.g. `ANTHROPIC_API_KEY`, `OPENAI_API_KEY`) when the prefixed versions are not set.
 
-### Initializer (Logger Only)
+### Initializer
 
-The only runtime-writable config attribute is the logger. The generated initializer sets it to the Rails logger:
+Use `RobotLab.configure` to set runtime attributes. The generated initializer wires the logger to `Rails.logger`:
 
 ```ruby title="config/initializers/robot_lab.rb"
 # frozen_string_literal: true
 
-# Set the RobotLab logger to use Rails.logger
+RobotLab.configure do |c|
+  c.logger = Rails.logger
+end
+```
+
+You can also assign it directly if you prefer a one-liner:
+
+```ruby
 RobotLab.config.logger = Rails.logger
 ```
 
@@ -114,8 +121,15 @@ RobotLab.config.streaming_enabled          #=> true
 rails generate robot_lab:robot Support
 rails generate robot_lab:robot Billing --description="Handles billing inquiries"
 rails generate robot_lab:robot Router --routing
+rails generate robot_lab:robot Support --tools=order_lookup,refund_processor
 ```
 
+Options:
+
+- `--description` — Robot description (defaults to `"A helpful <Name> robot"`)
+- `--routing` — Generate a routing robot (subclasses `RobotLab::Robot`, overrides `call`) instead of the plain factory-style robot
+- `--tools` — List of tool names; emitted as commented-out entries in the generated `tools` array for you to uncomment and wire up
+
 ### Robot Class
 
 Robots are plain Ruby classes with a `.build` factory method that calls `RobotLab.build` with keyword arguments:
@@ -496,6 +510,83 @@ class ProcessMessageJob < ApplicationJob
 end
 ```
 
+## Recurring Tasks (Solid Queue)
+
+When using [Solid Queue](https://github.com/rails/solid_queue), you can schedule robot runs without writing a thin wrapper job. Solid Queue's `command:` key in `config/recurring.yml` calls a class method directly, eliminating unnecessary glue code.
+
+### Orchestrator class
+
+Keep the scheduling logic in a plain Ruby class. The class method fans out per-item jobs — or runs a robot directly:
+
+```ruby title="app/services/daily_digest.rb"
+class DailyDigest
+  def self.run
+    User.digest_subscribers.find_each do |user|
+      DailyDigestJob.perform_later(user_id: user.id)
+    end
+  end
+end
+```
+
+### Wiring in recurring.yml
+
+Reference the method directly in `config/recurring.yml`:
+
+```yaml title="config/recurring.yml"
+daily_digest:
+  command: "DailyDigest.run"
+  schedule: "every day at 06:00"
+```
+
+No wrapper job needed. `DailyDigest.run` is a plain class method — independently testable without enqueuing anything.
+
+### Queue configuration
+
+Solid Queue sends recurring commands to the `solid_queue_recurring` queue by default. Add a dedicated worker in `config/queue.yml` so recurring runs don't compete with your main job queues:
+
+```yaml title="config/queue.yml"
+production:
+  workers:
+    - queues: [solid_queue_recurring]
+      threads: 1
+    - queues: [default, ai]
+      threads: 3
+```
+
+Override the queue per task with `queue:` to route recurring robot runs through a shared worker:
+
+```yaml title="config/recurring.yml"
+daily_digest:
+  command: "DailyDigest.run"
+  schedule: "every day at 06:00"
+  queue: ai
+```
+
+### Using robot_lab-to for overnight runs
+
+The `robot_lab-to` gem's `RobotLab::To.run` is designed for a single autonomous session, making it a natural fit for a Solid Queue recurring task:
+
+```ruby title="app/services/nightly_analysis.rb"
+class NightlyAnalysis
+  def self.run
+    RobotLab::To.run(
+      "Analyze yesterday's support tickets and generate a quality report",
+      max_iterations: 10,
+      stop_when: "Report is written to disk"
+    )
+  end
+end
+```
+
+```yaml title="config/recurring.yml"
+nightly_analysis:
+  command: "NightlyAnalysis.run"
+  schedule: "every day at 02:00"
+  queue: ai
+```
+
+> `RobotLab::To.run` is synchronous. Solid Queue runs it inside a worker process — this is intentional. Each nightly run blocks its worker for the duration of the autonomous loop.
+
 ## Testing
 
 ### Test Configuration
@@ -575,6 +666,10 @@ class RobotLabThread < ApplicationRecord
   def last_result
     results.order(sequence_number: :desc).first
   end
+
+  def message_count
+    results.count
+  end
 end
 ```
 
@@ -589,14 +684,24 @@ class RobotLabResult < ApplicationRecord
 
   validates :session_id, presence: true
   validates :robot_name, presence: true
+  validates :sequence_number, presence: true,
+                              numericality: { only_integer: true, greater_than_or_equal_to: 0 }
 
   default_scope { order(sequence_number: :asc) }
 
+  def output_messages
+    (output_data || []).map { |d| RobotLab::Message.from_hash(d.symbolize_keys) }
+  end
+
+  def tool_call_messages
+    (tool_calls_data || []).map { |d| RobotLab::Message.from_hash(d.symbolize_keys) }
+  end
+
   def to_robot_result
     RobotLab::RobotResult.new(
       robot_name: robot_name,
-      output: (output_data || []).map { |d| RobotLab::Message.from_hash(d.symbolize_keys) },
-      tool_calls: (tool_calls_data || []).map { |d| RobotLab::Message.from_hash(d.symbolize_keys) },
+      output: output_messages,
+      tool_calls: tool_call_messages,
       stop_reason: stop_reason
     )
   end

data/lib/robot_lab/rails/version.rb

@@ -2,6 +2,6 @@
 
 module RobotLab
   module Rails
-    VERSION = "0.1.0"
+    VERSION = "0.2.6"
   end
 end

data/lib/robot_lab/rails.rb

@@ -3,8 +3,12 @@
 require_relative "rails/version"
 require_relative "rails_integration/turbo_stream_callbacks"
 
-if defined?(::Rails)
+if defined?(Rails)
   require_relative "rails_integration/engine"
   require_relative "rails_integration/railtie"
   require_relative "rails_integration/job"
 end
+
+if defined?(RobotLab) && RobotLab.respond_to?(:register_extension)
+  RobotLab.register_extension(:rails, RobotLab::Rails)
+end

data/lib/robot_lab/rails_integration/job.rb

@@ -39,9 +39,10 @@ module RobotLab
 
       def resolve_robot_class(runtime_class)
         klass = runtime_class || self.class.robot_class
-        raise ArgumentError,
-              "No robot class specified. Pass robot_class: to perform or set robot_class on the job class." \
-          unless klass
+        unless klass
+          raise ArgumentError,
+                "No robot class specified. Pass robot_class: to perform or set robot_class on the job class."
+        end
 
         return klass if klass.is_a?(Class)
 

data/lib/robot_lab/rails_integration/turbo_stream_callbacks.rb

@@ -13,7 +13,7 @@ module RobotLab
       end
 
       def self.build_content_callback(stream_name:, target: "robot_response")
-        ->(chunk) {
+        lambda { |chunk|
           content = chunk.respond_to?(:content) ? chunk.content : chunk.to_s
           return unless content && TurboStreamCallbacks.available?
 
@@ -26,7 +26,7 @@ module RobotLab
       end
 
       def self.build_tool_call_callback(stream_name:, target: "robot_tools")
-        ->(tool_call) {
+        lambda { |tool_call|
           return unless TurboStreamCallbacks.available?
 
           name = tool_call.respond_to?(:name) ? tool_call.name : tool_call.to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: robot_lab-rails
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.6
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -13,16 +13,16 @@ dependencies:
   name: robot_lab
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.2.0
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -75,7 +75,11 @@ extra_rdoc_files: []
 files:
 - ".envrc"
 - ".github/workflows/deploy-github-pages.yml"
+- ".loki"
+- ".quality/reek_baseline.txt"
+- ".rubocop.yml"
 - CHANGELOG.md
+- CLAUDE.md
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -152,7 +156,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.11
+rubygems_version: 4.0.17
 specification_version: 4
 summary: Rails integration for the robot_lab LLM agent framework
 test_files: []