robot_lab 0.2.1 → 0.2.6

data/lib/robot_lab/hooks.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RobotLab
+  module Hooks
+    module_function
+
+    def run(family, context, registries:, per_run_hooks: nil, &)
+      before = registrations(:"before_#{family}", registries, per_run_hooks)
+      around = registrations(:"around_#{family}", registries, per_run_hooks)
+      after  = registrations(:"after_#{family}", registries, per_run_hooks)
+      errors = error_registrations(family, registries, per_run_hooks)
+
+      call_all(before, :"before_#{family}", context)
+      result = call_around(around, :"around_#{family}", context, &)
+      set_result(context, family, result)
+      call_all(after, :"after_#{family}", context)
+      result
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      context.error = e if context.respond_to?(:error=)
+      call_all(errors, :on_error, context)
+      raise
+    end
+
+    def call(hook_name, context, registries:, per_run_hooks: nil)
+      call_all(registrations(hook_name, registries, per_run_hooks), hook_name, context)
+    end
+
+    def around(hook_name, context, registries:, per_run_hooks: nil, &)
+      call_around(registrations(hook_name, registries, per_run_hooks), hook_name, context, &)
+    end
+
+    def registrations(hook_name, registries, per_run_hooks)
+      registry_entries = registries.compact.flat_map { |registry| registry.registrations_for(hook_name) }
+      registry_entries + per_run_entries(hook_name, per_run_hooks)
+    end
+
+    def error_registrations(family, registries, per_run_hooks)
+      return [] unless %i[run network_run task].include?(family.to_sym)
+
+      registrations(:on_error, registries, per_run_hooks)
+    end
+
+    def call_all(registrations, hook_name, context)
+      registrations.each { |registration| call_registration(registration, hook_name, context) }
+    end
+
+    def call_around(registrations, hook_name, context, &block)
+      chain = registrations.reverse.inject(block) do |next_link, registration|
+        proc { call_registration(registration, hook_name, context, &next_link) }
+      end
+
+      chain.call
+    end
+
+    def call_registration(registration, hook_name, context, &)
+      context.with_namespace(registration.namespace) do
+        if registration.context && registration.namespace
+          context.ext(registration.namespace).merge_defaults(registration.context)
+        end
+        registration.handler_class.call(hook_name, context, &)
+      end
+    end
+
+    # per_run_hooks is now a single handler class or an array of handler classes.
+    def per_run_entries(hook_name, hooks)
+      return [] unless hooks
+
+      hook_sym = hook_name.to_sym
+      Array(hooks).filter_map do |handler_class|
+        next unless handler_class.singleton_class.public_method_defined?(hook_sym)
+
+        HookRegistry::Registration.new(handler_class: handler_class)
+      end
+    end
+
+    def set_result(context, family, result)
+      case family.to_sym
+      when :run
+        context.response = result if context.respond_to?(:response=)
+      when :network_run, :task
+        context.result = result if context.respond_to?(:result=)
+      when :llm_generation
+        context.generation_response = result if context.respond_to?(:generation_response=)
+      end
+    end
+  end
+end

data/lib/robot_lab/mcp/connection_poller.rb

@@ -115,7 +115,7 @@ module RobotLab
           client.transport.stdin.flush
         rescue Errno::EPIPE, IOError => e
           @mutex.synchronize { @clients[io][:queue] = nil }
-          raise MCPError, "MCP connection lost: #{e.message}"
+          raise MCPError.new("MCP connection lost: #{e.message}", retryable: true)
         end
 
         response = Timeout.timeout(timeout) { queue.pop }
@@ -127,7 +127,7 @@ module RobotLab
         response
       rescue Timeout::Error
         @mutex.synchronize { @clients[io]&.[]= :queue, nil }
-        raise MCPError, "MCP server did not respond within #{timeout}s"
+        raise MCPError.new("MCP server did not respond within #{timeout}s", retryable: true)
       ensure
         @mutex.synchronize { @clients[io]&.[]= :queue, nil }
       end

