robot_lab 0.1.0 → 0.2.1

data/docs/superpowers/specs/2026-04-14-ractor-integration-design.md

@@ -1,258 +0,0 @@
-# Ractor Integration Design
-
-**Date:** 2026-04-14
-**Status:** Approved
-**Gems:** `ractor_queue`, `ractor-wrapper`
-
-## Goals
-
-1. True CPU parallelism (GIL-bypassing) for CPU-bound tool execution
-2. True CPU parallelism for parallel robot execution in Networks
-3. Use `ractor_queue` as the queue backbone for both tracks
-4. Use `ractor-wrapper` to expose shared `Memory` to Ractor workers
-5. Deliver both tracks as independent, composable layers
-
-## Non-Goals
-
-- Making `ruby_llm` or the `async` gem Ractor-safe
-- Replacing the existing `:async` concurrency model (it remains the default)
-- Ractor-isolating `Robot` instances that are long-lived across multiple tasks
-
----
-
-## Architecture Overview
-
-Two parallel tracks share a frozen-message convention and `ractor_queue` as the communication backbone.
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                        Thread/Fiber World                        │
-│  Robot (ruby_llm, async)  ──▶  Tool.call()  ──▶  RobotResult  │
-│           │                        │                             │
-│     BusPoller                 ractor_safe?                       │
-│    (ractor_queue)              │        │                        │
-└────────────────────────────────│────────│────────────────────────┘
-                                 │  yes   │  no
-             ┌───────────────────┘        └──► Thread executor
-             ▼
-┌─────────────────────────────────────────────────────────────────┐
-│                        Ractor World                              │
-│  RactorWorkerPool  ◀──ractor_queue──  frozen RactorJob          │
-│  (N Ractor workers)                                              │
-│         │                                                        │
-│  RactorMemoryProxy  (ractor-wrapper around Memory)              │
-│  ◀── get/set via Ractor messages ──▶                            │
-└─────────────────────────────────────────────────────────────────┘
-```
-
-**Key constraint:** only frozen, `Ractor.shareable?` objects cross Ractor boundaries. A `RactorJob` is a `Data.define` struct (shareable by design) carrying a frozen payload and a per-job reply `ractor_queue`.
-
----
-
-## Shared Infrastructure
-
-### `RactorJob`
-
-```ruby
-RactorJob = Data.define(:id, :type, :payload, :reply_queue)
-```
-
-Single cross-boundary carrier for both tracks. `payload` must be frozen by the caller before submission. `reply_queue` is a `ractor_queue` instance (Ractor-safe).
-
-### `RactorJobError`
-
-```ruby
-RactorJobError = Data.define(:message, :backtrace)
-```
-
-Frozen error representation for exceptions that occur inside a Ractor worker. Serialized at the Ractor boundary, re-raised on the thread side.
-
-### `RobotSpec`
-
-```ruby
-RobotSpec = Data.define(:name, :template, :system_prompt, :config_hash)
-```
-
-Carries everything needed to reconstruct a `Robot` inside a Ractor. All fields must be frozen strings/hashes.
-
-### `RactorBoundary`
-
-A utility module with a `freeze_deep(obj)` method that recursively freezes nested `Hash`/`Array` structures before they cross a Ractor boundary. Similar in spirit to the existing `deep_dup` in `Utils`. Raises `RobotLab::RactorBoundaryError` (a subclass of `RobotLab::Error`) if a value cannot be made shareable (e.g., a live IO or Proc).
-
-```ruby
-module RactorBoundary
-  def self.freeze_deep(obj)
-    case obj
-    when Hash  then obj.transform_values { freeze_deep(_1) }.freeze
-    when Array then obj.map { freeze_deep(_1) }.freeze
-    else            obj.frozen? ? obj : obj.dup.freeze
-    end
-  rescue TypeError => e
-    raise RobotLab::RactorBoundaryError, "Cannot make value Ractor-shareable: #{e.message}"
-  end
-end
-```
-
----
-
-## Track 1: RactorWorkerPool (Tool CPU Parallelism)
-
-### Tool opt-in
-
-`RobotLab::Tool` gets a `ractor_safe` class macro (default `false`). Ractor-safe tools must be stateless — no captured mutable closures, no non-shareable constants.
-
-```ruby
-class EmbeddingTool < RobotLab::Tool
-  ractor_safe true
-
-  def execute(text:)
-    # CPU-bound embedding work — runs inside a Ractor worker
-  end
-end
-```
-
-The framework raises `RobotLab::ConfigurationError` at class-definition time if a declared-safe tool captures unshareable state (detected via `Ractor.shareable?` check on the class object).
-
-### `RactorWorkerPool`
-
-A pool of N Ractor workers (configurable via `RunConfig#ractor_pool_size`, default `Etc.nprocessors`). Each worker runs:
-
-```ruby
-loop do
-  job = work_queue.pop                    # blocks on ractor_queue
-  result = dispatch(job)                  # instantiates tool class, calls execute
-  job.reply_queue.push(result)            # frozen result back to caller
-rescue => e
-  job.reply_queue.push(RactorJobError.new(message: e.message, backtrace: e.backtrace))
-end
-```
-
-The pool is lazily initialized on first use and shared across robots in a Network via the existing `RunConfig` hierarchy. It lives for the lifetime of the process (or the `RunConfig` that owns it). `RactorWorkerPool#shutdown` drains in-flight jobs, then closes the work `ractor_queue` so all workers exit their loops cleanly. `RunConfig` calls `shutdown` on `ObjectSpace` finalizer or explicit `RobotLab.shutdown` call.
-
-If a worker Ractor crashes (unhandled exception kills the Ractor), the pool detects the dead Ractor via `Ractor#take` and spawns a replacement. The failed job's reply queue receives a `RactorJobError`.
-
-### Submission path (inside `Robot#call_tool`)
-
-1. Look up `tool_class` from `ToolManifest`
-2. Check `tool_class.ractor_safe?`
-3. **If yes:** `RactorBoundary.freeze_deep(args)`, build `RactorJob`, push to pool's work `ractor_queue`, block on reply queue
-4. **If no:** run in current thread/fiber as today
-5. On reply: if result is `RactorJobError`, re-raise as `RobotLab::ToolError` in the calling thread
-
-### `RunConfig` additions
-
-```ruby
-ractor_pool_size: :auto   # :auto = Etc.nprocessors, or an Integer
-```
-
----
-
-## Track 2: RactorMemoryProxy + RactorNetworkScheduler (Robot Parallelism)
-
-### `RactorMemoryProxy`
-
-Wraps the existing `Memory` instance via `ractor-wrapper`. The wrapper Ractor acts as a method-dispatch server: it receives frozen messages and replies with frozen results.
-
-Supported operations proxied across the Ractor boundary:
-
-| Message | Reply |
-|---------|-------|
-| `[:get, key]` | frozen value or `nil` |
-| `[:set, key, frozen_value]` | `:ok` |
-| `[:keys]` | frozen array of keys |
-
-Subscriptions (callbacks) are **not** proxied — closures are not Ractor-safe. Robots that need reactive subscriptions use the thread-side `Memory` directly. `RactorMemoryProxy` is for Ractor workers that need read/write access to shared state.
-
-No changes to `Memory` itself.
-
-### `RactorNetworkScheduler`
-
-Replaces `SimpleFlow::Pipeline#call_parallel` for Networks with `parallel_mode: :ractor`. Distributes frozen task descriptions to worker Ractors, collects frozen results.
-
-`depends_on` ordering is preserved: the scheduler reads the pipeline's existing dependency graph (from `SimpleFlow::Pipeline`) and uses it to determine which tasks are ready to dispatch. A task is submitted to the `ractor_queue` only once all its dependencies have resolved. This mirrors how `call_parallel` works today — the scheduler wraps the same topological resolution logic.
-
-```
-Scheduler  ──► ractor_queue (frozen RobotSpec + task payload)
-                    │
-                    ▼
-              Worker Ractor
-              (constructs fresh Robot from RobotSpec,
-               runs task, freezes RobotResult,
-               pushes to reply ractor_queue)
-                    │
-Scheduler  ◀── ractor_queue (frozen results)
-```
-
-Each worker Ractor constructs its own `Robot` instance from a `RobotSpec`. The LLM call happens inside the Ractor. This is safe because `ruby_llm` HTTP calls use no shared mutable state between instances — the Ractor constraint is about *shared* non-shareable objects, not fresh instances created inside a Ractor.
-
-Results are collected via a reply `ractor_queue` and assembled into the pipeline's `SimpleFlow::Result` context on the thread side.
-
-### `BusPoller` queue upgrade
-
-`BusPoller#@robot_queues` changes from `Hash<String, Array>` to `Hash<String, ractor_queue>`. Delivery mechanics (mutex-guarded drain, `process_and_drain`) are unchanged — only the backing store is swapped. This makes `BusPoller` capable of receiving deliveries from Ractor workers.
-
-### Network opt-in
-
-```ruby
-network = RobotLab.create_network(name: "analysis", parallel_mode: :ractor) do
-  task :sentiment, sentiment_robot, depends_on: :none
-  task :entities,  entity_robot,    depends_on: :none
-  task :summarize, summary_robot,   depends_on: [:sentiment, :entities]
-end
-```
-
-`parallel_mode: :async` remains the default and is unchanged.
-
----
-
-## Error Handling
-
-| Scenario | Mechanism |
-|----------|-----------|
-| Tool raises inside Ractor worker | Serialized as `RactorJobError`, re-raised as `RobotLab::ToolError` in calling thread |
-| Robot raises inside `RactorNetworkScheduler` | Serialized as `RactorJobError`, surfaced as failed step in `SimpleFlow::Result` |
-| Worker Ractor crashes (unhandled exception) | Pool detects dead Ractor, spawns replacement, failed job gets `RactorJobError` on reply queue |
-| Non-shareable value submitted to pool | `RobotLab::RactorBoundaryError` raised before the Ractor boundary |
-
----
-
-## Testing
-
-- `RactorWorkerPool` is testable standalone — no Robot or Network required
-- `RactorMemoryProxy` is testable standalone — wrap a `Memory`, call proxy methods from a test Ractor
-- Tools that declare `ractor_safe true` should pass `assert_ractor_safe(tool_class)` — a test helper that spins up a single-worker pool and round-trips a frozen payload
-- `RactorNetworkScheduler` tests use a minimal two-robot network with `parallel_mode: :ractor`
-- All existing tests are unaffected — `:async` remains the default; no existing class is modified in a breaking way
-
----
-
-## New Files
-
-| File | Purpose |
-|------|---------|
-| `lib/robot_lab/ractor_job.rb` | `RactorJob`, `RactorJobError`, `RobotSpec` data classes |
-| `lib/robot_lab/ractor_boundary.rb` | `RactorBoundary.freeze_deep` utility |
-| `lib/robot_lab/ractor_worker_pool.rb` | `RactorWorkerPool` — N Ractor workers fed by `ractor_queue` |
-| `lib/robot_lab/ractor_memory_proxy.rb` | `RactorMemoryProxy` — `ractor-wrapper` around `Memory` |
-| `lib/robot_lab/ractor_network_scheduler.rb` | `RactorNetworkScheduler` — distributes robot tasks to Ractor workers |
-
-## Modified Files
-
-| File | Change |
-|------|--------|
-| `lib/robot_lab/tool.rb` | Add `ractor_safe` class macro |
-| `lib/robot_lab/robot.rb` | Check `ractor_safe?` in `call_tool`, submit to pool if true |
-| `lib/robot_lab/run_config.rb` | Add `ractor_pool_size:` field |
-| `lib/robot_lab/bus_poller.rb` | Swap `Array` queues for `ractor_queue` instances |
-| `lib/robot_lab/network.rb` | Add `parallel_mode:` option, delegate to `RactorNetworkScheduler` |
-| `lib/robot_lab/error.rb` | Add `RobotLab::RactorBoundaryError` subclass |
-| `lib/robot_lab.rb` | Require new files |
-
----
-
-## Dependencies to Add
-
-```ruby
-gem "ractor_queue"
-gem "ractor-wrapper"
-```

