robot_lab 0.3.0 → 0.3.1

data/examples/16_writers_room/writers_room.rb

@@ -1,256 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Example 16: The Writers' Room — Self-Organizing Group
-#
-# A team of writer robots collaborates to produce a 10-chapter
-# fiction novella. No orchestration, no pipeline, no assigned roles.
-# The writers self-organize through:
-#
-#   - BUS (broadcast + direct messages)
-#     :room channel for group discussion
-#     personal channels for 1:1 feedback
-#
-#   - SHARED MEMORY (story bible, outline, chapters)
-#     Writers read and write freely; memory is the shared truth
-#
-#   - SPAWNING (dynamic team growth)
-#     Any writer can recruit new writers when work exceeds capacity
-#
-# The script creates identical writers, seeds the room with an
-# assignment, and waits. Everything else is emergent.
-#
-# Modes:
-#   Book mode (default) — write an original 10-chapter novella
-#   Screenplay mode     — adapt a finished book into a 4-act TV movie pilot
-#
-# Usage:
-#   bundle exec ruby examples/16_writers_room/writers_room.rb
-#   bundle exec ruby examples/16_writers_room/writers_room.rb --premise "a detective story set on Mars"
-#   bundle exec ruby examples/16_writers_room/writers_room.rb --writers 4 --timeout 300
-#   bundle exec ruby examples/16_writers_room/writers_room.rb --log session.log
-#   bundle exec ruby examples/16_writers_room/writers_room.rb --screenplay-from output/memory.json
-#   bundle exec ruby examples/16_writers_room/writers_room.rb -h
-
-ENV["ROBOT_LAB_TEMPLATE_PATH"] ||= File.join(__dir__, "prompts")
-
-require "json"
-require_relative "../common"
-require_relative "display"
-require_relative "tools"
-require_relative "room"
-require_relative "writer"
-
-# ── Mode Descriptors ────────────────────────────────────────
-
-BOOK_MODE = {
-  name:            :book,
-  template:        :writer,
-  unit_name:       "chapter",
-  unit_range:      1..10,
-  completion_key:  :book_complete,
-  bible_key:       :story_bible,
-  outline_key:     :outline,
-  output_filename: "book.md"
-}.freeze
-
-SCREENPLAY_MODE = {
-  name:            :screenplay,
-  template:        :screenplay_writer,
-  unit_name:       "scene",
-  unit_range:      :dynamic,
-  registry_key:    :scene_registry,
-  completion_key:  :screenplay_complete,
-  bible_key:       :screenplay_bible,
-  outline_key:     :scene_outline,
-  output_filename: "screenplay.md"
-}.freeze
-
-# ── Parse CLI args ───────────────────────────────────────────
-
-if ARGV.include?("-h") || ARGV.include?("--help")
-  puts <<~HELP
-    Usage: #{$0} [options]
-
-    Options:
-      --premise TEXT              Story premise (default: generation ship AI consciousness)
-      --writers N                 Initial number of writers, minimum 2 (default: 3)
-      --log FILE                 Also write display output to FILE
-      --timeout N                Seconds to wait for completion (default: 600)
-      --screenplay-from PATH     Adapt a finished book into a screenplay using
-                                 memory dumped from a previous book-mode run
-      -h, --help                 Show this help
-  HELP
-  exit
-end
-
-log_path = nil
-if (idx = ARGV.index("--log"))
-  log_path = ARGV[idx + 1]
-  abort "Missing value for --log" unless log_path
-end
-
-premise = "a generation ship where the AI navigation system develops consciousness"
-if (idx = ARGV.index("--premise"))
-  premise = ARGV[idx + 1]
-  abort "Missing value for --premise" unless premise
-end
-
-initial_writers = 3
-if (idx = ARGV.index("--writers"))
-  initial_writers = ARGV[idx + 1].to_i
-  initial_writers = 3 if initial_writers < 2
-end
-
-timeout = 600
-if (idx = ARGV.index("--timeout"))
-  timeout = ARGV[idx + 1].to_i
-  timeout = 600 if timeout < 30
-end
-
-screenplay_source = nil
-if (idx = ARGV.index("--screenplay-from"))
-  screenplay_source = ARGV[idx + 1]
-  abort "Missing value for --screenplay-from" unless screenplay_source
-  abort "File not found: #{screenplay_source}" unless File.exist?(screenplay_source)
-end
-
-mode = screenplay_source ? SCREENPLAY_MODE : BOOK_MODE
-
-# ── Build the room ───────────────────────────────────────────
-
-OUTPUT_DIR = File.join(__dir__, "output")
-require "fileutils"
-FileUtils.mkdir_p(OUTPUT_DIR)
-
-display = Display.new(log_path: log_path)
-
-# RunConfig has no `provider` field, so the writers get provider+model via
-# **llm_opts and inherit the rest of their operational defaults from here.
-shared_config = RobotLab::RunConfig.new(
-  model: LLM[:default].model,
-  temperature: 0.7
-)
-
-room = Room.new(display: display, mode: mode, config: shared_config)
-
-# Load source material into memory for screenplay mode
-if screenplay_source
-  source_data = JSON.parse(File.read(screenplay_source))
-  source_data.each { |key, value| room.memory.set(key.to_sym, value) }
-  display.info("Loaded #{source_data.size} memory keys from #{screenplay_source}")
-end
-
-# Create identical writers
-initial_writers.times do |i|
-  room.add_writer("writer_#{i + 1}")
-end
-
-# Monitor shared memory changes
-room.memory.subscribe_pattern("#{mode[:unit_name]}_*") do |change|
-  display.info("[memory] #{change.writer} wrote :#{change.key}")
-end
-
-subscribe_keys = [mode[:bible_key], mode[:outline_key], :claims, mode[:completion_key]]
-subscribe_keys << mode[:registry_key] if mode[:registry_key]
-room.memory.subscribe(*subscribe_keys) do |change|
-  display.info("[memory] #{change.writer} updated :#{change.key}")
-end
-
-# ── Go ───────────────────────────────────────────────────────
-
-goal_label = mode[:name] == :book ? "10 chapters of fiction" : "4-act TV movie screenplay (dynamic scenes)"
-
-display.banner(<<~BANNER)
-  ============================================================
-    THE WRITERS' ROOM — Self-Organizing Group
-  ============================================================
-
-    Mode:    #{mode[:name]}
-    Premise: #{premise}
-    Writers: #{room.writers.keys.join(', ')}
-    Goal:    #{goal_label}
-    Method:  Self-organization via bus + shared memory
-BANNER
-
-display.separator
-
-if mode[:name] == :screenplay
-  assignment = <<~ASSIGNMENT
-    ASSIGNMENT: Adapt the source material into a 4-act made-for-TV movie screenplay
-    (pilot for a potential series). Work at the SCENE level — each writer claims
-    and writes individual scenes.
-
-    The source material is already loaded into shared memory. Read the story_bible,
-    outline, and chapter_1 through chapter_10 to understand the original book.
-
-    You are one of #{initial_writers} writers in this room. Coordinate among
-    yourselves to produce the screenplay:
-    1. Read the source material
-    2. Build a screenplay_bible (adaptation choices)
-    3. Create a scene_outline with numbered scenes grouped into 4 acts
-    4. Write the scene_registry (comma-separated scene numbers, e.g. "1,2,3,4,5,6,7,8,9,10,11,12")
-    5. Claim and write individual scenes (scene_1, scene_2, etc.)
-    6. Spawn more writers when unclaimed scenes exceed active writers
-    7. Mark complete when all registered scenes are written
-
-    Scenes may be dropped or reordered as the story takes shape — update the
-    scene_registry when that happens.
-
-    Start by reading the source material and discussing how to adapt it for screen.
-  ASSIGNMENT
-else
-  assignment = <<~ASSIGNMENT
-    ASSIGNMENT: Write a 10-chapter science fiction novella about #{premise}.
-
-    You are one of #{initial_writers} writers in this room. Coordinate among
-    yourselves to produce the book. Discuss the premise, build a story bible,
-    create an outline, claim chapters, and write them. If you need more writers,
-    spawn them. When all 10 chapters are done, mark complete.
-
-    Start by discussing what this story should be about.
-  ASSIGNMENT
-end
-
-room.seed(assignment)
-
-completed = room.wait_for_completion(timeout: timeout)
-
-# ── Assemble and save ────────────────────────────────────────
-
-display.separator
-
-output_text = room.assemble_output
-output_path = File.join(OUTPUT_DIR, mode[:output_filename])
-File.write(output_path, output_text)
-
-# Dump memory for book mode (enables later screenplay adaptation)
-if mode[:name] == :book
-  memory_path = File.join(OUTPUT_DIR, "memory.json")
-  custom = room.memory.keys.each_with_object({}) do |k, h|
-    next if %i[results messages].include?(k)
-    h[k] = room.memory.get(k)
-  end
-  File.write(memory_path, JSON.pretty_generate(custom))
-  display.info("Memory dumped to #{memory_path}")
-end
-
-# Count units actually written
-unit_name     = mode[:unit_name]
-expected      = room.expected_units
-units_written = expected.count { |n| room.memory.key?(:"#{unit_name}_#{n}") }
-
-display.stats(<<~STATS)
-  ────────────────────────────────────────────────────────────
-    Writers' Room Stats:
-      Mode:                 #{mode[:name]}
-      #{unit_name.capitalize}s written:#{' ' * (10 - unit_name.length)}#{units_written}/#{expected.size}
-      Completed:            #{completed}
-      Total writers:        #{room.writers.size} (#{room.writers.size - initial_writers} spawned)
-      Writers:              #{room.writers.keys.join(', ')}
-      Memory keys:          #{room.memory.keys.join(', ')}
-
-    Output: #{output_path}
-STATS
-
-display.close