data/lib/robot_lab/narrator.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RobotLab
+  # Opt-in live observability hook: narrates what a robot is doing as it happens,
+  # so a run is never silent between events. Complements RobotLab::Audit (which
+  # records to a persistent store) with a human-facing console feed.
+  #
+  # Enable it globally (applies to every robot run, including networks):
+  #
+  #   RobotLab::Narrator.enable!            # narrate to $stderr
+  #   RobotLab::Narrator.enable!(output: $stdout)
+  #
+  # or register like any hook for finer scope:
+  #
+  #   robot.on(RobotLab::Narrator)
+  #   network.on(RobotLab::Narrator)
+  #
+  # Output goes to $stderr by default and uses IO#puts (not Kernel#warn, which is
+  # silenced when Ruby warnings are disabled — i.e. $VERBOSE is nil, common under
+  # `bundle exec`).
+  class Narrator < RobotLab::Hook
+    self.namespace = :narrator
+
+    MAX = 80
+
+    class << self
+      attr_writer :output
+
+      # @return [IO] where narration is written (default $stderr)
+      def output
+        @output ||= $stderr
+      end
+
+      # Register the narrator globally and set its output.
+      #
+      # @param output [IO]
+      # @return [Class] self
+      def enable!(output: $stderr)
+        self.output = output
+        RobotLab.on(self)
+        self
+      end
+
+      # --- hooks ---------------------------------------------------------------
+
+      def before_llm_generation(ctx)
+        who = ctx.respond_to?(:robot) ? ctx.robot&.name : nil
+        say "#{"#{who}: " if who}thinking…"
+      rescue StandardError
+        nil
+      end
+
+      def before_tool_call(ctx)
+        say "→ #{ctx.tool_name}#{summarize(ctx.tool_args)}"
+      rescue StandardError
+        nil
+      end
+
+      def after_tool_call(ctx)
+        say "  ✗ #{clip(ctx.tool_error.message)}" if ctx.tool_error
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      def say(message)
+        output.puts("  · #{message}")
+      rescue StandardError
+        nil
+      end
+
+      # Compact one-line summary of the first tool argument, e.g. " path=\"a.rb\"".
+      def summarize(args)
+        return "" unless args.is_a?(Hash) && !args.empty?
+
+        key, value = args.first
+        " #{key}=#{clip(value).inspect}"
+      end
+
+      def clip(text)
+        line = text.to_s.lines.first.to_s.strip
+        line.length > MAX ? "#{line[0, MAX]}…" : line
+      end
+    end
+  end
+end

data/lib/robot_lab/network.rb

@@ -59,6 +59,7 @@ module RobotLab
   #
   class Network
     include Utils
+    include Runnable
 
     # Reserved key for broadcast messages in memory
     BROADCAST_KEY = :_network_broadcast
@@ -71,7 +72,7 @@ module RobotLab
     #   @return [Hash<String, Robot>] robots in this network, keyed by name
     # @!attribute [r] memory
     #   @return [Memory] shared memory for all robots in the network
-    attr_reader :name, :pipeline, :robots, :memory, :config, :parallel_mode
+    attr_reader :name, :pipeline, :robots, :memory, :config, :parallel_mode, :hooks
 
     # Creates a new Network instance.
     #
@@ -94,6 +95,7 @@ module RobotLab
       @memory = memory || Memory.new(network_name: @name)
       @config = config || RunConfig.new
       @parallel_mode = parallel_mode
+      @hooks = HookRegistry.new
       @broadcast_handlers = []
       @bus_poller = BusPoller.new.start
 
@@ -132,7 +134,8 @@ module RobotLab
         mcp: mcp,
         tools: tools,
         memory: memory,
-        config: config
+        config: config,
+        network: self
       )
 
       # Register the group and assign the shared poller to the robot
@@ -177,24 +180,55 @@ module RobotLab
     #   result.value  # => RobotResult from last robot
     #   result.context[:classifier]  # => RobotResult from classifier
     #
-    def run(**run_context)
+    def run(message = nil, **run_context)
+      # Runnable protocol: accept a positional message like Robot#run does, so
+      # callers can `run(msg, ...)` uniformly. `run(message: msg)` still works.
+      run_context[:message] = message unless message.nil?
+
       # Include shared memory in run params so robots can access it
       run_context[:network_memory] = @memory
+      run_context[:network] = self
 
       # Pass network's config so robots can inherit it
       run_context[:network_config] = @config unless @config.empty?
 
