robot_lab 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37a044eb81a0e5c56aa7c5c00f9b4eff600c56eecda8bb2deb18058919a18267
-  data.tar.gz: a48253bbceb5ac99f1babf9c4538045886e038fb0c4a827b96b219b5363bf5c8
+  metadata.gz: c852fcf7f4aed4ce95fabdc5b0296723ca8aa10e780dabaa7759e618a22bc640
+  data.tar.gz: 1bcb205c958ede9967886dae78a1d1a6d47da42e4cd9bd29d7bdd3e094b0a088
 SHA512:
-  metadata.gz: 9f84d7c82598d281e8c88a4e67b2b0c13bac1142e8dae9834a1b0e84d1055e16837c62b452398da615d477aec834b153ca74f6313c67b806fe174aacd3a0999b
-  data.tar.gz: 549afa0eb2e622ad8caf0d928559bb881b3f1307d2e427074a2f96f943418784e580ef9d5b2a06534f9ec57873682189ec6890cd0ed1790e19b66c159fff572e
+  metadata.gz: 5620e7798ac04441cb23c6a7cc5f0cdad7447103825db35ef6f3a3987785b8ff5fb355ec03a309ef9c8a5ce5b0b7a29d9f5adef0e6a5d9de5cd66d3c94fb0469
+  data.tar.gz: 9300b1f5ed98e70226c7c670bcf2e3dee033310db6b2182b2705085f02474a1ea6157a011c93906da1d45ba38b4c9f8b9e62545cdb5fd304ca1550734f7dc043

data/CHANGELOG.md

@@ -8,6 +8,45 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.0.9] - 2026-03-02
+
+### Added
+
+- **Provider passthrough** — `provider:` parameter on Robot constructor for local LLM providers (Ollama, GPUStack, etc.)
+  - Automatically sets `assume_model_exists: true` when provider is specified
+  - Exposed via `robot.provider` accessor
+- **MCP request timeouts** — configurable timeout for all MCP transports
+  - `MCP::Server` accepts `timeout:` parameter (default 15s); auto-converts millisecond values
+  - `MCP::Transports::Base` extracts and exposes `timeout` from config
+  - `MCP::Transports::Stdio` wraps all blocking I/O with `Timeout.timeout` — hung servers no longer block the caller forever
+  - Timeout propagated from `MCP::Server` through `MCP::Client` to transport layer
+- **MCP connection resilience** — improved error handling and retry logic
+  - `ensure_mcp_clients` retries previously failed servers on subsequent calls
+  - `@failed_mcp_configs` tracks servers that failed to connect
+  - `robot.failed_mcp_server_names` — query which MCP servers are down
+  - `robot.connect_mcp!` — eagerly connect to MCP servers (normally lazy)
+  - `init_mcp_client` rescues `StandardError` so one bad server doesn't prevent others from connecting
+  - `cleanup_process` in Stdio transport for reliable resource cleanup
+  - Better error messages for command-not-found (`Errno::ENOENT`), broken pipe (`Errno::EPIPE`), and EOF conditions
+- **`robot.inject_mcp!`** — inject pre-connected MCP clients and tools from an external host application
+- **Conversation management APIs** on Robot
+  - `robot.chat` — access the underlying `RubyLLM::Chat` instance
+  - `robot.messages` — return conversation messages
+  - `robot.clear_messages(keep_system:)` — clear history, optionally preserving the system prompt
+  - `robot.replace_messages(messages)` — restore a saved conversation (checkpoint/restore)
+  - `robot.chat_provider` — query the provider name without reaching into chat internals
+  - `robot.mcp_client(server_name)` — find an MCP client by server name
+- **`RobotResult#duration`** — elapsed seconds for a robot run, set automatically during pipeline execution
+- **`RobotResult#raw`** — raw LLM response stored on every result (previously only settable via accessor)
+- **Pipeline error resilience** — `Robot#call` (pipeline step) rescues all exceptions so one failing robot doesn't crash the entire network; error is captured in a `RobotResult` with the elapsed duration
+
+### Changed
+
+- Bumped version to 0.0.9
+- Display `scout_path` in Rusty Circuit example updated to use `output/` subdirectory
+- Updated `onnxruntime` dependency to 0.11.0
+- Updated Gemfile.lock dependencies (erb, minitest, rails-html-sanitizer, json_schemer)
+
 ## [0.0.8] - 2026-02-22
 
 ### Added

data/README.md

@@ -20,7 +20,8 @@
 - <strong>Extensible Tools</strong> - Custom capabilities with graceful error handling<br>
 - <strong>Human-in-the-Loop</strong> - AskUser tool for interactive prompting<br>
 - <strong>Content Streaming</strong> - Stored callbacks, per-call blocks, or both<br>
-- <strong>MCP Integration</strong> - Connect to external tool servers<br>
+- <strong>MCP Integration</strong> - Connect to external tool servers with timeouts and retry<br>
+- <strong>Local LLM Providers</strong> - Ollama, GPUStack, LM Studio via provider passthrough<br>
 - <strong>Shared Memory</strong> - Reactive key-value store with subscriptions<br>
 - <strong>Message Bus</strong> - Bidirectional robot communication via TypedBus<br>
 - <strong>Dynamic Spawning</strong> - Robots create new robots at runtime<br>
@@ -71,6 +72,19 @@ puts result.last_text_content
 # => "The capital of France is Paris."
 ```
 
+### Local LLM Providers
+
+For local LLM providers (Ollama, GPUStack, LM Studio, etc.), use the `provider:` parameter:
+
+```ruby
+robot = RobotLab.build(
+  name: "local_bot",
+  model: "llama3.2",
+  provider: :ollama,
+  system_prompt: "You are a helpful assistant."
+)
+```
+
 ### Configuration
 
 RobotLab uses [MywayConfig](https://github.com/MadBomber/myway_config) for layered configuration. There is no `configure` block. Configuration is loaded automatically from multiple sources in priority order:
@@ -443,14 +457,15 @@ puts result.value.last_text_content
 Connect to external tool servers via Model Context Protocol:
 
 ```ruby
-# Configure MCP server
+# Configure MCP server (with optional timeout)
 filesystem_server = {
   name: "filesystem",
   transport: {
     type: "stdio",
     command: "mcp-server-filesystem",
     args: ["/path/to/allowed/directory"]
-  }
+  },
+  timeout: 30  # seconds (default: 15)
 }
 
 # Create robot with MCP server - tools are auto-discovered