data/lib/generators/robot_lab/install_generator.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-require "rails/generators/active_record"
-
-module RobotLab
-  module Generators
-    # Installs RobotLab into a Rails application
-    #
-    # Usage:
-    #   rails generate robot_lab:install
-    #
-    class InstallGenerator < ::Rails::Generators::Base
-      include ::Rails::Generators::Migration
-
-      source_root File.expand_path("templates", __dir__)
-
-      class_option :skip_migration, type: :boolean, default: false,
-                                    desc: "Skip database migration generation"
-      class_option :skip_job, type: :boolean, default: false,
-                              desc: "Skip background job generation"
-
-      # Returns the next migration number for ActiveRecord migrations.
-      #
-      # @param dirname [String] the migrations directory
-      # @return [String] the next migration number
-      def self.next_migration_number(dirname)
-        ::ActiveRecord::Generators::Base.next_migration_number(dirname)
-      end
-
-      # Creates the RobotLab initializer file.
-      #
-      # @return [void]
-      def create_initializer
-        template "initializer.rb.tt", "config/initializers/robot_lab.rb"
-      end
-
-      # Creates the database migration for RobotLab tables.
-      #
-      # @return [void]
-      def create_migration
-        return if options[:skip_migration]
-
-        migration_template "migration.rb.tt", "db/migrate/create_robot_lab_tables.rb"
-      end
-
-      # Creates the ActiveRecord model files.
-      #
-      # @return [void]
-      def create_models
-        return if options[:skip_migration]
-
-        template "thread_model.rb.tt", "app/models/robot_lab_thread.rb"
-        template "result_model.rb.tt", "app/models/robot_lab_result.rb"
-      end
-
-      # Creates the background job for robot execution.
-      #
-      # @return [void]
-      def create_job
-        return if options[:skip_job]
-
-        template "job.rb.tt", "app/jobs/robot_run_job.rb"
-      end
-
-      # Creates the robots and tools directories.
-      #
-      # @return [void]
-      def create_directories
-        empty_directory "app/robots"
-        empty_directory "app/tools"
-      end
-
-      # Displays post-installation instructions.
-      #
-      # @return [void]
-      def display_post_install
-        say ""
-        say "RobotLab installed successfully!", :green
-        say ""
-        say "Next steps:"
-        say "  1. Run migrations: rails db:migrate"
-        say "  2. Configure your LLM API keys in config/initializers/robot_lab.rb"
-        say "  3. Generate your first robot: rails g robot_lab:robot MyRobot"
-        say "  4. Enqueue robot runs via RobotRunJob (app/jobs/robot_run_job.rb)" unless options[:skip_job]
-        say ""
-      end
-    end
-  end
-end