-      if @parallel_mode == :ractor
-        run_with_ractor_scheduler(run_context)
-      else
-        initial_result = SimpleFlow::Result.new(
-          run_context,
-          context: { run_params: run_context }
-        )
-        @pipeline.call_parallel(initial_result, max_concurrent: @config.max_concurrent_robots)
+      context = NetworkRunHookContext.new(
+        network: self,
+        context: run_context,
+        memory: @memory,
+        config: @config
+      )
+
+      RobotLab::Hooks.run(:network_run, context, registries: [RobotLab.hooks, @hooks]) do
+        if @parallel_mode == :ractor
+          run_with_ractor_scheduler(context.context)
+        else
+          initial_result = SimpleFlow::Result.new(
+            context.context,
+            context: { run_params: context.context }
+          )
+          @pipeline.call_parallel(initial_result, max_concurrent: @config.max_concurrent_robots)
+        end
       end
     end
 
+    # Runnable protocol: the network's robots as an Array (in pipeline order),
+    # and the network? predicate. (`robots` itself stays a name=>robot Hash.)
+    #
+    # @return [Array<Robot>]
+    def crew
+      robots.values
+    end
+
+    # @return [Boolean] always true for a Network
+    def network?
+      true
+    end
+
+    def on(handler_class, context: nil)
+      @hooks.on(handler_class, context: context)
+    end
+
     # Broadcast a message to all robots in the network.
     #
     # This sends a network-wide message that all robots subscribed via
@@ -303,6 +337,19 @@ module RobotLab
       self
     end
 
+    # Remove a dynamically-added robot from the network by name. Returns the
+    # removed robot, or nil if no robot by that name was present.
+    #
+    # Only removes the robot from the crew (`@robots`); it does not rewrite the
+    # pipeline, so callers should not remove a robot that is a pipeline task.
+    #
+    # @param name [String, Symbol] the robot's name
+    # @return [Robot, nil]
+    #
+    def remove_robot(name)
+      @robots.delete(name.to_s)
+    end
+
     # Visualize the pipeline as ASCII
     #
     # @return [String, nil]
@@ -363,15 +410,7 @@ module RobotLab
       specs_with_deps = @tasks.map do |task_name, task_wrapper|
         deps = dep_graph[task_name.to_sym] || []
         deps = deps.empty? ? :none : deps.map(&:to_s)
-
-        spec = RobotSpec.new(
-          name:          task_wrapper.robot.name.freeze,
-          template:      task_wrapper.robot.template&.to_s&.freeze,
-          system_prompt: task_wrapper.robot.system_prompt&.freeze,
-          config_hash:   RactorBoundary.freeze_deep(task_wrapper.robot.config.to_json_hash)
-        )
-
-        { spec: spec, depends_on: deps }
+        { spec: build_robot_spec(task_wrapper), depends_on: deps }
       end
 
       scheduler = RactorNetworkScheduler.new(memory: @memory)
@@ -379,5 +418,23 @@ module RobotLab
       scheduler.shutdown
       results
     end
+
+    def build_robot_spec(task_wrapper)
+      robot = task_wrapper.robot
+      RobotSpec.new(
+        name:          robot.name.freeze,
+        template:      robot.template&.to_s&.freeze,
+        system_prompt: robot.system_prompt&.freeze,
+        config_hash:   RactorBoundary.freeze_deep(robot.config.to_json_hash),
+        hook_classes:  ractor_hook_classes_for(robot)
+      )
+    end
+
+    def ractor_hook_classes_for(robot)
+      [RobotLab.hooks, @hooks, robot.hooks]
+        .flat_map { |registry| registry.registrations.map(&:handler_class) }
+        .uniq
+        .freeze
+    end
   end
 end