@@ -460,10 +475,18 @@ robot = RobotLab.build(
   mcp: [filesystem_server]
 )
 
+# Optionally connect eagerly (default is lazy on first run)
+robot.connect_mcp!
+
+# Check connection status
+puts "Failed: #{robot.failed_mcp_server_names}" if robot.failed_mcp_server_names.any?
+
 # Robot can now use filesystem tools
 result = robot.run("List the files in the current directory")
 ```
 
+MCP connections are resilient: failed servers are automatically retried on subsequent `run()` calls, and one failing server does not prevent others from connecting.
+
 ## Message Bus
 
 Robots can communicate bidirectionally via an optional message bus, independent of the Network pipeline. This enables negotiation loops, convergence patterns, and cyclic workflows.

data/docs/api/core/robot.md

@@ -23,6 +23,7 @@ Robot.new(
   description: nil,
   local_tools: [],
   model: nil,
+  provider: nil,
   mcp_servers: [],
   mcp: :none,
   tools: :none,
@@ -54,6 +55,7 @@ Robot.new(
 | `description` | `String`, `nil` | `nil` | Human-readable description of what the robot does |
 | `local_tools` | `Array` | `[]` | Tools defined locally (`RubyLLM::Tool` subclasses or `RobotLab::Tool` instances) |
 | `model` | `String`, `nil` | `nil` | LLM model ID (falls back to `RobotLab.config.ruby_llm.model`) |
+| `provider` | `String`, `Symbol`, `nil` | `nil` | LLM provider for local providers (e.g., `:ollama`, `:gpustack`). Automatically sets `assume_model_exists: true` |
 | `mcp_servers` | `Array` | `[]` | Legacy MCP server configurations |
 | `mcp` | `Symbol`, `Array` | `:none` | Hierarchical MCP config (`:none`, `:inherit`, or server array) |
 | `tools` | `Symbol`, `Array` | `:none` | Hierarchical tools config (`:none`, `:inherit`, or tool name array) |
@@ -101,6 +103,7 @@ If `name` is omitted, it defaults to `"robot"`.
 | `template` | `Symbol`, `nil` | Prompt template identifier |
 | `system_prompt` | `String`, `nil` | Inline system prompt |
 | `skills` | `Array<Symbol>`, `nil` | Constructor-provided skill template IDs (nil if none) |
+| `provider` | `String`, `nil` | LLM provider name (e.g., `"ollama"`) — set when using local providers |
 | `local_tools` | `Array` | Locally defined tools |
 | `mcp_clients` | `Hash<String, MCP::Client>` | Connected MCP clients, keyed by server name |
 | `mcp_tools` | `Array<Tool>` | Tools discovered from MCP servers |
@@ -239,7 +242,9 @@ robot.call(result)
 # => SimpleFlow::Result
 ```
 
-SimpleFlow step interface. Extracts the message from `result.context[:run_params]`, calls `run`, and wraps the output in a continued `SimpleFlow::Result`.
+SimpleFlow step interface. Extracts the message from `result.context[:run_params]`, calls `run`, and wraps the output in a continued `SimpleFlow::Result`. Automatically records `RobotResult#duration` (elapsed seconds).
+
+If the robot raises any exception during execution, the error is caught and wrapped in a `RobotResult` with the error message as content. This ensures one failing robot does not crash the entire network pipeline.
 
 Override this method in subclasses for custom routing logic (e.g., classifiers).
 
@@ -401,6 +406,142 @@ bot.with_bus(bus1)  # joins bus1
 bot.with_bus(bus2)  # leaves bus1, joins bus2
 ```
 
+### connect_mcp!
+
+```ruby
+robot.connect_mcp!
+# => self
+```
+
+Eagerly connect to configured MCP servers and discover tools. Normally MCP connections are lazy (established on first `run`). Call this to connect early, e.g., to display connection status at startup.
+
+**Returns:** `self`
+
+### failed_mcp_server_names
+
+```ruby
+robot.failed_mcp_server_names
+# => Array<String>
+```
+
+Returns server names that failed to connect. Useful for displaying connection status or deciding whether to retry.
+
+### inject_mcp!
+
+```ruby
+robot.inject_mcp!(clients: mcp_clients, tools: mcp_tools)
+# => self
+```
+
+Inject pre-connected MCP clients and their tools into this robot. Used by host applications that manage MCP connections externally and need to pass them to robots without re-connecting.
+
+**Parameters:**
+
+| Name | Type | Description |
+|------|------|-------------|
+| `clients` | `Hash<String, MCP::Client>` | Connected MCP clients keyed by server name |
+| `tools` | `Array<Tool>` | Tools discovered from the MCP servers |
+
+**Returns:** `self`
+
+**Example:**
+
+```ruby
+# Host app manages MCP connections
+clients = { "github" => github_client }
+tools   = github_client.list_tools.map { |t| RobotLab::Tool.from_mcp(t) }
+
+robot.inject_mcp!(clients: clients, tools: tools)
+```
+
+### chat
+
+```ruby
+robot.chat
+# => RubyLLM::Chat
+```
+
+Access the underlying `RubyLLM::Chat` instance. Useful for checkpoint/restore operations that need direct access to conversation state.
+
+### messages
+
+```ruby
+robot.messages
+# => Array<RubyLLM::Message>
+```
+
+Return the conversation messages from the underlying chat.
+
+### clear_messages
+
+```ruby
+robot.clear_messages(keep_system: true)
+# => self
+```
+
+Clear conversation messages, optionally keeping the system prompt.
+
+**Parameters:**
+
+| Name | Type | Default | Description |
+|------|------|---------|-------------|
+| `keep_system` | `Boolean` | `true` | Whether to preserve the system message |
+
+**Returns:** `self`
+
+### replace_messages
+
+```ruby
+robot.replace_messages(messages)
+# => self
+```
+
+Replace conversation messages with a saved set. Useful for checkpoint/restore workflows.
+
+**Parameters:**
+
+| Name | Type | Description |
+|------|------|-------------|
+| `messages` | `Array<RubyLLM::Message>` | The messages to restore |
+
+**Returns:** `self`
+
+**Example:**
+
+```ruby
+# Save a checkpoint
+saved = robot.messages.dup
+
+# ... later, restore it
+robot.replace_messages(saved)
+```
+
+### chat_provider
+
+```ruby
+robot.chat_provider
+# => String or nil
+```
+
+Return the provider for this robot's chat. Useful for displaying model/provider info without reaching into chat internals.
+
+### mcp_client
+
+```ruby
+robot.mcp_client("github")
+# => MCP::Client or nil
+```
+
+Find an MCP client by server name.
+
+**Parameters:**
+
+| Name | Type | Description |
+|------|------|-------------|
+| `server_name` | `String` | The MCP server name |
+
+**Returns:** `MCP::Client` or `nil`
+
 ### disconnect
 
 ```ruby