data/examples/17_skills.rb

@@ -1,234 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-# Example 17: Composable Skills
-#
-# Demonstrates using skills to compose robot behaviors from reusable templates.
-# Skills are regular templates whose prompt bodies are prepended before the main
-# template. They support nesting (a skill can reference other skills) with
-# automatic cycle detection.
-#
-# Scenario: An SRE incident response system where the on-call analyst robot
-# is composed from reusable behavioral skills.
-#
-# Skill architecture:
-#
-#   incident_responder (main template)
-#   ├── runbook_protocol        (flat skill — structured diagnosis steps)
-#   ├── structured_output       (flat skill — JSON response format)
-#   └── sre_compliance          (recursive skill — bundles two sub-skills)
-#       ├── pii_redactor        (leaf skill — redact PII from output)
-#       └── audit_trail         (leaf skill — include audit metadata)
-#
-# Prompt assembly order (depth-first):
-#   1. runbook_protocol     — "follow these 5 steps..."
-#   2. structured_output    — "respond with JSON..."
-#   3. pii_redactor         — "redact PII..." (nested via sre_compliance)
-#   4. audit_trail          — "include audit fields..." (nested via sre_compliance)
-#   5. sre_compliance       — "operate under SRE compliance..."
-#   6. incident_responder   — "you are the on-call analyst for..."
-#
-# Usage:
-#   ruby examples/17_skills.rb
-#
-# Templates:
-#   examples/prompts/
-#   ├── incident_responder.md   — Main template (team name, services, runbook URL)
-#   ├── runbook_protocol.md     — Flat skill: 5-step incident protocol
-#   ├── structured_output.md    — Flat skill: JSON response format
-#   ├── sre_compliance.md       — Recursive skill: bundles pii_redactor + audit_trail
-#   ├── pii_redactor.md         — Leaf skill: redact PII
-#   └── audit_trail.md          — Leaf skill: audit metadata in every response
-
-require_relative "common"
-
-# Send logger output to a file instead of stdout
-require 'logger'
-log_file = File.join(__dir__, "17.log")
-RobotLab.config.logger = Logger.new(log_file)
-RubyLLM.configure { |c| c.logger = Logger.new(log_file) }
-
-# =============================================================================
-# Simulated Alert Data
-# =============================================================================
-
-ALERTS = [
-  {
-    label: "Database Connection Pool Exhaustion",
-    data: <<~ALERT
-      ALERT: PostgreSQL connection pool exhausted
-      Service: payments-api
-      Severity: SEV-2
-      Time: 2025-02-22T03:14:00Z
-      Region: us-east-1
-
-      Metrics:
-      - Active connections: 100/100 (pool max)
-      - Connection wait time: 12.4s (p99), normally 0.02s
-      - Failed queries: 847 in last 5 minutes
-      - Error rate: 23% (baseline: 0.1%)
-
-      Recent changes:
-      - Deploy payments-api v2.41.0 at 02:50 UTC (added batch reconciliation job)
-      - No infrastructure changes in 24h
-
-      Affected users: ~3,200 checkout attempts failing
-      Downstream: order-service seeing 504 timeouts from payments-api
-
-      Sample error log:
-      [2025-02-22T03:12:44Z] ERROR payments-api: PG::ConnectionBad: could not obtain connection
-        from pool within 10s — user=svc_payments@10.0.3.47 db=payments_prod
-      [2025-02-22T03:13:01Z] ERROR payments-api: ActiveRecord::ConnectionTimeoutError
-        request_id=req_8f3a2b user=jane.doe@acme.com account_id=acct_99321
-    ALERT
-  },
-  {
-    label: "Memory Leak in User Service",
-    data: <<~ALERT
-      ALERT: Container OOMKilled — repeated restarts
-      Service: user-service
-      Severity: SEV-3
-      Time: 2025-02-22T09:30:00Z
-      Region: eu-west-1
-
-      Metrics:
-      - Container restarts: 14 in last hour (normally 0)
-      - Memory usage: ramps from 256MB to 2GB limit in ~4 minutes
-      - Request latency: p99 spikes to 8s before each OOMKill
-      - Heap profile: String allocations growing linearly
-
-      Recent changes:
-      - Deploy user-service v1.18.3 at 08:00 UTC (added avatar upload endpoint)
-      - Kubernetes node pool scaled from 3 to 5 nodes at 07:00 UTC
-
-      Affected users: intermittent 503 errors on profile pages (~500 users/hr)
-      Downstream: session-service cache miss rate elevated (users re-authenticating)
-
-      Sample error log:
-      [2025-02-22T09:28:11Z] WARN user-service: Memory usage 1.8GB approaching 2GB limit
-        pod=user-service-7f8b9c-x4k2j node=ip-10-0-5-112.ec2.internal
-      [2025-02-22T09:29:03Z] ERROR user-service: OOMKilled — container exceeded memory limit
-        user_email=bob.smith@example.org ip=192.168.1.42 endpoint=/api/v2/avatar/upload
-    ALERT
-  }
-]
-
-# =============================================================================
-# Build the Incident Responder with Composable Skills
-# =============================================================================
-
-banner "RobotLab Skills Demo — SRE Incident Response System"
-
-# Show the skill composition
-puts "Skill composition:"
-puts "  incident_responder (main template)"
-puts "  ├── runbook_protocol        (flat skill)"
-puts "  ├── structured_output       (flat skill)"
-puts "  └── sre_compliance          (recursive skill)"
-puts "      ├── pii_redactor        (leaf)"
-puts "      └── audit_trail         (leaf)"
-puts
-
-# Build the robot with skills
-#
-# - runbook_protocol:  Flat skill — adds the 5-step incident diagnosis protocol
-# - structured_output: Flat skill — forces JSON output, sets temperature to 0.2
-# - sre_compliance:    Recursive skill — auto-expands to include pii_redactor
-#                      and audit_trail before its own compliance instructions
-responder = RobotLab.build(
-  **llm_opts,
-  name: "incident_responder",
-  template: :incident_responder,
-  skills: [:runbook_protocol, :structured_output, :sre_compliance],
-  context: {
-    team_name: "Platform Engineering",
-    services: ["payments-api", "user-service", "order-service", "session-service"],
-    on_call_runbook_url: "https://wiki.internal/runbooks/platform-eng"
-  }
-)
-
-# Show what the robot got.
-#
-# `skills` is the DECLARED list. The expanded list (with sre_compliance's
-# nested skills spliced in ahead of it) has no public reader — but you don't
-# need one, because the expansion is visible in the assembled system prompt
-# printed below, which is the thing that actually reaches the model.
-puts "Robot: #{responder.name}"
-puts "Declared skills: #{responder.skills.inspect}"
-puts "Model: #{responder.model}"
-puts
-
-# Display the assembled system prompt.
-# Robot#messages is a public reader over the chat's message list.
-system_msg = responder.messages.find { |m| m.role.to_s == "system" }
-if system_msg
-  prompt = system_msg.content
-  hr
-  puts "Assembled system prompt (#{prompt.length} chars, #{prompt.lines.count} lines):"
-  hr
-  prompt.lines.each_with_index do |line, i|
-    puts "  %3d  %s" % [i + 1, line]
-  end
-  hr
-end
-
-# =============================================================================
-# Also build a plain responder WITHOUT skills for comparison
-# =============================================================================
-
-plain_responder = RobotLab.build(
-  **llm_opts,
-  name: "plain_responder",
-  template: :incident_responder,
-  context: {
-    team_name: "Platform Engineering",
-    services: ["payments-api", "user-service", "order-service", "session-service"],
-    on_call_runbook_url: "https://wiki.internal/runbooks/platform-eng"
-  }
-)
-
-plain_msg = plain_responder.messages.find { |m| m.role.to_s == "system" }
-if plain_msg
-  puts
-  puts "For comparison — plain responder (no skills): #{plain_msg.content.length} chars"
-  puts
-end
-
-# =============================================================================
-# Run Against Simulated Incidents
-# =============================================================================
-
-ALERTS.each_with_index do |alert, index|
-  section "Incident #{index + 1}: #{alert[:label]}"
-
-  result = responder.run(alert[:data])
-  content = result.output.first&.content.to_s
-
-  # Display the response
-  puts "Response:"
-  puts content
-  puts
-end
-
-puts
-puts <<~FOOTER
-  This example demonstrates:
-
-  Flat skills (prepended directly):
-    - runbook_protocol: Adds a 5-step incident diagnosis protocol
-    - structured_output: Forces JSON output and lowers temperature to 0.2
-
-  Recursive skill (auto-expands nested skills):
-    - sre_compliance bundles:
-      - pii_redactor: Redacts email, IP, username, account ID from output
-      - audit_trail: Adds confidence, sources, and assumptions metadata
-
-  Key behaviors:
-    - Skills are just templates — no special syntax or directories
-    - Depth-first expansion: pii_redactor and audit_trail appear before sre_compliance
-    - Config cascade: structured_output sets temperature: 0.2, inherited by the robot
-    - Shared context: all skills and the main template render with the same context hash
-    - Constructor kwargs always override skill/template config
-
-  Template files: #{File.join(__dir__, 'prompts')}
-FOOTER