data/lib/robot_lab/robot/budget.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RobotLab
+  class Robot < RubyLLM::Agent
+    # Token/cost budget enforcement for a single Robot, backed by a
+    # RobotLab::Budget::Ledger.
+    #
+    # Two layers of enforcement:
+    # - reserve_budget!/reconcile_budget! wrap each LLM call. reserve_budget!
+    #   raises BudgetExceeded up front when a *prior* call already pushed
+    #   usage over budget, so a robot with an exhausted budget refuses
+    #   further calls instead of spending on them.
+    # - enforce_token_budget!/enforce_cost_budget! run after the call
+    #   completes and raise InferenceError when *this* call's actual usage
+    #   pushed cumulative usage over budget — unavoidable for the call that
+    #   causes the overage, since token/cost totals aren't known until the
+    #   response comes back.
+    module Budget
+      private
+
+      # @return [RobotLab::Budget::Ledger, nil] nil when neither token_budget
+      #   nor cost_budget is configured
+      def build_budget_ledger
+        limits = { tokens: @config.token_budget, cost: @config.cost_budget }.compact
+        return nil if limits.empty?
+
+        RobotLab::Budget::Ledger.new(limits: limits)
+      end
+
+      def enforce_token_budget!
+        budget = @config.token_budget
+        return unless budget && @total_input_tokens + @total_output_tokens > budget
+
+        raise InferenceError,
+              "Token budget exceeded: #{@total_input_tokens + @total_output_tokens} tokens used, budget is #{budget}"
+      end
+
+      def enforce_cost_budget!
+        budget = @config.cost_budget
+        return unless budget && @budget_ledger
+
+        consumed = @budget_ledger.consumed[:cost]
+        return unless consumed > budget
+
+        raise InferenceError,
+              format("Cost budget exceeded: $%<consumed>.6f used, budget is $%<budget>.6f",
+                     consumed: consumed, budget: budget)
+      end
+
+      # Reserves whatever remains of each configured budget dimension
+      # before attempting the LLM call.
+      #
+      # @return [Hash{Symbol=>Numeric}] the amount reserved per dimension, to pass to reconcile_budget!
+      # @raise [RobotLab::BudgetExceeded] if a dimension is already exhausted
+      def reserve_budget!
+        return {} unless @budget_ledger
+
+        @budget_ledger.limits.each_key.with_object({}) do |dimension, reservation|
+          amount = @budget_ledger.remaining(dimension)
+          @budget_ledger.reserve!(dimension, amount)
+          reservation[dimension] = amount
+        end
+      end
+
+      # Replaces a reservation from reserve_budget! with the actual usage
+      # from this call.
+      #
+      # @param reservation [Hash{Symbol=>Numeric}] the value returned by reserve_budget!
+      # @param response [Object] the raw LLM response, used to extract actual cost
+      # @param result [RobotResult] the built result, used to extract actual tokens
+      def reconcile_budget!(reservation, response:, result:)
+        return unless reservation&.any?
+
+        actual = { tokens: result.input_tokens + result.output_tokens, cost: extract_cost(response) }
+        reservation.each_pair { |dimension, amount| @budget_ledger.reconcile!(dimension, amount, actual[dimension] || 0) }
+      end
+
+      # @param response [Object] the raw LLM response
+      # @return [Float] the response's total cost, or 0.0 when unavailable (no pricing data)
+      def extract_cost(response)
+        return 0.0 unless response.respond_to?(:cost)
+
+        response.cost.total.to_f
+      rescue StandardError
+        0.0
+      end
+    end
+  end
+end

data/lib/robot_lab/robot/bus_messaging.rb

@@ -29,9 +29,15 @@ module RobotLab
       def send_message(to:, content:)
         raise BusError, "No bus configured on robot '#{@name}'" unless @bus
 
-        @message_counter += 1
-        message = RobotMessage.build(id: @message_counter, from: @name, content: content)
-        @outbox[message.key] = { message: message, status: :sent, replies: [] }
+        # Counter + outbox are shared with the poller thread (reply correlation)
+        # and with other senders; mutate them under the bus mutex. Publish (which
+        # does I/O) stays outside the lock.
+        message = @bus_mutex.synchronize do
+          @message_counter += 1
+          msg = RobotMessage.build(id: @message_counter, from: @name, content: content)
+          @outbox[msg.key] = { message: msg, status: :sent, replies: [] }
+          msg
+        end
         publish_to_bus(to.to_sym, message)
         message
       end
@@ -46,8 +52,10 @@ module RobotLab
       def send_reply(to:, content:, in_reply_to:)
         raise BusError, "No bus configured on robot '#{@name}'" unless @bus
 