data/lib/generators/robot_lab/job_generator.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-
-module RobotLab
-  module Generators
-    # Generates a RobotLab job subclass pre-wired to a specific robot class.
-    #
-    # Usage:
-    #   rails generate robot_lab:job NAME [options]
-    #
-    # Examples:
-    #   rails generate robot_lab:job Support
-    #   # => app/jobs/support_job.rb  (robot_class SupportRobot)
-    #
-    class JobGenerator < ::Rails::Generators::NamedBase
-      source_root File.expand_path("templates", __dir__)
-
-      class_option :queue, type: :string, default: "default",
-                           desc: "ActiveJob queue name"
-
-      # Creates the job file.
-      #
-      # @return [void]
-      def create_job_file
-        template "robot_job.rb.tt", "app/jobs/#{file_name}_job.rb"
-      end
-
-      private
-
-      def queue_name
-        options[:queue]
-      end
-
-      def robot_class_name
-        "#{class_name}Robot"
-      end
-    end
-  end
-end

data/lib/generators/robot_lab/robot_generator.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require "rails/generators"
-
-module RobotLab
-  module Generators
-    # Generates a new RobotLab robot
-    #
-    # Usage:
-    #   rails generate robot_lab:robot NAME [options]
-    #
-    # Examples:
-    #   rails generate robot_lab:robot Support
-    #   rails generate robot_lab:robot Billing --description="Handles billing queries"
-    #
-    class RobotGenerator < ::Rails::Generators::NamedBase
-      source_root File.expand_path("templates", __dir__)
-
-      class_option :description, type: :string, default: nil,
-                                 desc: "Robot description"
-      class_option :routing, type: :boolean, default: false,
-                             desc: "Generate a routing robot"
-      class_option :tools, type: :array, default: [],
-                           desc: "List of tools to include"
-
-      # Creates the robot class file.
-      #
-      # @return [void]
-      def create_robot_file
-        if options[:routing]
-          template "routing_robot.rb.tt", "app/robots/#{file_name}_robot.rb"
-        else
-          template "robot.rb.tt", "app/robots/#{file_name}_robot.rb"
-        end
-      end
-
-      # Creates the robot test file.
-      #
-      # @return [void]
-      def create_test_file
-        template "robot_test.rb.tt", "test/robots/#{file_name}_robot_test.rb"
-      end
-
-      private
-
-      def robot_description
-        options[:description] || "A helpful #{class_name.titleize} robot"
-      end
-
-      def robot_tools
-        options[:tools]
-      end
-    end
-  end
-end

