robot_lab 0.0.11 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f4b2a3fafbdf3a54de3044b57597b42d86c68bd2afdad6ce866ac82483e61091
-  data.tar.gz: 5137cff56485a26fabe5ab6606b144c4c3c21c1673ecec1d2254a392e015c25c
+  metadata.gz: 9a1898a9909e7fdd795350b7f10cf80c57d69c1cec1b2533e56b9652cc2b3930
+  data.tar.gz: 641d4bd4022788a4ce53965a1ff8413ccf1420f71a1981f975618f825c29b80c
 SHA512:
-  metadata.gz: 33045f27ec803094a020caee4133c1d6c65887446330c294d9a9babd56a0fe7e71979fe0d032c2421488d1dcae886ad784a78dae579ba01b2786b5f9f91c0172
-  data.tar.gz: 5554296590bfb3dea031c95090ef8a47e946ac1c7a92b3efc6924439f55df7267e0b04d385e2332ea827099c37688c4988aa908caf5bb9d2f21eabc2c50c3167
+  metadata.gz: d51060ef5a929f5d9b895ba7e11220d47765fb92a342e9c3c76d5c223043747d53e7b924c9ecc53fccc90b90a0b08c180e75d5955527cc8b3cd99411a9c64026
+  data.tar.gz: c59f404518a69d97c65d960982367c582b8410d3754d3cf238ab8117f400eb229a02891bb449ab311bceaa16f0382c6cfd355c8f976bcc8f49b8191f8035e221

data/CHANGELOG.md

@@ -8,6 +8,63 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.0] - 2026-04-29
+
+### Added
+
+- **`RobotLab::Job` base class** (`lib/robot_lab/rails_integration/job.rb`) — `ActiveJob::Base` subclass encapsulating the full robot-run lifecycle for Rails background jobs
+  - `robot_class` DSL — bind a job subclass to a specific robot class at the class level; per-subclass, not inherited
+  - `perform(message:, robot_class: nil, thread_id: nil, **context)` — resolves robot class, wires Turbo Stream callbacks, runs robot, persists `RobotResult`, broadcasts completion/error
+  - `thread_id` omitted → fire-and-forget mode (no persistence, no broadcasting)
+  - Turbo Stream wiring is a graceful no-op when `turbo-rails` is absent
+  - `retry_on StandardError, wait: 5.seconds, attempts: 3` and `discard_on ActiveJob::DeserializationError` configured by default
+  - `RobotLab::Job` top-level alias registered in `robot_lab.rb` when Rails is present so job subclasses can write `< RobotLab::Job`
+- **`rails generate robot_lab:job NAME`** (`lib/generators/robot_lab/job_generator.rb`) — generates a dedicated job subclass pre-wired to `<NAME>Robot` via `robot_class` DSL
+  - `--queue` option (default `"default"`)
+  - Template: `lib/generators/robot_lab/templates/robot_job.rb.tt`
+- **`max_concurrent_robots` field on `RunConfig`** — caps the number of fiber-concurrent robots in a parallel network execution; passed to `SimpleFlow::Pipeline#call_parallel` as `max_concurrent:`
+- **Example 31: Launch Assessment** (`examples/31_launch_assessment.rb`) — six `AnalystRobot` instances run in parallel (market, competitive, tech, risk, financial, legal) with a cap of 4 concurrent robots; a `LaunchDirector` synthesizes findings into a GO/NO-GO decision
+- **20 unit tests for `RobotLab::RailsIntegration::Job`** (`test/robot_lab/rails_integration/job_test.rb`) covering `robot_class` DSL, `resolve_robot_class`, `setup_thread`, `build_robot`, `broadcast_completion`, `broadcast_error`, and `turbo_available?`
+
+### Changed
+
+- Bumped version to 0.1.0
+- **`RobotRunJob` (generated job)** is now a thin two-line subclass of `RobotLab::Job` — all lifecycle logic lives in the base class
+- **`job.rb.tt` install generator template** updated to the thin-subclass pattern
+- **`examples/18_rails` `RobotRunJob`** updated to thin subclass
+- **`Network#call_parallel`** now forwards `max_concurrent: @config.max_concurrent_robots` to `SimpleFlow::Pipeline`, enabling the concurrency cap introduced in `RunConfig`
+
+### Fixed
+
+- **`Message.from_hash`** — records persisted without a `type` key (e.g. legacy user-message rows) previously raised `ArgumentError: missing keyword: :type`; `from_hash` now defaults a nil or absent `type` to `"text"` so old rows deserialize as `TextMessage` without error
+
+### Documentation
+
+- **`docs/guides/rails-integration.md`** — rewrote Background Jobs section to document `RobotLab::Job` base class, lifecycle steps, `robot_class` DSL, dedicated job generator, fire-and-forget mode, and when to use a custom `ApplicationJob` instead
+- **`docs/api/messages/index.md`** — added "Deserializing from Hash" section documenting `Message.from_hash` dispatch logic and the missing-type fallback
+- **README.md** — expanded Rails Integration section with full Background Jobs documentation including both generic and dedicated job patterns
+
+## [0.0.12] - 2026-04-18
+
+### Added
+
+- **README: Context Window Compression section** — documents `robot.compress_history` with threshold tuning (`recent_turns`, `keep_threshold`, `drop_threshold`) and summarizer lambda pattern
+- **README: Convergence Detection section** — documents `RobotLab::Convergence.detected?` / `.similarity` with network router fast-path example
+- **README: Structured Delegation section** — documents `robot.delegate(to:, task:)` sync and async modes, `DelegationFuture` fan-out pattern, and timeout handling
+- **README: Ractor Parallelism section** — documents `ractor_safe true` tool macro and `parallel_mode: :ractor` network mode with link to full guide
+- **`docs/guides/building-robots.md`** — added matching sections for all four features above with expanded API detail, `DelegationFuture` method table, and convergence router example
+- **`docs/api/core/result.md`** — new API reference for `RobotResult`: attributes, token tracking, delegation metadata, persistence (`export`, `from_hash`, `checksum`), and debug fields
+- **`docs/api/errors.md`** — new error hierarchy reference covering all `RobotLab::Error` subclasses (`ConfigurationError`, `DependencyError`, `InferenceError`, `ToolLoopError`, `ToolNotFoundError`, `MCPError`, `BusError`, `RactorBoundaryError`, `ToolError`, `DelegationFuture::DelegationTimeout`) with rescue examples
+
+### Changed
+
+- Bumped version to 0.0.12
+- Updated `bigdecimal` to 4.1.2
+- Updated `protocol-http` to 0.62.2
+- Updated `protocol-websocket` to 0.21.0
+- Updated `rake` to 13.4.2
+- Updated `sqlite3` to 2.9.3
+
 ## [0.0.11] - 2026-04-14
 
 ### Added

