aia 1.1.1 → 2.0.0.0.pre.beta2

data/lib/aia/mention_router.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+# lib/aia/mention_router.rb
+#
+# Handles @mention routing in multi-model networks.
+# Scans prompts for @name tokens, matches them to robots in the
+# network, and sends the prompt only to mentioned robots.
+
+module AIA
+  class MentionRouter
+    include ContentExtractor
+    include HandlerProtocol
+    include Speech
+
+    # Reserved @mention that broadcasts the message to every crew member.
+    BROADCAST_TOKEN = 'crew'
+
+    def initialize(ui_presenter:, tracker:, streaming_runner:)
+      @ui_presenter = ui_presenter
+      @tracker = tracker
+      @streaming_runner = streaming_runner
+    end
+
+    # Scan prompt for @mentions and route to matching robots.
+    # Returns true if mentions were handled, false otherwise.
+    #
+    # @param context [HandlerContext] — reads context.robot and context.prompt
+    # @return [Boolean]
+    # :reek:TooManyStatements -- mention routing: scan, resolve, report unknowns, dispatch; one decision chain
+    def handle(context) # rubocop:disable Naming/PredicateMethod
+      robot  = context.robot
+      prompt = context.prompt
+      return false unless robot.network?
+
+      mention_tokens = prompt.scan(/@(\w+)/i).flatten
+      return false if mention_tokens.empty?
+
+      all_robots = robot.crew
+      matched = resolve_mentions(mention_tokens, all_robots)
+
+      if matched.empty?
+        report_unknown_mentions(mention_tokens, all_robots)
+        return true
+      end
+
+      clean_prompt = strip_addressing_prefix(prompt)
+
+      report_unknown_mentions(mention_tokens, all_robots)
+      run_mentioned_robots(matched, clean_prompt, concurrent: leading_address_only?(prompt))
+      true
+    end
+
+    private
+
+    # Remove only the leading run of @mentions (the addressing prefix), so
+    # "@alice summarize this" becomes "summarize this" while @mentions inside the
+    # message body — "hello @hemie have you met @joker" — are preserved as
+    # content and reach the routed robots intact.
+    def strip_addressing_prefix(prompt)
+      prompt.sub(/\A(?:\s*@\w+)+\s*/i, '').strip
+    end
+
+    # True when every @mention is part of the leading address — i.e. nothing but
+    # @mentions before the message — so it's a broadcast to its addressees and
+    # runs concurrently. A @mention woven into the body makes it sequential.
+    def leading_address_only?(prompt)
+      !strip_addressing_prefix(prompt).match?(/@\w+/)
+    end
+
+    # Resolve @mention tokens to robots. The reserved @crew token broadcasts to
+    # the entire crew; otherwise each token is matched to a robot by name.
+    #
+    # @return [Array<Robot>]
+    def resolve_mentions(tokens, all_robots)
+      return all_robots if tokens.any? { |token| token.casecmp?(BROADCAST_TOKEN) }
+
+      tokens.filter_map { |token| all_robots.find { |r| r.name.casecmp?(token) } }.uniq(&:name)
+    end
+
+    def report_unknown_mentions(mention_tokens, all_robots)
+      known_names = all_robots.map { |r| r.name.downcase }
+      unknown = mention_tokens.reject { |t| t.casecmp?(BROADCAST_TOKEN) || known_names.include?(t.downcase) }
+      return unless unknown.any?
+
+      available = all_robots.map(&:name).join(', ')
+      unknown.each do |name|
+        @ui_presenter.display_info("Unknown robot: @#{name}  (available: #{available})")
+      end
+    end
+
+    def run_mentioned_robots(robots, prompt, concurrent:)
+      if robots.size == 1
+        run_streamed(robots.first, prompt)
+      elsif concurrent
+        run_concurrently(robots, prompt)
+      else
+        run_sequentially(robots, prompt)
+      end
+      @ui_presenter.display_separator
+    end
+
+    # Robots mentioned in the body run one at a time, each streaming its reply.
+    # After each reply, it is injected into every *other* member's conversation
+    # so later robots build on it and earlier ones carry it forward — the
+    # sequential pipeline becomes a shared, accumulating conversation.
+    def run_sequentially(robots, prompt)
+      robots.each do |bot|
+        content = run_streamed(bot, prompt)
+        share_with_peers(robots, bot, content) if content
+      end
+    end
+
+    # Add one robot's reply to every other pipeline member's chat history.
+    def share_with_peers(robots, author, content)
+      note = "[#{author.name}]: #{content}"
+      (robots - [author]).each do |peer|
+        next unless peer.respond_to?(:chat) && peer.chat
+
+        peer.chat.add_message({ role: :user, content: note })
+      end
+    end
+
+    # A single addressed robot streams its reply token-by-token.
+    def run_streamed(bot, prompt)
+      name = bot.name
+      result, streamed_content, elapsed = @streaming_runner.run(
+        bot, prompt,
+        header: "\nAI (#{name}):\n   ",
+        spinner_message: "#{name} processing..."
+      )
+      content = streamed_content || extract_content(result)
+
+      if streamed_content
+        puts
+        @ui_presenter.display_info("(#{format_duration(elapsed)})")
+      else
+        @ui_presenter.display_ai_response(reply_block(bot, content, elapsed))
+      end
+
+      finalize_reply(bot, prompt, result, content, elapsed)
+      content
+    rescue StandardError => e
+      @ui_presenter.display_info("Error from #{name}: #{e.class}: #{e.message}")
+      nil
+    end
+
+    # A broadcast to multiple robots runs them concurrently — no token streaming,
+    # which would interleave on one console. Each robot runs in its own thread and
+    # pushes its result to a queue; the main thread renders each reply as it lands
+    # (finish order), so wall-clock is the slowest robot, not the sum. Rendering
+    # stays single-threaded, so display/tracking are never touched concurrently.
+    def run_concurrently(robots, prompt)
+      @ui_presenter.display_info("Broadcasting to #{robots.size} robots concurrently…")
+
+      done = Queue.new
+      robots.each { |bot| Thread.new { done << run_member(bot, prompt) } }
+      robots.size.times { render_member(prompt, *done.pop) }
+    end
+
+    # Run one crew member to completion (off the streaming path), in a worker
+    # thread. Returns [bot, result, elapsed, error] — no shared state touched.
+    # :reek:DuplicateMethodCall -- each clock_gettime must read the clock at that moment (start, success end, failure end)
+    def run_member(bot, prompt)
+      started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      result  = bot.run(prompt, mcp: :inherit, tools: :inherit)
+      [bot, result, Process.clock_gettime(Process::CLOCK_MONOTONIC) - started, nil]
+    rescue StandardError => e
+      [bot, nil, Process.clock_gettime(Process::CLOCK_MONOTONIC) - started, e]
+    end
+
+    # Render one crew member's reply on the main thread.
+    def render_member(prompt, bot, result, elapsed, error)
+      if error
+        @ui_presenter.display_info("Error from #{bot.name}: #{error.class}: #{error.message}")
+        return
+      end
+
+      content = extract_content(result)
+      @ui_presenter.display_ai_response(reply_block(bot, content, elapsed))
+      finalize_reply(bot, prompt, result, content, elapsed)
+    end
+
+    def reply_block(bot, content, elapsed)
+      "**#{bot.name}** [#{bot.model || 'unknown'}] (#{format_duration(elapsed)}):\n#{content}"
+    end
+
+    def finalize_reply(bot, prompt, result, content, elapsed)
+      @tracker.record_turn(model: bot.model || 'unknown', input: prompt, result: result, elapsed: elapsed)
+      output_to_file(content)
+      display_metrics(result, elapsed: elapsed)
+      speak(content)
+    end
+
+    def display_metrics(result, elapsed: nil)
+      return unless AIA.config.flags.tokens
+
+      raw = result.respond_to?(:raw) ? result.raw : nil
+      return unless raw && raw.respond_to?(:input_tokens) && raw.input_tokens
+
+      model_id = extract_model_id(raw)
+      model_id ||= result.respond_to?(:robot_name) ? result.robot_name : "unknown"
+      metrics = {
+        model_id:      model_id,
+        input_tokens:  raw.input_tokens,
+        output_tokens: raw.output_tokens,
+        elapsed:       elapsed
+      }
+      @ui_presenter.display_token_metrics(metrics)
+    end
+
+    def extract_model_id(message)
+      return message.model_id if message.respond_to?(:model_id) && message.model_id
+      return message.model    if message.respond_to?(:model)    && message.model
+      nil
+    end
+  end
+end