data/lib/generators/robot_lab/templates/initializer.rb.tt

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-# RobotLab Configuration
-#
-# RobotLab uses MywayConfig for configuration. Settings are loaded from:
-#
-#   1. Bundled defaults (lib/robot_lab/config/defaults.yml)
-#   2. Environment-specific overrides (development, test, production)
-#   3. XDG user config (~/.config/robot_lab/config.yml)
-#   4. Project config (./config/robot_lab.yml)
-#   5. Environment variables (ROBOT_LAB_* prefix)
-#
-# Create config/robot_lab.yml for project-specific settings:
-#
-#   defaults:
-#     ruby_llm:
-#       anthropic_api_key: <%%= ENV['ANTHROPIC_API_KEY'] %>
-#       openai_api_key: <%%= ENV['OPENAI_API_KEY'] %>
-#       model: claude-sonnet-4
-#       request_timeout: 180
-#
-#   development:
-#     ruby_llm:
-#       log_level: :debug
-#
-#   test:
-#     streaming_enabled: false
-#     ruby_llm:
-#       model: claude-3-haiku-20240307
-#       request_timeout: 30
-#
-# Or use environment variables with double underscores for nested keys:
-#
-#   ROBOT_LAB_RUBY_LLM__ANTHROPIC_API_KEY=sk-ant-...
-#   ROBOT_LAB_RUBY_LLM__MODEL=claude-sonnet-4
-#
-# RobotLab also falls back to standard provider env vars
-# (e.g. ANTHROPIC_API_KEY, OPENAI_API_KEY) when the prefixed
-# versions are not set.
-
-# Set the RobotLab logger to use Rails.logger
-RobotLab.config.logger = Rails.logger