data/README.md

@@ -700,6 +700,136 @@ reviewer.learnings          # => ["This codebase prefers map/collect..."]
 reviewer.learn("new fact")  # deduplicates before storing
 ```
 
+## Context Window Compression
+
+`robot.compress_history` prunes old conversation turns using TF-IDF cosine similarity, keeping only turns that are relevant to the most recent context. System messages and tool call/result pairs are always preserved.
+
+```ruby
+# Basic compression: protect the 3 most recent turns, drop unrelated old turns
+robot.compress_history
+
+# Tune the thresholds
+robot.compress_history(
+  recent_turns:   5,    # protect this many recent user+assistant pairs
+  keep_threshold: 0.6,  # turns scoring >= this are kept verbatim
+  drop_threshold: 0.2   # turns scoring < this are dropped
+)
+
+# Summarize medium-relevance turns instead of dropping them
+summarizer_bot = RobotLab.build(name: "summarizer", system_prompt: "Summarize concisely.")
+robot.compress_history(
+  summarizer: ->(text) { summarizer_bot.run("One sentence: #{text}").reply }
+)
+```
+
+Requires the optional `classifier` gem (`~> 2.3`). Add it to your Gemfile:
+
+```ruby
+gem "classifier", "~> 2.3"
+```
+
+## Convergence Detection
+
+`RobotLab::Convergence` detects when two independent agents have reached the same conclusion using TF-IDF cosine similarity. Use it as a router fast-path to skip an expensive reconciler LLM call when verifiers already agree.
+
+```ruby
+# Check similarity directly
+score = RobotLab::Convergence.similarity(result_a.reply, result_b.reply)
+# => 0.92
+
+# Boolean check against a threshold (default: 0.85)
+RobotLab::Convergence.detected?(result_a.reply, result_b.reply)
+# => true
+
+# Use a custom threshold
+RobotLab::Convergence.detected?(text_a, text_b, threshold: 0.75)
+```
+
+A common pattern is wiring convergence into a network router to skip reconciliation:
+
+```ruby
+router = ->(args) do
+  a = args.context[:verifier_a]&.reply.to_s
+  b = args.context[:verifier_b]&.reply.to_s
+  RobotLab::Convergence.detected?(a, b) ? nil : ["reconciler"]
+end
+
+network = RobotLab.create_network(name: "verify", router: router) do
+  # ...
+end
+```
+
+Requires the `classifier` gem (`~> 2.3`).
+
+## Structured Delegation
+
+`robot.delegate(to:, task:)` dispatches work to another robot and returns the result, with duration and token metadata attached. Pass `async: true` for non-blocking fan-out.
+
+```ruby
+analyst  = RobotLab.build(name: "analyst",  system_prompt: "Analyze data.")
+writer   = RobotLab.build(name: "writer",   system_prompt: "Write reports.")
+manager  = RobotLab.build(name: "manager",  system_prompt: "Coordinate work.")
+
+# Synchronous delegation — blocks until done
+result = manager.delegate(to: analyst, task: "Analyze Q3 sales data")
+puts result.reply
+puts "%.2fs, %d tokens" % [result.duration, result.output_tokens]
+
+# Asynchronous fan-out — returns immediately
+f1 = manager.delegate(to: analyst, task: "Analyze Q3 sales", async: true)
+f2 = manager.delegate(to: writer,  task: "Draft Q3 summary", async: true)
+
+# Do other work here while both run in parallel...
+
+analysis = f1.value           # blocks until resolved
+summary  = f2.value           # blocks until resolved
+
+# With a timeout
+result = f1.value(timeout: 30)  # raises DelegationFuture::DelegationTimeout if too slow
+```
+
+`DelegationFuture` attributes:
+
+```ruby
+future.resolved?      # => true/false (non-blocking poll)
+future.robot_name     # => "analyst"
+future.delegated_by   # => "manager"
+```
+
+## Ractor Parallelism
+
+RobotLab supports true CPU parallelism via Ruby Ractors — isolated execution contexts that bypass the GVL. Two modes are available:
+
+**CPU-bound tools** — mark a tool `ractor_safe true` and RobotLab automatically routes its calls through a global `RactorWorkerPool` instead of running inline:
+
+```ruby
+class TranscribeAudio < RubyLLM::Tool
+  ractor_safe true
+  description "Transcribe an audio file"
+  param :path, type: :string, desc: "Path to audio file"
+
+  def execute(path:)
+    AudioTranscriber.run(path)  # pure computation, no shared mutable state
+  end
+end
+```
+
+**Parallel robot networks** — pass `parallel_mode: :ractor` when creating a network to dispatch independent robots across hardware threads simultaneously:
+
+```ruby
+network = RobotLab.create_network(name: "analysis", parallel_mode: :ractor) do
+  task :fetch,     fetcher_robot,    depends_on: :none
+  task :sentiment, sentiment_robot,  depends_on: [:fetch]
+  task :entities,  entity_robot,     depends_on: [:fetch]   # runs in parallel with sentiment
+  task :summarize, summary_robot,    depends_on: [:sentiment, :entities]
+end
+
+results = network.run(message: "Analyze customer feedback")
+# => { "fetch" => "...", "sentiment" => "positive", "entities" => "...", "summarize" => "..." }
+```
+
+See the [Ractor Parallelism guide](https://madbomber.github.io/robot_lab/guides/ractor-parallelism) for constraints, the frozen-data contract, and `RactorMemoryProxy` for shared state.
+
 ## Rails Integration
 
 ```bash