data/lib/aia/model_alias_registry.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# lib/aia/model_alias_registry.rb
+#
+# Configurable alias table that maps short names, provider names,
+# and capability descriptors to model IDs.
+
+module AIA
+  class ModelAliasRegistry
+    DEFAULT_ALIASES = {
+      # Short names
+      "claude"     => "claude-sonnet-4-20250514",
+      "sonnet"     => "claude-sonnet-4-20250514",
+      "opus"       => "claude-opus-4-20250514",
+      "haiku"      => "claude-haiku-4-5-20251001",
+      "gpt4"       => "gpt-4o",
+      "gpt4o"      => "gpt-4o",
+      "gpt4mini"   => "gpt-4o-mini",
+      "gemini"     => "gemini-2.0-flash",
+      "flash"      => "gemini-2.0-flash",
+      "llama"      => "llama-3.1-70b",
+
+      # Provider names (resolve to default model for provider)
+      "anthropic"  => "claude-sonnet-4-20250514",
+      "openai"     => "gpt-4o",
+      "google"     => "gemini-2.0-flash",
+      "meta"       => "llama-3.1-70b",
+
+      # Capability descriptors
+      "fast"       => "claude-haiku-4-5-20251001",
+      "cheap"      => "gpt-4o-mini",
+      "best"       => "claude-opus-4-20250514",
+      "coding"     => "claude-sonnet-4-20250514",
+      "vision"     => "gpt-4o"
+    }.freeze
+
+    def initialize(custom_aliases = {})
+      @aliases = DEFAULT_ALIASES.merge(normalize_keys(custom_aliases))
+    end
+
+    # Resolve a single name or alias to a model ID.
+    #
+    # @param name_or_alias [String] model name, alias, or capability descriptor
+    # @return [String] resolved model ID
+    def resolve(name_or_alias)
+      normalized = normalize_key(name_or_alias)
+      @aliases[normalized] || fuzzy_match(name_or_alias) || name_or_alias.to_s.strip
+    end
+
+    # Resolve a string containing multiple model references.
+    # Handles comma-separated, "and"-separated, and mixed formats.
+    #
+    # @param input [String] e.g., "claude and gemini", "gpt4, llama"
+    # @return [Array<String>] resolved model IDs
+    def resolve_multiple(input)
+      names = input.to_s.split(/\s*(?:,|and|&|\+)\s*/i)
+      names.map { |n| resolve(n.strip) }.uniq
+    end
+
+    # Check if a name is a known alias
+    #
+    # @param name [String] the name to check
+    # @return [Boolean]
+    def known?(name)
+      @aliases.key?(normalize_key(name))
+    end
+
+    # List all known aliases
+    #
+    # @return [Hash<String, String>]
+    def all_aliases
+      @aliases.dup
+    end
+
+    private
+
+    def normalize_key(name)
+      name.to_s.strip.downcase.gsub(/[-_\s]+/, '')
+    end
+
+    def normalize_keys(hash)
+      hash.transform_keys { |k| normalize_key(k) }
+    end
+
+    def fuzzy_match(name)
+      return nil unless defined?(RubyLLM) && RubyLLM.respond_to?(:models)
+
+      target = name.to_s.downcase.strip
+      return nil if target.empty?
+
+      match = RubyLLM.models.find { |m| m.id.downcase.include?(target) }
+      match&.id
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/aia/model_switch_handler.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# lib/aia/model_switch_handler.rb
+#
+# Handles natural language model-change intent detection.
+# When a model-change intent is detected by the classification KB,
+# extracts model names, confirms with the user, and reconfigures.
+
+module AIA
+  class ModelSwitchHandler
+    include HandlerProtocol
+
+    def initialize(alias_registry, ui_presenter)
+      @aliases = alias_registry
+      @ui = ui_presenter
+      @model_exists_cache = {}
+    end
+
+    # Natural language model switching via KBS intent detection has been removed.
+    # Use the /model directive for model changes.
+    #
+    # @param context [HandlerContext]
+    # @return [Boolean] always false
+    def handle(context) # rubocop:disable Naming/PredicateMethod
+      false
+    end
+
+    private
+
+    def handle_switch(intent, config)
+      models = extract_model_names(intent[:raw_text])
+      return false if models.empty?
+
+      resolved = models.map { |m| @aliases.resolve(m) }
+      confirm_and_apply(config, resolved)
+    end
+
+    def handle_compare(intent, config) # rubocop:disable Naming/PredicateMethod
+      models = extract_model_names(intent[:raw_text])
+      return false if models.size < 2
+
+      resolved = models.map { |m| @aliases.resolve(m) }
+
+      @ui.display_info("Interpreted as: compare #{resolved.join(', ')}")
+      @ui.display_info("Proceed? (y/n)")
+
+      response = @ui.ask_question
+      return false unless response&.strip&.downcase == 'y'
+
+      config.flags.consensus = true
+      apply_model_change(config, resolved)
+      true
+    end
+
+    def handle_capability_switch(intent, config)
+      capability = intent[:capability]
+      resolved = [@aliases.resolve(capability)]
+      confirm_and_apply(config, resolved)
+    end
+
+    def confirm_and_apply(config, resolved) # rubocop:disable Naming/PredicateMethod
+      @ui.display_info("Interpreted as: /model #{resolved.join(', ')}")
+      @ui.display_info("Proceed? (y/n)")
+
+      response = @ui.ask_question
+      return false unless response&.strip&.downcase == 'y'
+
+      apply_model_change(config, resolved)
+      true
+    end
+
+    def extract_model_names(text)
+      return [] unless text
+
+      # Check each word against known aliases and model names
+      words = text.downcase.scan(/[\w.-]+/)
+      words.select { |w| @aliases.known?(w) || model_exists?(w) }.uniq
+    end
+
+    def model_exists?(name)
+      return @model_exists_cache[name] if @model_exists_cache.key?(name)
+      @model_exists_cache[name] = begin
+        return false unless defined?(RubyLLM) && RubyLLM.respond_to?(:models)
+        !!RubyLLM.models.find(name)
+      rescue StandardError
+        false
+      end
+    end
+
+    def apply_model_change(config, model_names)
+      config.models = model_names.map { |name| AIA::ModelSpec.new(name: name) }
+
+      history_mode = config.respond_to?(:model_switch_history) ?
+        config.model_switch_history&.to_sym : :clean
+
+      AIA.client = RobotFactory.rebuild(config, history_mode: history_mode)
+      @ui.display_info("Model switched to: #{model_names.join(', ')}")
+    end
+  end
+end