@@ -653,6 +794,18 @@ robot = RobotLab.build(
 result = robot.run("What is 15 * 7?")
 ```
 
+### Robot with Local Provider
+
+```ruby
+robot = RobotLab.build(
+  name: "local_bot",
+  model: "llama3.2",
+  provider: :ollama,
+  system_prompt: "You are helpful."
+)
+result = robot.run("Hello!")
+```
+
 ### Robot with MCP
 
 ```ruby

data/docs/api/mcp/client.md

@@ -36,6 +36,7 @@ Accepts either a `Server` instance or a Hash configuration. When a Hash is provi
 |-----|------|----------|-------------|
 | `name` | `String` | Yes | Server identifier |
 | `transport` | `Hash` | Yes | Transport configuration (must include `type`) |
+| `timeout` | `Numeric` | No | Request timeout in seconds (default: 15). Propagated to the transport layer |
 
 **Raises:** `ArgumentError` if the config is neither a `Server` nor a `Hash`.
 

data/docs/api/mcp/server.md

@@ -13,31 +13,42 @@ server = RobotLab::MCP::Server.new(
   name: "filesystem",
   transport: { type: "stdio", command: "mcp-server-filesystem", args: ["--root", "/data"] }
 )
+
+# With custom timeout
+server = RobotLab::MCP::Server.new(
+  name: "slow_server",
+  transport: { type: "stdio", command: "heavy-mcp-server" },
+  timeout: 30
+)
 ```
 
 ## Constructor
 
 ```ruby
-Server.new(name:, transport:)
+Server.new(name:, transport:, timeout: nil, **_extra)
 ```
 
 **Parameters:**
 
-| Name | Type | Description |
-|------|------|-------------|
-| `name` | `String` | Unique server identifier |
-| `transport` | `Hash` | Transport configuration (must include `type`) |
+| Name | Type | Default | Description |
+|------|------|---------|-------------|
+| `name` | `String` | **required** | Unique server identifier |
+| `transport` | `Hash` | **required** | Transport configuration (must include `type`) |
+| `timeout` | `Numeric`, `nil` | `15` | Request timeout in seconds. Values >= 1000 are auto-converted from milliseconds. Minimum 1 second |
 
 **Raises:** `ArgumentError` if:
 - The transport type is not one of the valid types
 - A stdio transport is missing the `:command` key
 - A network transport (ws, websocket, sse, streamable-http, http) is missing the `:url` key
 
-## Valid Transport Types
+## Constants
 
 ```ruby
 RobotLab::MCP::Server::VALID_TRANSPORT_TYPES
 # => ["stdio", "sse", "ws", "websocket", "streamable-http", "http"]
+
+RobotLab::MCP::Server::DEFAULT_TIMEOUT
+# => 15  (seconds)
 ```
 
 ## Attributes
@@ -58,6 +69,14 @@ server.transport  # => Hash
 
 The normalized transport configuration hash (keys are symbols, type is downcased).
 
+### timeout
+
+```ruby
+server.timeout  # => Numeric
+```
+
+Request timeout in seconds. Defaults to `DEFAULT_TIMEOUT` (15). Values >= 1000 passed to the constructor are auto-converted from milliseconds to seconds. The minimum is 1 second.
+
 ## Methods
 
 ### transport_type
@@ -71,10 +90,10 @@ Returns the transport type string (e.g., `"stdio"`, `"ws"`, `"sse"`).
 ### to_h
 
 ```ruby
-server.to_h  # => { name: "...", transport: { ... } }
+server.to_h  # => { name: "...", transport: { ... }, timeout: 15 }
 ```
 
-Converts the server configuration to a hash representation.
+Converts the server configuration to a hash representation (includes `timeout`).
 
 ## Transport Configuration Options
 

data/docs/api/mcp/transports.md

@@ -21,7 +21,10 @@ All transports inherit from `RobotLab::MCP::Transports::Base` and implement:
 
 ```ruby
 class RobotLab::MCP::Transports::Base
-  attr_reader :config  # => Hash (symbolized keys)
+  DEFAULT_TIMEOUT = 15  # seconds
+
+  attr_reader :config   # => Hash (symbolized keys, :timeout removed)
+  attr_reader :timeout  # => Numeric (seconds, extracted from config)
 
   def connect        # Establish connection, returns self
   def send_request(message)  # Send JSON-RPC message, returns Hash response
@@ -30,11 +33,13 @@ class RobotLab::MCP::Transports::Base
 end
 ```
 
+The `timeout` is extracted from the config hash during initialization (and removed from `config`). If not provided, it defaults to `DEFAULT_TIMEOUT` (15 seconds). The timeout is propagated from `MCP::Server` through `MCP::Client` to the transport.
+
 ## Stdio Transport
 
 **Class:** `RobotLab::MCP::Transports::Stdio`
 
-Spawns a subprocess and communicates via stdin/stdout using JSON-RPC messages (one per line). Automatically sends MCP `initialize` and `notifications/initialized` on connect.
+Spawns a subprocess and communicates via stdin/stdout using JSON-RPC messages (one per line). Automatically sends MCP `initialize` and `notifications/initialized` on connect. All blocking I/O is wrapped with `Timeout.timeout` so a missing or hung server cannot block the caller forever.
 
 ### Configuration
 
@@ -43,7 +48,8 @@ Spawns a subprocess and communicates via stdin/stdout using JSON-RPC messages (o
   type: "stdio",
   command: "mcp-server-filesystem",      # Required: executable command
   args: ["--root", "/data"],             # Optional: command arguments
-  env: { "DEBUG" => "true" }             # Optional: environment variables
+  env: { "DEBUG" => "true" },            # Optional: environment variables
+  timeout: 10                            # Optional: request timeout in seconds (default: 15)
 }
 ```
 
@@ -52,14 +58,18 @@ Spawns a subprocess and communicates via stdin/stdout using JSON-RPC messages (o
 | `command` | `String` | Yes | Executable command to spawn |
 | `args` | `Array<String>` | No | Command arguments |
 | `env` | `Hash` | No | Environment variables (merged with current env) |
+| `timeout` | `Numeric` | No | Request timeout in seconds (default: 15) |
 
 ### Behavior
 
 - Uses `Open3.popen3` to spawn the subprocess
+- Verifies the process actually started (raises `MCPError` if it exits immediately)
 - Writes JSON-RPC messages to stdin (one per line)
 - Reads responses from stdout, skipping notifications (messages without `id`)
+- All blocking reads are wrapped with `Timeout.timeout` — raises `MCPError` if the server does not respond within the timeout period
 - `connected?` returns `true` when the subprocess is alive
-- `close` terminates stdin, stdout, stderr, and kills the subprocess
+- `close` calls `cleanup_process` to reliably close stdin, stdout, stderr and kill the subprocess
+- Handles `Errno::ENOENT` (command not found), `Errno::EPIPE` / `IOError` (broken pipe / connection lost), and `Timeout::Error` (hung server) with clear error messages
 
 ### Example
 
@@ -67,7 +77,8 @@ Spawns a subprocess and communicates via stdin/stdout using JSON-RPC messages (o
 transport = RobotLab::MCP::Transports::Stdio.new(
   command: "mcp-server-filesystem",
   args: ["--root", "/data"],
-  env: { "DEBUG" => "true" }
+  env: { "DEBUG" => "true" },
+  timeout: 10
 )
 
 transport.connect
@@ -243,7 +254,11 @@ end
 Specific error cases:
 - **Not connected** -- calling `send_request` before `connect` raises `MCPError`
 - **Missing gem** -- WebSocket, SSE, and HTTP transports raise `MCPError` with a `LoadError` message if required gems are not installed
-- **No response** -- Stdio transport raises `MCPError` if the subprocess produces no output
+- **No response** -- Stdio transport raises `MCPError` if the subprocess produces no output (EOF on stdout)
+- **Command not found** -- Stdio transport raises `MCPError` with the original `Errno::ENOENT` message
+- **Timeout** -- Stdio transport raises `MCPError` if the server does not respond within the configured timeout
+- **Broken pipe** -- Stdio transport raises `MCPError` and marks itself disconnected on `Errno::EPIPE` or `IOError`
+- **Immediate exit** -- Stdio transport raises `MCPError` if the server process exits immediately after spawn
 
 ## See Also
 

data/docs/architecture/core-concepts.md

@@ -9,7 +9,7 @@ A Robot is the primary unit of computation in RobotLab. It is a subclass of `Rub
 - A unique identity (name, description)
 - A personality (system prompt and/or template)
 - Capabilities (tools, MCP connections)
-- Model and inference configuration
+- Model, provider, and inference configuration
 - Inherent memory (key-value store)
 
 ### Robot Anatomy

data/docs/architecture/robot-execution.md

@@ -164,7 +164,8 @@ def build_result(response, _memory)
     robot_name: @name,
     output: output,
     tool_calls: normalize_tool_calls(tool_calls),
-    stop_reason: response.respond_to?(:stop_reason) ? response.stop_reason : nil
+    stop_reason: response.respond_to?(:stop_reason) ? response.stop_reason : nil,
+    raw: response
   )
 end
 ```
@@ -182,9 +183,12 @@ result.tool_calls       # => [ToolResultMessage, ...]
 result.stop_reason      # => "stop" or nil
 result.created_at       # => Time
 result.id               # => UUID string
+result.duration         # => Float or nil (elapsed seconds, set in pipeline execution)
+result.raw              # => raw LLM response object
 
 # Convenience methods
 result.last_text_content  # => "Hi there!" (last text message content)
+result.reply              # => alias for last_text_content
 result.has_tool_calls?    # => false
 result.stopped?           # => true
 ```
@@ -275,17 +279,31 @@ sequenceDiagram
     Robot-->>SF: result.continue(robot_result)
 ```
 
-The `Task` wrapper deep-merges per-task configuration (context, mcp, tools) before delegating to the robot's `call`. The base `Robot#call` extracts the message and calls `run`:
+The `Task` wrapper deep-merges per-task configuration (context, mcp, tools) before delegating to the robot's `call`. The base `Robot#call` extracts the message, calls `run`, and records the elapsed time in `RobotResult#duration`. If the robot raises any exception, the error is caught and wrapped in a `RobotResult` so one failing robot does not crash the entire pipeline:
 
 ```ruby
 def call(result)
   run_context = extract_run_context(result)
   message = run_context.delete(:message)
+
+  start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
   robot_result = run(message, **run_context)
+  robot_result.duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
 
   result
     .with_context(@name.to_sym, robot_result)
     .continue(robot_result)
+rescue Exception => e
+  # Error is wrapped in a RobotResult with the elapsed duration
+  error_result = RobotResult.new(
+    robot_name: @name,
+    output: [TextMessage.new(role: 'assistant', content: "Error: #{e.class}: #{e.message}")]
+  )
+  error_result.duration = elapsed
+
+  result
+    .with_context(@name.to_sym, error_result)
+    .continue(error_result)
 end
 ```
 

data/docs/concepts.md

@@ -12,6 +12,7 @@ Each robot has:
 - **Template**: A `.md` file with YAML front matter managed by prompt_manager, referenced by symbol
 - **System Prompt**: Inline instructions (can be used alone or combined with a template)
 - **Model**: The LLM model to use (defaults to `RobotLab.config.ruby_llm.model`)
+- **Provider**: Optional LLM provider for local models (Ollama, GPUStack, etc.)
 - **Skills**: Composable template behaviors prepended before the main template
 - **Local Tools**: `RubyLLM::Tool` subclasses or `RobotLab::Tool` instances (with automatic error handling)
 - **Streaming**: Real-time content via stored `on_content` callback or per-call block
@@ -195,12 +196,15 @@ tool = RobotLab::Tool.create(
 result = robot.run("Hello!")
 
 result.last_text_content  # => "Hi there!" (String or nil)
+result.reply              # => alias for last_text_content
 result.output             # => [TextMessage, ...] array of output messages
 result.tool_calls         # => [] array of tool call results
 result.robot_name         # => "assistant"
 result.stop_reason        # => "end_turn" or nil
 result.has_tool_calls?    # => false
 result.checksum           # => "a1b2c3d4..." (for dedup)
+result.duration           # => Float or nil (elapsed seconds, set in pipeline execution)
+result.raw                # => raw LLM response object
 ```
 
 ## Memory

data/docs/guides/building-robots.md

@@ -50,6 +50,21 @@ robot = RobotLab.build(
 )
 ```
 
+### Provider
+
+For local LLM providers (Ollama, GPUStack, LM Studio, etc.), use the `provider:` parameter. This tells RubyLLM to skip model validation and connect directly:
+
+```ruby
+robot = RobotLab.build(
+  name: "local_bot",
+  model: "llama3.2",
+  provider: :ollama,
+  system_prompt: "You are a helpful assistant."
+)
+```
+
+When `provider:` is set, `assume_model_exists: true` is automatically applied. The provider is available via `robot.provider`.
+
 ### System Prompt
 
 An inline string that defines the robot's personality and behavior:
@@ -479,10 +494,13 @@ The `run` method returns a `RobotResult` with:
 
 ```ruby
 result.last_text_content  # => "Hi there! How can I help?"
+result.reply              # => alias for last_text_content
 result.output             # => Array of output messages
 result.tool_calls         # => Array of tool call results
 result.robot_name         # => "assistant"
 result.stop_reason        # => stop reason from the LLM
+result.duration           # => Float (elapsed seconds, set in pipeline execution)
+result.raw                # => raw LLM response object
 ```
 
 ### With Runtime Memory

data/docs/guides/creating-networks.md

@@ -291,6 +291,24 @@ network = RobotLab.create_network(name: "multi_analysis") do
 end
 ```
 
+### Pipeline Error Resilience
+
+When a robot raises an exception during pipeline execution, the error is caught and wrapped in a `RobotResult` with the error message as content. This ensures one failing robot does not crash the entire network:
+
+```ruby
+# If billing_robot raises an error, the network continues
+# The error is available in the result context:
+result = network.run(message: "Process this")
+billing_result = result.context[:billing]
+
+if billing_result&.last_text_content&.start_with?("Error:")
+  puts "Billing failed: #{billing_result.last_text_content}"
+  puts "Took: #{billing_result.duration}s"
+end
+```
+
+Each robot's `RobotResult` includes a `duration` field (elapsed seconds) that is set automatically during pipeline execution, even for errored results.
+
 ### Conditional Continuation
 
 A robot can halt execution early:

data/docs/guides/mcp-integration.md

@@ -101,6 +101,26 @@ Global (RobotLab.config.mcp)
       -> Runtime (robot.run("msg", mcp: [...]))
 ```
 
+## Timeout Configuration
+
+All transports support a configurable request timeout. The default is 15 seconds. Set a custom timeout at the server level:
+
+```ruby
+robot = RobotLab.build(
+  name: "patient_bot",
+  system_prompt: "You help with slow operations.",
+  mcp: [
+    {
+      name: "heavy_server",
+      transport: { type: "stdio", command: "heavy-mcp-server" },
+      timeout: 60  # seconds
+    }
+  ]
+)
+```
+
+Values >= 1000 are auto-converted from milliseconds to seconds. The minimum timeout is 1 second.
+
 ## Transport Types
 
 ### Stdio Transport
@@ -290,6 +310,50 @@ client.list_resources       # => Array of resource definitions
 client.disconnect
 ```
 
+## Connection Resilience
+
+### Eager Connection
+
+By default, MCP connections are lazy — established on the first `run()` call. Use `connect_mcp!` to connect early:
+
+```ruby
+robot = RobotLab.build(
+  name: "assistant",
+  system_prompt: "You help with tasks.",
+  mcp: [
+    { name: "github", transport: { type: "stdio", command: "mcp-server-github" } },
+    { name: "filesystem", transport: { type: "stdio", command: "mcp-server-fs" } }
+  ]
+)
+
+robot.connect_mcp!
+
+# Check which servers failed
+if robot.failed_mcp_server_names.any?
+  puts "Failed to connect: #{robot.failed_mcp_server_names.join(', ')}"
+end
+```
+
+### Automatic Retry
+
+Failed MCP servers are automatically retried on subsequent `run()` calls. If a server was down when the robot first connected, it will be retried transparently:
+
+```ruby
+robot.run("First message")       # github connects, filesystem fails
+# ... filesystem comes back up ...
+robot.run("Second message")      # filesystem retried and connects
+```
+
+### Injecting External MCP Clients
+
+Host applications that manage MCP connections externally can inject pre-connected clients into a robot:
+
+```ruby
+robot.inject_mcp!(clients: my_clients, tools: my_tools)
+```
+
+This skips the normal connection process and marks the robot as MCP-initialized.
+
 ## Error Handling
 
 ### Connection Errors
@@ -302,8 +366,16 @@ rescue RobotLab::MCPError => e
 end
 ```
 
-!!! tip
-    MCP connection failures are logged as warnings but do not raise errors by default. The robot will continue without MCP tools if a server is unreachable.
+MCP connection failures are logged as warnings but do not raise errors by default. The robot will continue without MCP tools if a server is unreachable. One failing server does not prevent other servers from connecting.
+
+### Timeout Errors
+
+Stdio transports wrap all blocking I/O with a configurable timeout. If a server does not respond within the timeout period, an `MCPError` is raised with a descriptive message:
+
+```ruby
+# Server that takes too long will raise:
+# RobotLab::MCPError: MCP server 'heavy-server' did not respond within 15s
+```
 
 ## Disconnecting
 

data/examples/14_rusty_circuit/.gitignore

@@ -0,0 +1 @@
+/output/

data/examples/14_rusty_circuit/open_mic.rb

@@ -59,7 +59,7 @@ end
 
 bus     = TypedBus::MessageBus.new
 display = Display.new(
-  scout_path: File.join(__dir__, "scout_notes.md"),
+  scout_path: File.join(__dir__, "output", "scout_notes.md"),
   log_path: log_path
 )
 

data/lib/robot_lab/mcp/client.rb

@@ -162,15 +162,17 @@ module RobotLab
       end
 
       def create_transport
+        config = @server.transport.merge(timeout: @server.timeout)
+
         case @server.transport_type
         when "stdio"
-          Transports::Stdio.new(@server.transport)
+          Transports::Stdio.new(config)
         when "ws", "websocket"
-          Transports::WebSocket.new(@server.transport)
+          Transports::WebSocket.new(config)
         when "sse"
-          Transports::SSE.new(@server.transport)
+          Transports::SSE.new(config)
         when "streamable-http", "http"
-          Transports::StreamableHTTP.new(@server.transport)
+          Transports::StreamableHTTP.new(config)
         else
           raise MCPError, "Unsupported transport type: #{@server.transport_type}"
         end

data/lib/robot_lab/mcp/server.rb

@@ -24,20 +24,28 @@ module RobotLab
       # Valid transport types for MCP connections
       VALID_TRANSPORT_TYPES = %w[stdio sse ws websocket streamable-http http].freeze
 
+      # Default timeout for MCP requests (in seconds)
+      DEFAULT_TIMEOUT = 15
+
       # @!attribute [r] name
       #   @return [String] the server name
       # @!attribute [r] transport
       #   @return [Hash] the transport configuration
-      attr_reader :name, :transport
+      # @!attribute [r] timeout
+      #   @return [Numeric] request timeout in seconds
+      attr_reader :name, :transport, :timeout
 
       # Creates a new Server configuration.
       #
       # @param name [String] the server name
       # @param transport [Hash] the transport configuration
+      # @param timeout [Numeric, nil] request timeout in seconds (default: 15)
+      # @param _extra [Hash] additional keys are silently ignored for forward compatibility
       # @raise [ArgumentError] if transport type is invalid or required fields are missing
-      def initialize(name:, transport:)
+      def initialize(name:, transport:, timeout: nil, **_extra)
         @name = name.to_s
         @transport = normalize_transport(transport)
+        @timeout = normalize_timeout(timeout)
         validate!
       end
 
@@ -54,7 +62,8 @@ module RobotLab
       def to_h
         {
           name: name,
-          transport: transport
+          transport: transport,
+          timeout: timeout
         }
       end
 
@@ -79,6 +88,15 @@ module RobotLab
           raise ArgumentError, "Transport requires :url" unless transport[:url]
         end
       end
+
+      def normalize_timeout(value)
+        return DEFAULT_TIMEOUT if value.nil?
+
+        seconds = value.to_f
+        # If the caller passed milliseconds (>= 1000), convert to seconds
+        seconds = seconds / 1000.0 if seconds >= 1000
+        [seconds, 1].max
+      end
     end
   end
 end

data/lib/robot_lab/mcp/transports/base.rb

@@ -8,15 +8,23 @@ module RobotLab
       # @abstract Subclass and implement {#connect}, {#send_request}, {#close}
       #
       class Base
+        # Default timeout for request operations (in seconds)
+        DEFAULT_TIMEOUT = 15
+
         # @!attribute [r] config
         #   @return [Hash] the transport configuration
-        attr_reader :config
+        # @!attribute [r] timeout
+        #   @return [Numeric] request timeout in seconds
+        attr_reader :config, :timeout
 
         # Creates a new transport instance.
         #
-        # @param config [Hash] transport configuration options
+        # @param config [Hash] transport configuration options.
+        #   May include a :timeout key (in seconds) that controls how long
+        #   blocking operations wait before raising an error.
         def initialize(config)
           @config = config.transform_keys(&:to_sym)
+          @timeout = @config.delete(:timeout) || DEFAULT_TIMEOUT
         end
 
         # Connect to the server

data/lib/robot_lab/mcp/transports/stdio.rb

@@ -2,6 +2,7 @@
 
 require "open3"
 require "json"
+require "timeout"
 
 module RobotLab
   module MCP
@@ -9,12 +10,13 @@ module RobotLab
       # StdIO transport for local MCP servers
       #
       # Spawns a subprocess and communicates via stdin/stdout.
+      # All blocking I/O is wrapped with a configurable timeout
+      # so a missing or hung server cannot block the caller forever.
       #
       # @example
       #   transport = Stdio.new(
-      #     command: "mcp-server-filesystem",
-      #     args: ["--root", "/data"],
-      #     env: { "DEBUG" => "true" }
+      #     { command: "mcp-server-filesystem", args: ["--root", "/data"] },
+      #     timeout: 10
       #   )
       #
       class Stdio < Base
@@ -24,6 +26,7 @@ module RobotLab
         # @option config [String] :command the command to execute
         # @option config [Array<String>] :args command arguments
         # @option config [Hash] :env environment variables
+        # @option config [Numeric] :timeout request timeout in seconds (default: 15)
         def initialize(config)
           super
           @stdin = nil
@@ -36,7 +39,8 @@ module RobotLab
         # Connect to the MCP server via stdio.
         #
         # @return [self]
-        # @raise [MCPError] if connection fails
+        # @raise [MCPError] if the server process cannot be started or does not
+        #   respond to the MCP initialize handshake within the timeout period
         def connect
           return self if @connected
 
@@ -44,44 +48,59 @@ module RobotLab
           args = @config[:args] || []
           env = @config[:env] || {}
 
-          # Merge with current environment
           full_env = ENV.to_h.merge(env.transform_keys(&:to_s))
 
           @stdin, @stdout, @stderr, @wait_thread = Open3.popen3(full_env, command, *args)
+
+          # Verify the process actually started
+          unless @wait_thread.alive?
+            raise MCPError, "MCP server process exited immediately (command: #{command})"
+          end
+
           @connected = true
 
-          # Initialize MCP protocol
+          # Initialize MCP protocol — this must complete within the timeout
           send_initialize
 
           self
+        rescue Errno::ENOENT => e
+          cleanup_process
+          raise MCPError, "MCP server command not found: #{command} (#{e.message})"
+        rescue Timeout::Error
+          cleanup_process
+          raise MCPError, "MCP server '#{command}' did not respond within #{@timeout}s"
         end
 
         # Send a JSON-RPC request to the MCP server.
         #
         # @param message [Hash] JSON-RPC message
         # @return [Hash] the response
-        # @raise [MCPError] if not connected or no response
+        # @raise [MCPError] if not connected, no response, or timeout
         def send_request(message)
           raise MCPError, "Not connected" unless @connected
 
-          # Write JSON-RPC message
-          json = message.to_json
-          @stdin.puts(json)
-          @stdin.flush
+          Timeout.timeout(@timeout, Timeout::Error) do
+            json = message.to_json
+            @stdin.puts(json)
+            @stdin.flush
 
-          # Read response, skipping notifications
-          loop do
-            response_line = @stdout.gets
-            raise MCPError, "No response from MCP server" unless response_line
+            loop do
+              response_line = @stdout.gets
+              raise MCPError, "No response from MCP server (EOF on stdout)" unless response_line
 
-            parsed = JSON.parse(response_line, symbolize_names: true)
+              parsed = JSON.parse(response_line, symbolize_names: true)
 
-            # Skip notifications (messages without an id)
-            next if parsed[:method] && !parsed.key?(:id)
+              # Skip notifications (messages without an id)
+              next if parsed[:method] && !parsed.key?(:id)
 
-            # Return responses (messages with an id)
-            return parsed
+              return parsed
+            end
           end
+        rescue Timeout::Error
+          raise MCPError, "MCP server did not respond within #{@timeout}s"
+        rescue Errno::EPIPE, IOError => e
+          @connected = false
+          raise MCPError, "MCP server connection lost: #{e.message}"
         end
 
         # Close the connection to the MCP server.
@@ -90,12 +109,7 @@ module RobotLab
         def close
           return self unless @connected
 
-          @stdin&.close
-          @stdout&.close
-          @stderr&.close
-          @wait_thread&.kill if @wait_thread&.alive?
-
-          @connected = false
+          cleanup_process
           self
         end
 
@@ -127,6 +141,18 @@ module RobotLab
           @stdin.puts({ jsonrpc: "2.0", method: "notifications/initialized" }.to_json)
           @stdin.flush
         end
+
+        def cleanup_process
+          @connected = false
+          @stdin&.close  rescue nil
+          @stdout&.close rescue nil
+          @stderr&.close rescue nil
+          @wait_thread&.kill if @wait_thread&.alive?
+          @stdin = nil
+          @stdout = nil
+          @stderr = nil
+          @wait_thread = nil
+        end
       end
     end
   end

data/lib/robot_lab/robot/mcp_management.rb

@@ -26,17 +26,22 @@ module RobotLab
       end
 
 
-      # Ensure MCP clients are initialized for the given server configs
+      # Ensure MCP clients are initialized for the given server configs.
+      # On subsequent calls, retries any servers that previously failed to connect.
       def ensure_mcp_clients(mcp_servers)
         return if mcp_servers.empty?
 
         needed_servers = mcp_servers.map { |s| s.is_a?(Hash) ? s[:name] : s.to_s }.compact
-        return if @mcp_initialized && (@mcp_clients.keys.sort == needed_servers.sort)
 
-        disconnect if @mcp_initialized
+        if @mcp_initialized
+          # Already initialized — retry any servers that are needed but not connected
+          retry_failed_servers(mcp_servers, needed_servers)
+          return
+        end
 
         @mcp_clients = {}
         @mcp_tools = []
+        @failed_mcp_configs = {}
 
         mcp_servers.each do |server_config|
           init_mcp_client(server_config)
@@ -55,8 +60,48 @@ module RobotLab
           @mcp_clients[server_name] = client
           discover_mcp_tools(client, server_name)
         else
+          server_name = extract_server_name(server_config)
+          @failed_mcp_configs[server_name] = server_config
           RobotLab.config.logger.warn(
-            "Robot '#{@name}' failed to connect to MCP server: #{server_config[:name] || server_config}"
+            "Robot '#{@name}' failed to connect to MCP server: #{server_name}"
+          )
+        end
+      rescue StandardError => e
+        server_name = extract_server_name(server_config)
+        @failed_mcp_configs[server_name] = server_config
+        RobotLab.config.logger.warn(
+          "Robot '#{@name}' error connecting to MCP server '#{server_name}': #{e.message}"
+        )
+      end
+
+
+      # Retry connecting to servers that previously failed
+      def retry_failed_servers(mcp_servers, needed_servers)
+        return if @failed_mcp_configs.nil? || @failed_mcp_configs.empty?
+
+        # Only retry servers that are still needed and still failed
+        to_retry = @failed_mcp_configs.select { |name, _| needed_servers.include?(name) }
+        return if to_retry.empty?
+
+        to_retry.each do |name, server_config|
+          RobotLab.config.logger.info(
+            "Robot '#{@name}' retrying MCP server: #{name}"
+          )
+
+          client = MCP::Client.new(server_config)
+          client.connect
+
+          if client.connected?
+            @mcp_clients[name] = client
+            @failed_mcp_configs.delete(name)
+            discover_mcp_tools(client, name)
+            RobotLab.config.logger.info(
+              "Robot '#{@name}' successfully connected to MCP server '#{name}' on retry"
+            )
+          end
+        rescue StandardError => e
+          RobotLab.config.logger.warn(
+            "Robot '#{@name}' retry failed for MCP server '#{name}': #{e.message}"
           )
         end
       end
@@ -83,6 +128,18 @@ module RobotLab
           "Robot '#{@name}' discovered #{tools.size} tools from MCP server '#{server_name}'"
         )
       end
+
+
+      def extract_server_name(server_config)
+        case server_config
+        when Hash
+          server_config[:name] || server_config['name'] || server_config.to_s
+        when MCP::Server
+          server_config.name
+        else
+          server_config.to_s
+        end
+      end
     end
   end
 end

data/lib/robot_lab/robot.rb

@@ -66,7 +66,7 @@ module RobotLab
 
     attr_reader :name, :description, :template, :system_prompt,
                 :local_tools, :mcp_clients, :mcp_tools, :memory,
-                :bus, :outbox, :config, :skills
+                :bus, :outbox, :config, :skills, :provider
 
     # @!attribute [r] mcp_config
     #   @return [Symbol, Array] build-time MCP configuration (raw, unresolved)
@@ -108,6 +108,7 @@ module RobotLab
       description: nil,
       local_tools: [],
       model: nil,
+      provider: nil,
       mcp_servers: [],
       mcp: :none,
       tools: :none,
@@ -187,6 +188,15 @@ module RobotLab
       resolved_model = @config.model || config.ruby_llm.model
       chat_kwargs = { model: resolved_model }
 
+      # Pass provider through for local providers (Ollama, GPUStack, etc.)
+      # RubyLLM auto-sets assume_model_exists for local providers when
+      # provider is specified.
+      @provider = provider
+      if @provider
+        chat_kwargs[:provider] = @provider
+        chat_kwargs[:assume_model_exists] = true
+      end
+
       # Create the persistent chat via Agent's initialize
       super(chat: nil, **chat_kwargs)
 
@@ -354,11 +364,26 @@ module RobotLab
       # Extract the message from run context
       message = run_context.delete(:message)
 
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
       robot_result = run(message, **run_context)
+      robot_result.duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
 
       result
         .with_context(@name.to_sym, robot_result)
         .continue(robot_result)
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      # Catch all errors (including SecurityError, Timeout::Error, etc.)
+      # so one failing robot doesn't crash the entire network pipeline.
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+      error_result = RobotResult.new(
+        robot_name: @name,
+        output: [TextMessage.new(role: 'assistant', content: "Error: #{e.class}: #{e.message}")]
+      )
+      error_result.duration = elapsed
+
+      result
+        .with_context(@name.to_sym, error_result)
+        .continue(error_result)
     end
 
 
@@ -371,6 +396,26 @@ module RobotLab
     end
 
 
+    # Eagerly connect to configured MCP servers and discover tools.
+    # Normally MCP connections are lazy (established on first run).
+    # Call this to connect early, e.g. to display connection status at startup.
+    #
+    # @return [self]
+    def connect_mcp!
+      resolved_mcp = resolve_mcp_hierarchy(@mcp_config)
+      ensure_mcp_clients(resolved_mcp) if resolved_mcp.is_a?(Array) && resolved_mcp.any?
+      self
+    end
+
+    # Returns server names that failed to connect.
+    #
+    # @return [Array<String>]
+    def failed_mcp_server_names
+      return [] unless @failed_mcp_configs
+
+      @failed_mcp_configs.keys
+    end
+
     # Disconnect all MCP clients and bus channel.
     #
     # @return [self]
@@ -381,6 +426,83 @@ module RobotLab
     end
 
 
+    # --- Public APIs for external MCP and history management (A4) ---
+
+    # Inject pre-connected MCP clients and their tools into this robot.
+    # Used by host applications (e.g. AIA) that manage MCP connections
+    # externally and need to pass them to robots without re-connecting.
+    #
+    # @param clients [Hash<String, MCP::Client>] connected MCP clients by server name
+    # @param tools [Array<Tool>] tools discovered from the MCP servers
+    # @return [self]
+    def inject_mcp!(clients:, tools:)
+      @mcp_clients = clients
+      @mcp_tools = tools
+      @mcp_initialized = true
+      self
+    end
+
+    # Access the underlying RubyLLM::Chat instance.
+    # Useful for checkpoint/restore operations that need direct
+    # access to conversation state.
+    #
+    # @return [RubyLLM::Chat]
+    def chat
+      @chat
+    end
+
+    # Return the conversation messages from the underlying chat.
+    #
+    # @return [Array<RubyLLM::Message>]
+    def messages
+      @chat.messages
+    end
+
+    # Clear conversation messages, optionally keeping the system prompt.
+    #
+    # @param keep_system [Boolean] whether to preserve the system message
+    # @return [self]
+    def clear_messages(keep_system: true)
+      if keep_system
+        system_msg = @chat.messages.find { |m| m.role == :system }
+        @chat.instance_variable_set(:@messages, [])
+        @chat.add_message(system_msg) if system_msg
+      else
+        @chat.instance_variable_set(:@messages, [])
+      end
+      self
+    end
+
+    # Replace conversation messages with a saved set (for checkpoint restore).
+    #
+    # @param messages [Array<RubyLLM::Message>] the messages to restore
+    # @return [self]
+    def replace_messages(messages)
+      @chat.instance_variable_set(:@messages, messages)
+      self
+    end
+
+    # Return the provider for this robot's chat.
+    # Useful for displaying model/provider info without reaching
+    # into chat internals.
+    #
+    # @return [String, nil]
+    def chat_provider
+      m = @chat.model
+      m.respond_to?(:provider) ? m.provider : nil
+    rescue StandardError
+      nil
+    end
+
+    # Find an MCP client by server name.
+    #
+    # @param server_name [String] the MCP server name
+    # @return [MCP::Client, nil]
+    def mcp_client(server_name)
+      @mcp_clients[server_name]
+    end
+
+
     # Converts the robot to a hash representation
     #
     # @return [Hash]
@@ -460,7 +582,8 @@ module RobotLab
         robot_name: @name,
         output: output,
         tool_calls: normalize_tool_calls(tool_calls),
-        stop_reason: response.respond_to?(:stop_reason) ? response.stop_reason : nil
+        stop_reason: response.respond_to?(:stop_reason) ? response.stop_reason : nil,
+        raw: response
       )
     end
 

data/lib/robot_lab/robot_result.rb

@@ -30,13 +30,15 @@ module RobotLab
     #   @return [String, nil] reason execution stopped
     attr_reader :robot_name, :output, :tool_calls, :created_at, :id, :stop_reason
 
+    # @!attribute [rw] duration
+    #   @return [Float, nil] elapsed seconds for this run
     # @!attribute [rw] prompt
     #   @return [Array<Message>, nil] the prompt messages used (debug)
     # @!attribute [rw] history
     #   @return [Array<Message>, nil] the history used (debug)
     # @!attribute [rw] raw
     #   @return [Object, nil] the raw LLM response (debug)
-    attr_accessor :prompt, :history, :raw
+    attr_accessor :duration, :prompt, :history, :raw
 
     # Creates a new RobotResult instance.
     #

data/lib/robot_lab/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RobotLab
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: robot_lab
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -273,6 +273,7 @@ files:
 - examples/11_network_introspection.rb
 - examples/12_message_bus.rb
 - examples/13_spawn.rb
+- examples/14_rusty_circuit/.gitignore
 - examples/14_rusty_circuit/comic.rb
 - examples/14_rusty_circuit/display.rb
 - examples/14_rusty_circuit/heckler.rb
@@ -463,7 +464,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.7
 specification_version: 4
 summary: Ruby framework for building and orchestrating multi-robot LLM workflows
 test_files: []