data/examples/18_rails/.envrc

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

data/examples/18_rails/.gitignore

@@ -1,5 +0,0 @@
-db/*.sqlite3
-db/schema.rb
-log/
-tmp/
-Gemfile.lock

data/examples/18_rails/Gemfile

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-source "https://rubygems.org"
-
-gem "rails", "~> 8.0"
-gem "sqlite3", "~> 2.0"
-gem "puma", "~> 6.0"
-gem "turbo-rails", "~> 2.0"
-
-gem "robot_lab", path: "../.."
-gem "robot_lab-rails", path: "../../../robot_lab-rails"

data/examples/18_rails/README.md

@@ -1,67 +0,0 @@
-# RobotLab Rails 8 Demo
-
-Minimal Rails 8 app that demonstrates RobotLab's full Rails integration:
-
-- **ChatRobot** with a custom `TimeTool`
-- **RobotRunJob** for background execution
-- **Turbo Stream** token streaming to the browser
-- **Persistence** via `RobotLabThread` + `RobotLabResult`
-- **Conversation history** on page reload
-
-## Prerequisites
-
-- Ruby 3.2+
-- [Ollama](https://ollama.com) running locally with the demo model pulled:
-
-  ```bash
-  ollama serve
-  ollama pull qwen3.6
-  ```
-
-No API keys. Override the model with `ROBOT_LAB_PROVIDER` / `ROBOT_LAB_MODEL`,
-and the endpoint with `OLLAMA_API_BASE`.
-
-## Setup
-
-```bash
-cd examples/18_rails
-bin/setup
-```
-
-## Run
-
-```bash
-bin/dev
-# Open http://localhost:3000
-```
-
-## Try It
-
-1. Type "What time is it?" — the robot will call TimeTool and stream the response
-2. Refresh the page — conversation history is preserved
-3. Check `db/development.sqlite3` to see persisted threads and results
-
-## Two things worth copying
-
-**`RobotLab::RailsIntegration::Job` is the real superclass.** There is no
-`RobotLab::Job` alias, so `class RobotRunJob < RobotLab::Job` raises `NameError`
-at boot.
-
-**`tools: :inherit` has to reach `run`.** `Robot#run` defaults to `tools: :none`,
-which hands the provider an empty tool list. The job splats any extra keywords
-into `robot.run`, so the controller passes `tools: :inherit` at enqueue time —
-without it TimeTool is never offered and the model just guesses the time.
-
-## Architecture
-
-```
-app/
-  controllers/chat_controller.rb  — index + create actions
-  views/chat/index.html.erb       — form + Turbo Stream subscription
-  models/                         — RobotLabThread, RobotLabResult
-  robots/chat_robot.rb            — robot factory with system prompt + tool
-  tools/time_tool.rb              — simple RobotLab::Tool subclass
-  jobs/robot_run_job.rb           — enqueues robot.run() with Turbo callbacks
-```
-
-No Redis, no Solid Queue, no asset pipeline. Uses `:async` adapters for both ActiveJob and ActionCable.

data/examples/18_rails/Rakefile

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "config/application"
-Rails.application.load_tasks

data/examples/18_rails/app/controllers/application_controller.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-class ApplicationController < ActionController::Base
-end

data/examples/18_rails/app/controllers/chat_controller.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-class ChatController < ApplicationController
-  def index
-    @thread_id = session[:thread_id] ||= SecureRandom.uuid
-    thread = RobotLabThread.find_by(session_id: @thread_id)
-    @results = thread&.results&.to_a || []
-  end
-
-  def create
-    thread_id = session[:thread_id] ||= SecureRandom.uuid
-    message = params[:message].to_s.strip
-    return redirect_to root_path if message.empty?
-
-    # Persist user message so it appears in history on reload
-    thread = RobotLabThread.find_or_create_by_session_id(thread_id)
-    sequence = thread.results.maximum(:sequence_number).to_i + 1
-    thread.results.create!(
-      robot_name:      "user",
-      sequence_number: sequence,
-      output_data:     [{ role: "user", content: message }],
-      tool_calls_data: [],
-      stop_reason:     "user_message",
-      checksum:        Digest::SHA256.hexdigest(message)
-    )
-
-    # tools: :inherit is forwarded by the job straight through to robot.run.
-    # Without it run() defaults to tools: :none and TimeTool is never offered
-    # to the model, so "What time is it?" gets a guess instead of a tool call.
-    RobotRunJob.perform_later(
-      robot_class: "ChatRobot",
-      message:     message,
-      thread_id:   thread_id,
-      tools:       :inherit
-    )
-
-    respond_to do |format|
-      format.turbo_stream do
-        render turbo_stream: [
-          turbo_stream.append("messages", partial: "chat/user_message", locals: { message: message }),
-          turbo_stream.replace("robot_status", "<div id=\"robot_status\"><span class=\"thinking\">Thinking...</span></div>"),
-          turbo_stream.update("robot_response", ""),
-          turbo_stream.update("robot_tools", ""),
-          turbo_stream.update("robot_errors", "")
-        ]
-      end
-      format.html { redirect_to root_path }
-    end
-  end
-end

data/examples/18_rails/app/jobs/application_job.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-class ApplicationJob < ActiveJob::Base
-end

data/examples/18_rails/app/jobs/robot_run_job.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-# Generic background job for executing any robot asynchronously.
-#
-# Inherits from RobotLab::RailsIntegration::Job — Turbo Stream wiring, thread
-# persistence, and completion/error broadcasting are all handled by the base
-# class. (Note the full namespace: robot_lab-rails defines the class as
-# RobotLab::RailsIntegration::Job and registers no RobotLab::Job alias.)
-#
-# Pass robot_class: at enqueue time to select which robot to run. Any extra
-# keywords are forwarded straight to robot.run — which is how `tools:` gets
-# through, since run defaults to :none and would otherwise send the model an
-# empty tool list.
-#
-# @example Enqueue from a controller
-#   RobotRunJob.perform_later(
-#     robot_class: "ChatRobot",
-#     message:     params[:message],
-#     thread_id:   session_id,
-#     tools:       :inherit
-#   )
-#
-class RobotRunJob < RobotLab::RailsIntegration::Job
-  queue_as :default
-end

data/examples/18_rails/app/models/application_record.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-class ApplicationRecord < ActiveRecord::Base
-  self.abstract_class = true
-end