data/lib/generators/robot_lab/templates/job.rb.tt

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-# Generic background job for executing any robot asynchronously.
-#
-# Inherits from RobotLab::Job — Turbo Stream wiring, thread persistence,
-# and completion/error broadcasting are all handled by the base class.
-#
-# Pass robot_class: at enqueue time to select which robot to run, or
-# generate a dedicated job with `rails generate robot_lab:job NAME` to
-# bind a job class to a specific robot via the robot_class DSL.
-#
-# @example Enqueue from a controller
-#   RobotRunJob.perform_later(
-#     robot_class: "SupportRobot",
-#     message:     params[:message],
-#     thread_id:   session_id
-#   )
-#
-class RobotRunJob < RobotLab::Job
-  queue_as :default
-end

data/lib/generators/robot_lab/templates/migration.rb.tt

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-class CreateRobotLabTables < ActiveRecord::Migration[7.0]
-  def change
-    create_table :robot_lab_threads do |t|
-      t.string :session_id, null: false, index: { unique: true }
-      t.text :initial_input
-      t.json :input_metadata, default: {}
-      t.json :state_data, default: {}
-      t.text :last_user_message
-      t.datetime :last_user_message_at
-
-      t.timestamps
-    end
-
-    create_table :robot_lab_results do |t|
-      t.string :session_id, null: false, index: true
-      t.string :robot_name, null: false
-      t.integer :sequence_number, null: false, default: 0
-      t.json :output_data, default: []
-      t.json :tool_calls_data, default: []
-      t.string :stop_reason
-      t.string :checksum
-
-      t.timestamps
-    end
-
-    add_index :robot_lab_results, [:session_id, :sequence_number]
-    add_foreign_key :robot_lab_results, :robot_lab_threads,
-                    column: :session_id, primary_key: :session_id
-  end
-end