data/lib/aia/network_builder.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+# lib/aia/network_builder.rb
+#
+# Stateless module for building RobotLab::Network instances.
+# Extracted from RobotFactory to reduce its size and isolate
+# the network-specific construction logic.
+
+module AIA
+  module NetworkBuilder
+    module_function
+
+    # Build a network where each prompt in the pipeline is a sequential step.
+    #
+    # @param config [AIA::Config]
+    # @param namer [RobotNamer]
+    # @return [RobotLab::Network]
+    # :reek:TooManyStatements -- gathers shared robot inputs then declares one network task per pipeline step
+    def build_pipeline_network(config, namer)
+      prompts = config.pipeline
+      run_config = RobotFactory.build_run_config(config)
+      tools = ToolLoader.filtered_tools(config)
+      mcp = RobotFactory.mcp_server_configs(config)
+      model_spec = config.models.first
+
+      RobotLab.create_network(name: "aia-pipeline") do
+        prev = nil
+        prompts.each_with_index do |_prompt_id, i|
+          task_name = :"step_#{i}"
+          robot = RobotFactory.build_robot(
+            model_spec,
+            name:          "#{namer.name_for(model_spec.name)}-s#{i}",
+            system_prompt: nil,
+            local_tools:   tools,
+            mcp_servers:   mcp,
+            config:        run_config
+          )
+          task task_name, robot, depends_on: prev ? [prev] : :none
+          prev = task_name
+        end
+      end
+    end
+
+    # Build a network where multiple models run in parallel.
+    #
+    # @param config [AIA::Config]
+    # @param namer [RobotNamer]
+    # @return [RobotLab::Network]
+    def build_parallel_network(config, namer)
+      run_config = RobotFactory.build_run_config(config)
+      tools = ToolLoader.filtered_tools(config)
+      mcp = RobotFactory.mcp_server_configs(config)
+      aia_config = config
+      roster = config.models.map { |spec| { name: namer.name_for(spec.name), spec: spec } }
+      build_robot = ->(entry) { build_roster_robot(entry, roster, tools, mcp, run_config, aia_config) }
+
+      RobotLab.create_network(name: "aia-parallel") do
+        roster.each do |entry|
+          task entry[:spec].internal_id.to_sym, build_robot.call(entry), depends_on: :none
+        end
+      end
+    end
+
+    # Build a consensus network: all models run in parallel, then a
+    # synthesizer merges the results.
+    #
+    # @param config [AIA::Config]
+    # @param namer [RobotNamer]
+    # @return [RobotLab::Network]
+    # :reek:TooManyStatements -- gathers shared robot inputs, declares one task per roster member plus the synthesizer
+    def build_consensus_network(config, namer)
+      run_config = RobotFactory.build_run_config(config)
+      tools  = ToolLoader.filtered_tools(config)
+      mcp    = RobotFactory.mcp_server_configs(config)
+      models = config.models
+      primary = models.first
+      aia_config = config
+      roster = models.map { |spec| { name: namer.name_for(spec.name), spec: spec } }
+      build_robot = ->(entry) { build_roster_robot(entry, roster, tools, mcp, run_config, aia_config) }
+
+      RobotLab.create_network(name: "aia-consensus") do
+        roster.each do |entry|
+          task entry[:spec].internal_id.to_sym, build_robot.call(entry), depends_on: :none
+        end
+
+        synthesizer = RobotFactory.build_robot(
+          primary,
+          name:          "Weaver",
+          system_prompt: "You are a synthesizer. Review the responses from multiple AI models " \
+                         "and create a unified, coherent response that captures the best " \
+                         "insights from each.",
+          config:        run_config
+        )
+        task :consensus, synthesizer,
+             depends_on: models.map { |s| s.internal_id.to_sym }
+      end
+    end
+
+    # Shared helper: builds a single roster robot (used by parallel and consensus networks).
+    # :reek:LongParameterList { max_params: 6 } -- pass-through of the shared per-network build inputs
+    def build_roster_robot(entry, roster, tools, mcp, run_config, aia_config)
+      spec = entry[:spec]
+      identity = SystemPromptAssembler.build_identity_prompt(entry[:name], spec, roster)
+      base_prompt = SystemPromptAssembler.resolve_system_prompt(aia_config, spec)
+      system_prompt = [identity, base_prompt].compact.join("\n\n")
+      RobotFactory.build_robot(
+        spec,
+        name:          entry[:name],
+        system_prompt: system_prompt,
+        local_tools:   tools,
+        mcp_servers:   mcp,
+        config:        run_config
+      )
+    end
+
+    # Build a concurrent MCP network where independent server groups
+    # run in parallel with a synthesizer to merge results.
+    #
+    # @param config [AIA::Config]
+    # @param namer [RobotNamer]
+    # @param server_groups [Array<Array<Hash>>]
+    # @return [RobotLab::Network]
+    # :reek:TooManyStatements -- gathers shared robot inputs, declares one task per server group plus the synthesizer
+    def build_concurrent_mcp_network(config, namer, server_groups)
+      run_config = RobotFactory.build_run_config(config)
+      tools = ToolLoader.filtered_tools(config)
+      model_spec = config.models.first
+      system_prompt = SystemPromptAssembler.resolve_system_prompt(config, model_spec)
+
+      network = RobotLab.create_network(name: "aia-concurrent-mcp") do
+        server_groups.each_with_index do |group, i|
+          robot = RobotFactory.build_robot(
+            model_spec,
+            name:          "#{namer.name_for(model_spec.name)}-w#{i}",
+            system_prompt: system_prompt,
+            local_tools:   tools,
+            mcp_servers:   group.map { |s| RobotFactory.normalize_mcp_config(s) },
+            config:        run_config
+          )
+          task :"mcp_worker_#{i}", robot, depends_on: :none
+        end
+
+        synthesizer = RobotFactory.build_robot(
+          model_spec,
+          name:          "Weaver",
+          system_prompt: "You are a synthesizer. Merge the following results from " \
+                         "multiple specialized queries into a coherent response. " \
+                         "Preserve all relevant information. Resolve contradictions.",
+          config:        run_config
+        )
+        task :synthesize, synthesizer,
+             depends_on: server_groups.each_index.map { |i| :"mcp_worker_#{i}" }
+      end
+
+      RobotFactory.initialize_network_memory(network, config)
+      RobotFactory.setup_memory_subscriptions(network, config)
+      network
+    end
+  end
+end