-        @message_counter += 1
-        reply = RobotMessage.build(id: @message_counter, from: @name, content: content, in_reply_to: in_reply_to)
+        reply = @bus_mutex.synchronize do
+          @message_counter += 1
+          RobotMessage.build(id: @message_counter, from: @name, content: content, in_reply_to: in_reply_to)
+        end
         publish_to_bus(to.to_sym, reply)
         reply
       end
@@ -65,6 +73,37 @@ module RobotLab
         self
       end
 
+      # Automatically respond to inbound (non-reply) bus tasks: run +responder+ to
+      # produce a reply, and send it back to the sender. This is the symmetric
+      # counterpart to how a Cyborg answers its human — one call makes any bus
+      # member a first-class responder instead of hand-wiring {#on_message}.
+      #
+      # The responder runs on the poller drain thread, so deliveries to this member
+      # are handled one at a time (a long turn delays the next inbound message).
+      #
+      # @param auto_reply [Boolean] send the responder's result back to the sender
+      # @yield [message] the inbound task; return the reply content (nil => no reply)
+      # @return [self]
+      def respond_to_tasks(auto_reply: true, &responder)
+        on_message do |message|
+          next if message.reply?
+
+          reply = responder.call(message)
+          send_reply(to: message.from, content: reply, in_reply_to: message.key) if auto_reply && reply
+        end
+        self
+      end
+
+      # Serve inbound bus tasks by running each through this member's #run and
+      # replying with the result — the one-call way to make a Robot cooperate on
+      # the bus the way a Cyborg already does out of the box.
+      #
+      # @param auto_reply [Boolean]
+      # @return [self]
+      def serve(auto_reply: true)
+        respond_to_tasks(auto_reply: auto_reply) { |message| run(bus_task_content(message)).reply }
+      end
+
       # Spawn a new robot on a shared bus.
       #
       # Creates a new Robot instance that shares this robot's bus,
@@ -88,10 +127,24 @@ module RobotLab
           template: template,
           local_tools: local_tools,
           bus: @bus,
+          **inherited_llm_settings,
           **
         )
       end
 
+      # Model/provider a spawned robot inherits from its parent so a specialist
+      # runs on the SAME LLM as the robot that spawned it (e.g. a local Ollama
+      # model) instead of falling back to the global default. Caller-supplied
+      # opts override these.
+      #
+      # @return [Hash]
+      def inherited_llm_settings
+        settings = {}
+        settings[:model]    = model    if model
+        settings[:provider] = provider if provider
+        settings
+      end
+
       # Connect this robot to a message bus.
       #
       # If a bus is provided, the robot joins it. If no bus is provided
@@ -159,6 +212,12 @@ module RobotLab
         @bus_poller_group   = :default
       end
 
+      # Flatten a task message's content to text for #run.
+      def bus_task_content(message)
+        content = message.content
+        content.is_a?(Hash) ? content.map { |k, v| "#{k}: #{v}" }.join("\n") : content.to_s
+      end
+
       # Enqueue a delivery to the robot's assigned poller.
       def enqueue_delivery(delivery)
         @bus_poller.enqueue(robot: self, delivery: delivery, group: @bus_poller_group)
@@ -167,13 +226,7 @@ module RobotLab
       # Process a single delivery (called by BusPoller drain thread).
       def process_delivery(delivery)
         message = delivery.message
-
-        # Correlate replies with outbox entries
-        if message.reply? && @outbox.key?(message.in_reply_to)
-          entry = @outbox[message.in_reply_to]
-          entry[:status] = :replied
-          entry[:replies] << message
-        end
+        correlate_reply(message) if message.reply?
 
         if @message_handler.arity == 1
           delivery.ack!
@@ -186,6 +239,17 @@ module RobotLab
         raise BusError, "Error handling bus message on robot '#{@name}': #{e.message}"
       end
 
+      # Mark the sender's outbox entry replied. Shared with senders on other
+      # threads, so guard with the bus mutex.
+      def correlate_reply(message)
+        @bus_mutex.synchronize do
+          entry = @outbox[message.in_reply_to] or return
+
+          entry[:status] = :replied
+          entry[:replies] << message
+        end
+      end
+
       # Publish a RobotMessage to a bus channel
       def publish_to_bus(channel_name, message)
         if defined?(Async::Task) && Async::Task.current?