@@ -712,6 +842,56 @@ This creates:
 - `app/robots/` - Directory for your robots
 - Database tables for conversation history
 
+### Background Jobs
+
+RobotLab ships with `RobotLab::Job`, an `ActiveJob::Base` subclass that handles the full robot-run lifecycle: robot class resolution, Turbo Stream wiring, thread-record persistence, and completion/error broadcasting.
+
+**Generic job** (robot class supplied at enqueue time):
+
+```bash
+rails generate robot_lab:install   # creates app/jobs/robot_run_job.rb
+```
+
+```ruby
+# app/jobs/robot_run_job.rb  (generated)
+class RobotRunJob < RobotLab::Job
+  queue_as :default
+end
+
+# Enqueue from a controller:
+RobotRunJob.perform_later(
+  robot_class: "SupportRobot",
+  message:     params[:message],
+  thread_id:   session_id
+)
+```
+
+**Dedicated job** (robot class bound at the class level via DSL):
+
+```bash
+rails generate robot_lab:job Support            # binds to SupportRobot, queue: default
+rails generate robot_lab:job Support --queue ai # custom queue
+```
+
+```ruby
+# app/jobs/support_job.rb  (generated)
+class SupportJob < RobotLab::Job
+  queue_as :default
+  robot_class SupportRobot
+end
+
+# Enqueue (no robot_class: needed):
+SupportJob.perform_later(message: params[:message], thread_id: session_id)
+```
+
+When `thread_id` is provided and [turbo-rails](https://github.com/hotwired/turbo-rails) is installed, `RobotLab::Job` automatically:
+
+- Wires `on_content` / `on_tool_call` Turbo Stream callbacks so the UI updates in real time
+- Broadcasts a **completion** event to `"robot_lab_thread_#{thread_id}"` when the run finishes
+- Broadcasts an **error** event (HTML-escaped) if the job raises
+
+Omitting `thread_id` runs the robot in fire-and-forget mode — no persistence, no broadcasting.
+
 ## Documentation
 
 Full documentation is available at **[https://madbomber.github.io/robot_lab](https://madbomber.github.io/robot_lab)**

data/docs/api/core/result.md

@@ -0,0 +1,123 @@
+# RobotResult
+
+`RobotResult` is returned by every `robot.run()` call. It carries the LLM output, tool call results, token usage, timing, and delegation metadata for that execution.
+
+## Accessing the Response
+
+```ruby
+result = robot.run("What is the capital of France?")
+
+result.reply              # => "The capital of France is Paris."
+result.last_text_content  # => alias for reply
+result.output             # => Array of Message objects (full turn)
+result.tool_calls         # => Array of ToolResultMessage objects
+```
+
+`reply` / `last_text_content` returns the content of the last text message in `output`. This is the string you want for the vast majority of use cases.
+
+## Token & Cost Tracking
+
+```ruby
+result.input_tokens   # => Integer — tokens sent to the LLM this run
+result.output_tokens  # => Integer — tokens generated this run
+```
+
+Token counts are zero for providers that do not return usage data.
+
+## Timing
+
+`duration` is set when the result travels through a network pipeline or a `delegate` call. It is `nil` when calling `robot.run()` directly.
+
+```ruby
+result.duration  # => Float (elapsed seconds) or nil
+```
+
+## Delegation Metadata
+
+When a result comes back through `robot.delegate(to:, task:)`, two additional fields are populated:
+
+```ruby
+result.delegated_by  # => "manager"  (the robot that issued the delegation)
+result.duration      # => 2.34       (always set by delegate)
+```
+
+## Identity & Status
+
+```ruby
+result.robot_name   # => "analyst"
+result.id           # => "550e8400-e29b-..."  (UUID, unique per run)
+result.created_at   # => Time instance
+result.stop_reason  # => "end_turn", "tool_use", or nil
+```
+
+## Inspecting the Full Output
+
+```ruby
+result.output.each do |message|
+  puts message.role     # :assistant, :tool, etc.
+  puts message.content  # String or Array
+end
+
+result.has_tool_calls?  # => true if the LLM called any tools
+result.stopped?         # => true if execution ended naturally (not mid-tool-call)
+```
+
+## Persistence
+
+Export for serialization (excludes debug fields):
+
+```ruby
+hash = result.export
+# {
+#   robot_name: "analyst",
+#   output: [...],
+#   tool_calls: [...],
+#   created_at: "2026-04-18T12:00:00Z",
+#   id: "550e8400-...",
+#   checksum: "a1b2c3...",
+#   stop_reason: "end_turn",
+#   duration: 2.34,
+#   input_tokens: 512,
+#   output_tokens: 128
+# }
+
+json = result.to_json
+
+# Reconstruct from hash
+restored = RobotLab::RobotResult.from_hash(hash)
+```
+
+`checksum` is a SHA-256 digest of `output + tool_calls + created_at`. Use it for deduplication when persisting results.
+
+## Debug Fields
+
+These are `nil` by default and only populated when explicitly set for debugging:
+
+```ruby
+result.prompt   # Array<Message> — prompt sent to the LLM
+result.history  # Array<Message> — history used
+result.raw      # raw LLM response object from ruby_llm
+```
+
+## Attribute Reference
+
+| Attribute | Type | Description |
+|-----------|------|-------------|
+| `robot_name` | String | Name of the robot that produced this result |
+| `reply` | String, nil | Last text content (alias: `last_text_content`) |
+| `output` | Array\<Message\> | All output messages from this run |
+| `tool_calls` | Array\<ToolResultMessage\> | Tool call results |
+| `input_tokens` | Integer | Tokens sent to LLM |
+| `output_tokens` | Integer | Tokens generated |
+| `duration` | Float, nil | Elapsed seconds (set by delegate/pipeline) |
+| `delegated_by` | String, nil | Delegating robot's name |
+| `id` | String | UUID |
+| `created_at` | Time | Creation timestamp |
+| `stop_reason` | String, nil | LLM stop reason |
+| `checksum` | String | SHA-256 of output content |
+
+## Related
+
+- [Robot API](robot.md) — `run`, `delegate`, `compress_history`
+- [Building Robots](../../guides/building-robots.md) — Robot construction patterns
+- [Structured Delegation](../../guides/building-robots.md#structured-delegation) — `DelegationFuture` and async fan-out

data/docs/api/errors.md

@@ -0,0 +1,185 @@
+# Error Reference
+
+All RobotLab exceptions inherit from `RobotLab::Error`, which inherits from `StandardError`. Rescue `RobotLab::Error` to catch any framework exception in one clause, or rescue specific subclasses for targeted handling.
+
+## Hierarchy
+
+```
+StandardError
+└── RobotLab::Error
+    ├── RobotLab::ConfigurationError
+    │   └── RobotLab::DependencyError
+    ├── RobotLab::InferenceError
+    │   └── RobotLab::ToolLoopError
+    ├── RobotLab::ToolNotFoundError
+    ├── RobotLab::MCPError
+    ├── RobotLab::BusError
+    ├── RobotLab::RactorBoundaryError
+    └── RobotLab::ToolError
+```
+
+Additionally, `DelegationFuture` defines its own scoped error:
+
+```
+StandardError
+└── RobotLab::Error
+    └── RobotLab::DelegationFuture::DelegationTimeout
+```
+
+---
+
+## RobotLab::Error
+
+Base class for all RobotLab errors. Rescue this to catch any framework exception.
+
+```ruby
+begin
+  robot.run("hello")
+rescue RobotLab::Error => e
+  puts "RobotLab error: #{e.message}"
+end
+```
+
+---
+
+## RobotLab::ConfigurationError
+
+Raised when configuration is invalid or missing required values.
+
+```ruby
+# Example: missing API key, invalid template path
+rescue RobotLab::ConfigurationError => e
+  puts "Bad config: #{e.message}"
+end
+```
+
+---
+
+## RobotLab::DependencyError < ConfigurationError
+
+Raised when a required optional gem dependency is not installed.
+
+```ruby
+# Triggered by: Convergence, HistoryCompressor when 'classifier' gem is absent
+rescue RobotLab::DependencyError => e
+  puts e.message  # "Add gem 'classifier', '~> 2.3' to your Gemfile"
+end
+```
+
+---
+
+## RobotLab::InferenceError
+
+Raised when LLM inference fails (API errors, timeouts, rate limits).
+
+```ruby
+rescue RobotLab::InferenceError => e
+  puts "LLM call failed: #{e.message}"
+end
+```
+
+---
+
+## RobotLab::ToolLoopError < InferenceError
+
+Raised when a robot's tool call count exceeds `max_tool_rounds:`. The chat history will contain a dangling `tool_use` block with no matching `tool_result`; call `robot.clear_messages` before reusing the robot.
+
+```ruby
+robot = RobotLab.build(
+  name: "runner",
+  system_prompt: "Execute every step.",
+  local_tools: [StepTool],
+  max_tool_rounds: 10
+)
+
+begin
+  robot.run("Run all steps.")
+rescue RobotLab::ToolLoopError => e
+  puts e.message  # "Tool call limit of 10 exceeded"
+  robot.clear_messages  # required before reuse
+end
+```
+
+---
+
+## RobotLab::ToolNotFoundError
+
+Raised when a tool name is referenced but cannot be found in the `ToolManifest`.
+
+---
+
+## RobotLab::MCPError
+
+Raised when MCP server communication fails (connection refused, timeout, protocol error).
+
+```ruby
+rescue RobotLab::MCPError => e
+  puts "MCP failed: #{e.message}"
+end
+```
+
+---
+
+## RobotLab::BusError
+
+Raised when message bus communication fails (no bus configured, channel not found).
+
+```ruby
+rescue RobotLab::BusError => e
+  puts "Bus error: #{e.message}"
+end
+```
+
+---
+
+## RobotLab::RactorBoundaryError
+
+Raised when a value cannot be made Ractor-shareable before crossing a Ractor boundary (e.g., a live `IO` object, a `Proc`, or an object with mutable state).
+
+```ruby
+begin
+  RobotLab::RactorBoundary.freeze_deep({ io: StringIO.new })
+rescue RobotLab::RactorBoundaryError => e
+  puts e.message  # "Cannot make value Ractor-shareable: ..."
+end
+```
+
+Raised proactively by `RactorWorkerPool#submit` and `RactorMemoryProxy#set` before any Ractor is involved.
+
+---
+
+## RobotLab::ToolError
+
+Raised when a tool fails during execution inside a Ractor worker (the pool unwraps `RactorJobError` and re-raises as `ToolError`).
+
+```ruby
+begin
+  pool.submit("MyTool", { input: "bad" })
+rescue RobotLab::ToolError => e
+  puts e.message  # "Tool 'MyTool' failed in Ractor: ..."
+end
+```
+
+---
+
+## RobotLab::DelegationFuture::DelegationTimeout
+
+Raised by `DelegationFuture#value(timeout: N)` when the delegated task does not complete within `N` seconds.
+
+```ruby
+future = manager.delegate(to: analyst, task: "...", async: true)
+
+begin
+  result = future.value(timeout: 10)
+rescue RobotLab::DelegationFuture::DelegationTimeout => e
+  puts e.message  # "Delegation to 'analyst' timed out after 10s"
+end
+```
+
+---
+
+## Related
+
+- [Building Robots](../guides/building-robots.md) — Tool loop circuit breaker, delegation
+- [Ractor Parallelism](../guides/ractor-parallelism.md) — Ractor boundary and tool errors
+- [MCP Integration](../guides/mcp-integration.md) — MCP connection errors

data/docs/api/messages/index.md

@@ -76,6 +76,27 @@ memory.messages  # => Array<Message>
 memory.format_history  # => Array<Message>
 ```
 
+## Deserializing from Hash
+
+`Message.from_hash` reconstructs the correct subclass from a stored hash:
+
+```ruby
+RobotLab::Message.from_hash({ type: "text", role: "user", content: "Hello" })
+# => #<RobotLab::TextMessage ...>
+
+RobotLab::Message.from_hash({ type: "tool_call", role: "assistant", tools: [...] })
+# => #<RobotLab::ToolCallMessage ...>
+```
+
+When the `type` key is absent or `nil` (e.g. records persisted before the field was introduced), `from_hash` defaults to `TextMessage`:
+
+```ruby
+RobotLab::Message.from_hash({ role: "user", content: "legacy row" })
+# => #<RobotLab::TextMessage ...>
+```
+
+String keys are normalised automatically via `transform_keys(&:to_sym)`.
+
 ## See Also
 
 - [Memory](../core/memory.md)

data/docs/getting-started/configuration.md

@@ -361,7 +361,7 @@ effective.temperature  #=> 0.9 (overridden)
 | **LLM** | `model`, `temperature`, `top_p`, `top_k`, `max_tokens`, `presence_penalty`, `frequency_penalty`, `stop` |
 | **Tools** | `mcp`, `tools` |
 | **Callbacks** | `on_tool_call`, `on_tool_result` |
-| **Infrastructure** | `bus`, `enable_cache` |
+| **Infrastructure** | `bus`, `enable_cache`, `max_tool_rounds`, `token_budget`, `ractor_pool_size`, `max_concurrent_robots` |
 
 ### RunConfig vs RobotLab.config