data/lib/aia/network_memory_manager.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# lib/aia/network_memory_manager.rb
+#
+# Manages shared memory initialization and subscriptions for
+# multi-robot networks. Extracted from RobotFactory.
+
+module AIA
+  class NetworkMemoryManager
+    class << self
+      # Initialize shared memory for a network with session context.
+      #
+      # @param network [RobotLab::Network]
+      # @param config [AIA::Config]
+      # @return [RobotLab::Network]
+      def initialize_memory(network, config)
+        return network unless network.respond_to?(:memory)
+
+        data = network.memory.data
+        data.session_id  = SecureRandom.hex(8)
+        data.model_count = config.models.size
+        data.model_names = config.models.map(&:name)
+        data.mode        = config.flags.consensus ? :consensus : :parallel
+        data.turn_count  = 0
+
+        network
+      end
+
+      # Set up memory subscriptions for debug logging and completion tracking.
+      #
+      # @param network [RobotLab::Network]
+      # @param config [AIA::Config]
+      def setup_subscriptions(network, config)
+        return unless network.respond_to?(:memory)
+
+        memory = network.memory
+
+        if config.flags.debug
+          memory.subscribe_pattern("result_*") do |change|
+            AIA::LoggerManager.aia_logger.debug(
+              "Memory: #{change.key} by #{change.writer} at #{change.timestamp}"
+            )
+          end
+        end
+
+        memory.set(:completed_count, 0)
+        memory.subscribe_pattern("result_*") do |change|
+          next unless change.created?
+          count = memory.get(:completed_count) || 0
+          memory.set(:completed_count, count + 1)
+        end
+      end
+    end
+  end
+end