data/lib/generators/robot_lab/templates/result_model.rb.tt

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-# RobotLab Result Model
-#
-# Stores robot execution results for history persistence.
-#
-class RobotLabResult < ApplicationRecord
-  belongs_to :thread,
-             class_name: "RobotLabThread",
-             foreign_key: :session_id,
-             primary_key: :session_id
-
-  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) }
-
-  # Get output messages as RobotLab::Message objects
-  #
-  # @return [Array<RobotLab::Message>]
-  #
-  def output_messages
-    (output_data || []).map do |data|
-      RobotLab::Message.from_hash(data.symbolize_keys)
-    end
-  end
-
-  # Get tool calls as RobotLab::Message objects
-  #
-  # @return [Array<RobotLab::Message>]
-  #
-  def tool_call_messages
-    (tool_calls_data || []).map do |data|
-      RobotLab::Message.from_hash(data.symbolize_keys)
-    end
-  end
-
-  # Convert to RobotLab::RobotResult
-  #
-  # @return [RobotLab::RobotResult]
-  #
-  def to_robot_result
-    RobotLab::RobotResult.new(
-      robot_name: robot_name,
-      output: output_messages,
-      tool_calls: tool_call_messages,
-      stop_reason: stop_reason
-    )
-  end
-end

data/lib/generators/robot_lab/templates/robot.rb.tt

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-# <%= class_name %> Robot
-#
-# <%= robot_description %>
-#
-class <%= class_name %>Robot
-  SYSTEM_PROMPT = <<~PROMPT
-    You are a helpful <%= class_name.titleize %> assistant.
-
-    Your role is to assist users with their requests in a friendly and efficient manner.
-  PROMPT
-
-  def self.build(**options)
-    RobotLab.build(
-      name: "<%= file_name %>",
-      description: "<%= robot_description %>",
-      system_prompt: SYSTEM_PROMPT,
-      local_tools: tools,
-      **options
-    )
-  end
-
-  def self.tools
-    [
-      <%- robot_tools.each do |tool| -%>
-      # <%= tool.camelize %>,
-      <%- end -%>
-    ]
-  end
-end

data/lib/generators/robot_lab/templates/robot_job.rb.tt

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-# Background job that runs <%= robot_class_name %> asynchronously.
-#
-# Inherits from RobotLab::Job — Turbo Stream wiring, thread persistence,
-# and completion/error broadcasting are all handled by the base class.
-#
-# @example Enqueue from a controller
-#   <%= class_name %>Job.perform_later(
-#     message:   params[:message],
-#     thread_id: session_id
-#   )
-#
-class <%= class_name %>Job < RobotLab::Job
-  queue_as :<%= queue_name %>
-
-  robot_class <%= robot_class_name %>
-end

data/lib/generators/robot_lab/templates/robot_test.rb.tt

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class <%= class_name %>RobotTest < ActiveSupport::TestCase
-  def setup
-    @robot = <%= class_name %>Robot.build
-  end
-
-  test "robot has correct name" do
-    assert_equal "<%= file_name %>", @robot.name
-  end
-
-  test "robot has description" do
-    assert_not_nil @robot.description
-  end
-
-  test "robot has system prompt" do
-    assert_not_nil @robot.system_prompt
-  end
-
-  # Add more tests as needed:
-  #
-  # test "robot runs successfully" do
-  #   result = @robot.run("Hello, I need help")
-  #   assert result.is_a?(RobotLab::RobotResult)
-  #   assert_not_nil result.last_text_content
-  # end
-  #
-  # test "robot has expected tools" do
-  #   tool_names = @robot.local_tools.map(&:name)
-  #   assert_includes tool_names, "expected_tool_name"
-  # end
-end