data/lib/robot_lab/robot/hooking.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RobotLab
+  class Robot < RubyLLM::Agent
+    module Hooking
+      def run(message = nil, network: nil, task: nil, network_memory: nil, network_config: nil,
+              memory: nil, mcp: :none, tools: :none, hooks: nil, **kwargs, &block)
+        run_memory = resolve_run_memory(memory, network: network, network_memory: network_memory)
+        previous_writer = run_memory.current_writer
+        run_memory.current_writer = @name
+        context = RunHookContext.new(
+          robot: self,
+          network: network,
+          task: task,
+          memory: run_memory,
+          config: @config,
+          request: message
+        )
+
+        registries = hook_registries(network)
+
+        begin
+          RobotLab.with_hook_scope(registries, hooks) do
+            RobotLab::Hooks.run(:run, context, registries: registries, per_run_hooks: hooks) do
+              run_context = kwargs.except(:with)
+              prepare_tools(message: context.request, mcp: mcp, tools: tools,
+                            network: network, network_config: network_config)
+              rerender_template(run_context) if @template && run_context.any?
+              reservation = reserve_budget!
+              response = invoke_ask(context: context, kwargs: kwargs, hooks: hooks, block: block)
+              result = build_result(response, run_memory)
+              reconcile_budget!(reservation, response: response, result: result)
+              enforce_token_budget!
+              enforce_cost_budget!
+              result
+            end
+          end
+        ensure
+          remove_doom_loop_detection
+          restore_tool_call_callback if @config.max_tool_rounds
+          run_memory.current_writer = previous_writer
+        end
+      end
+
+      def on(handler_class, context: nil)
+        @hooks.on(handler_class, context: context)
+      end
+
+      private
+
+      def hook_registries(network = nil)
+        [RobotLab.hooks, network&.hooks, @hooks]
+      end
+    end
+  end
+end

data/lib/robot_lab/robot/mcp_management.rb

@@ -12,18 +12,24 @@ module RobotLab
 
       # Resolve MCP hierarchy: runtime -> robot build -> network -> config
       def resolve_mcp_hierarchy(runtime_value, network: nil, network_config: nil)
-        parent_value = network_config&.mcp || network&.network&.mcp || RobotLab.config.mcp
+        parent_value = network_config&.mcp || network_parent_config(network)&.mcp || RobotLab.config.mcp
         build_resolved = ToolConfig.resolve_mcp(@mcp_config, parent_value: parent_value)
         ToolConfig.resolve_mcp(runtime_value, parent_value: build_resolved)
       end
 
       # Resolve tools hierarchy: runtime -> robot build -> network -> config
       def resolve_tools_hierarchy(runtime_value, network: nil, network_config: nil)
-        parent_value = network_config&.tools || network&.network&.tools || RobotLab.config.tools
+        parent_value = network_config&.tools || network_parent_config(network)&.tools || RobotLab.config.tools
         build_resolved = ToolConfig.resolve_tools(@tools_config, parent_value: parent_value)
         ToolConfig.resolve_tools(runtime_value, parent_value: build_resolved)
       end
 
+      def network_parent_config(network)
+        return network.config if network.respond_to?(:config)
+
+        network&.network
+      end
+
       # 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)

data/lib/robot_lab/robot/template_rendering.rb

@@ -45,7 +45,7 @@ module RobotLab
         # Front matter is the base; @config (from constructor kwargs) overrides.
         fm_config = RunConfig.from_front_matter(parsed.metadata)
         effective = fm_config.merge(@config)
-        effective.apply_to(@chat)
+        effective.apply_to(@chat, provider: @provider, assume_model_exists: !@provider.nil?)
 
         # Resolve context (could be a Proc)
         resolved_ctx = resolve_context(context, network: nil)
@@ -142,7 +142,7 @@ module RobotLab
         apply_accumulated_extras(extras)
 
         effective = accumulated_config.merge(@config)
-        effective.apply_to(@chat)
+        effective.apply_to(@chat, provider: @provider, assume_model_exists: !@provider.nil?)
 
         combined = bodies.join("\n\n")
         @chat.with_instructions(combined) unless combined.empty?