data/lib/aia/patches/ruby_llm_streaming_error.rb

@@ -0,0 +1,43 @@
+# lib/aia/patches/ruby_llm_streaming_error.rb
+#
+# Patches RubyLLM::Streaming#handle_error_chunk to locate the SSE `data:` line
+# robustly.
+#
+# The shipped implementation assumes the `data:` line is the SECOND line of the
+# same chunk as `event: error`:
+#
+#     error_data = chunk.split("\n")[1].delete_prefix('data: ')
+#
+# When a provider flushes `event: error` and its `data:` line in SEPARATE stream
+# chunks (LM Studio does this on, e.g., a context-length overflow),
+# chunk.split("\n")[1] is nil and the real provider message is masked as the
+# cryptic `NoMethodError: undefined method 'delete_prefix' for nil`. This
+# version scans the chunk for the `data:` line so the actual error propagates to
+# the user. Falls back to the whole chunk when no data line is present, which
+# still parses cleanly instead of raising.
+#
+# Applied via #prepend so it cleanly overrides the buggy method while reusing
+# ruby_llm's own private parse_error_from_json. Guarded against API drift: if
+# parse_error_from_json is renamed/removed the patch is skipped with a warning.
+#
+# NOTE: This fixes a genuine upstream bug — it should be contributed to
+# crmne/ruby_llm so this patch can eventually be retired.
+
+module AIA
+  module RubyLLMStreamingError
+    private
+
+    def handle_error_chunk(chunk, env)
+      data_line  = chunk.to_s.lines.find { |line| line.start_with?('data:') }
+      error_data = data_line ? data_line.sub(/\Adata:\s*/, '').strip : chunk.to_s.strip
+      parse_error_from_json(error_data, env, 'Failed to parse error chunk')
+    end
+  end
+end
+
+if RubyLLM::Streaming.private_method_defined?(:parse_error_from_json)
+  RubyLLM::Streaming.prepend(AIA::RubyLLMStreamingError)
+else
+  $stderr.puts "WARNING: [AIA] ruby_llm patch skipped: RubyLLM::Streaming#parse_error_from_json " \
+               "not found (ruby_llm #{RubyLLM::VERSION}). Streaming error messages may be cryptic."
+end