aia 0.9.24 → 0.10.2

data/lib/aia/ruby_llm_adapter.rb

@@ -1,6 +1,9 @@
 # lib/aia/ruby_llm_adapter.rb
 
 require 'async'
+require 'fileutils'
+require 'json'
+require 'simple_flow'
 require_relative '../extensions/ruby_llm/provider_fix'
 
 module AIA
@@ -21,13 +24,15 @@ module AIA
 
     def configure_rubyllm
       # TODO: Add some of these configuration items to AIA.config
+      # Note: RubyLLM supports specific providers. Use provider prefix (e.g., "xai/grok-beta")
+      # for providers not directly configured here.
       RubyLLM.configure do |config|
         config.anthropic_api_key  = ENV.fetch('ANTHROPIC_API_KEY', nil)
         config.deepseek_api_key   = ENV.fetch('DEEPSEEK_API_KEY', nil)
         config.gemini_api_key     = ENV.fetch('GEMINI_API_KEY', nil)
         config.gpustack_api_key   = ENV.fetch('GPUSTACK_API_KEY', nil)
         config.mistral_api_key    = ENV.fetch('MISTRAL_API_KEY', nil)
-        config.openrouter_api_key = ENV.fetch('OPENROUTER_API_KEY', nil)
+        config.openrouter_api_key = ENV.fetch('OPEN_ROUTER_API_KEY', nil)
         config.perplexity_api_key = ENV.fetch('PERPLEXITY_API_KEY', nil)
 
         # These providers require a little something extra
@@ -65,20 +70,79 @@ module AIA
         # Connection pooling settings removed - not supported in current RubyLLM version
         # config.connection_pool_size       = 10  # Number of connections to maintain in pool
         # config.connection_pool_timeout    = 60  # Connection pool timeout in seconds
-        # config.log_file   = '/logs/ruby_llm.log'
-        config.log_level = :fatal # debug level can also be set to debug by setting RUBYLLM_DEBUG envar to true
+
+        # Configure RubyLLM logger from centralized LoggerManager
+        config.log_level = LoggerManager.llm_log_level_symbol
       end
+
+      # Configure RubyLLM's logger output destination
+      LoggerManager.configure_llm_logger
+
+      # Configure RubyLLM::MCP's logger early, before any MCP operations
+      # This ensures all MCP debug/info logs go to the configured log file
+      LoggerManager.configure_mcp_logger
     end
 
 
     def refresh_local_model_registry
-      if  AIA.config.refresh.nil?           ||
-          Integer(AIA.config.refresh).zero? ||
-          Date.today > (AIA.config.last_refresh + Integer(AIA.config.refresh))
-        RubyLLM.models.refresh!
-        AIA.config.last_refresh = Date.today
-        AIA::Config.dump_config(AIA.config, AIA.config.config_file) if AIA.config.config_file
+      return if models_json_path.nil? # Skip if no aia_dir configured
+
+      # Coerce refresh_days to integer (env vars come as strings)
+      refresh_days = AIA.config.registry.refresh
+      refresh_days = refresh_days.to_i if refresh_days.respond_to?(:to_i)
+      refresh_days ||= 7 # Default to 7 days if nil
+
+      last_refresh = models_last_refresh
+      models_exist = !last_refresh.nil?
+
+      # If refresh is disabled (0), just save current models if file doesn't exist
+      if refresh_days.zero?
+        save_models_to_json unless models_exist
+        return
       end
+
+      # Determine if refresh is needed:
+      # 1. Always refresh if models.json doesn't exist (initial setup)
+      # 2. Otherwise, refresh if enough time has passed
+      needs_refresh = if !models_exist
+                        true # Initial refresh needed (no models.json)
+                      else
+                        Date.today > (last_refresh + refresh_days)
+                      end
+
+      return unless needs_refresh
+
+      # Refresh models from RubyLLM (fetches latest model info)
+      RubyLLM.models.refresh!
+
+      # Save models to JSON file in aia_dir
+      save_models_to_json
+    end
+
+    def models_json_path
+      aia_dir = AIA.config.paths&.aia_dir
+      return nil if aia_dir.nil?
+
+      File.join(File.expand_path(aia_dir), 'models.json')
+    end
+
+    # Returns the last refresh date based on models.json modification time
+    def models_last_refresh
+      path = models_json_path
+      return nil if path.nil? || !File.exist?(path)
+
+      File.mtime(path).to_date
+    end
+
+    def save_models_to_json
+      return if models_json_path.nil?
+
+      aia_dir = File.expand_path(AIA.config.paths.aia_dir)
+      FileUtils.mkdir_p(aia_dir)
+
+      models_data = RubyLLM.models.all.map(&:to_h)
+
+      File.write(models_json_path, JSON.pretty_generate(models_data))
     end
 
 
@@ -170,7 +234,7 @@ module AIA
       @models = valid_chats.keys
 
       # Update the config to reflect only the valid models (keep as specs)
-      AIA.config.model = @model_specs
+      # Note: models is an array, not directly settable - skip this update
 
       # Report successful models
       if failed_models.any?
@@ -194,16 +258,17 @@ module AIA
       @tools = []
 
       support_local_tools
-      support_mcp_lazy
+      support_mcp_with_simple_flow  # Parallel MCP connections via SimpleFlow
       filter_tools_by_allowed_list
       filter_tools_by_rejected_list
       drop_duplicate_tools
 
       if tools.empty?
         AIA.config.tool_names = ''
+        AIA.config.loaded_tools = []
       else
         AIA.config.tool_names = @tools.map(&:name).join(', ')
-        AIA.config.tools      = @tools
+        AIA.config.loaded_tools = @tools
       end
     end
 
@@ -221,13 +286,20 @@ module AIA
         AIA.config.tool_names = ''
       else
         AIA.config.tool_names = @tools.map(&:name).join(', ')
-        AIA.config.tools      = @tools
+        AIA.config.loaded_tools = @tools
       end
     end
 
 
     def support_local_tools
-      @tools += ObjectSpace.each_object(Class).select do |klass|
+      # First, load any required libraries specified in config
+      load_require_libs
+
+      # Then, load tool files from tools.paths
+      load_tool_files
+
+      # Now scan ObjectSpace for RubyLLM::Tool subclasses
+      tool_classes = ObjectSpace.each_object(Class).select do |klass|
         next false unless klass < RubyLLM::Tool
 
         # Filter out tools that can't be instantiated without arguments
@@ -240,37 +312,379 @@ module AIA
           false
         end
       end
+
+      @tools += tool_classes
+    end
+
+    def load_require_libs
+      require_libs = AIA.config.require_libs
+      return if require_libs.nil? || require_libs.empty?
+
+      require_libs.each do |lib|
+        begin
+          # Activate gem and add to load path (bypasses Bundler's restrictions)
+          activate_gem_for_require(lib)
+
+          require lib
+
+          # After requiring, trigger tool loading if the library supports it
+          # This handles gems like shared_tools that use Zeitwerk lazy loading
+          trigger_tool_loading(lib)
+        rescue LoadError => e
+          warn "Warning: Failed to require library '#{lib}': #{e.message}"
+          warn "Hint: Make sure the gem is installed: gem install #{lib}"
+        rescue StandardError => e
+          warn "Warning: Error in library '#{lib}': #{e.class} - #{e.message}"
+        end
+      end
+    end
+
+    # Activate a gem and add its lib path to $LOAD_PATH
+    # This bypasses Bundler's restrictions on loading non-bundled gems
+    def activate_gem_for_require(lib)
+      # First try normal activation
+      return if Gem.try_activate(lib)
+
+      # Bundler intercepts Gem::Specification methods, so search gem dirs directly
+      gem_path = find_gem_path(lib)
+      if gem_path
+        lib_path = File.join(gem_path, 'lib')
+        $LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+      end
     end
 
+    # Find gem path by searching gem directories directly
+    # This bypasses Bundler's restrictions
+    def find_gem_path(gem_name)
+      gem_dirs = Gem.path.flat_map do |base|
+        gems_dir = File.join(base, 'gems')
+        next [] unless File.directory?(gems_dir)
+
+        Dir.glob(File.join(gems_dir, "#{gem_name}-*")).select do |path|
+          File.directory?(path) && File.basename(path).match?(/^#{Regexp.escape(gem_name)}-[\d.]+/)
+        end
+      end
+
+      # Return the most recent version
+      gem_dirs.sort.last
+    end
 
-    def support_mcp_lazy
-      # Only load MCP tools if MCP servers are actually configured
-      return if AIA.config.mcp_servers.nil? || AIA.config.mcp_servers.empty?
+    # Some tool libraries use lazy loading (e.g., Zeitwerk) and need explicit
+    # triggering to load tool classes into ObjectSpace
+    def trigger_tool_loading(lib)
+      # Convert lib name to constant (e.g., 'shared_tools' -> SharedTools)
+      const_name = lib.split(/[_-]/).map(&:capitalize).join
 
       begin
-        RubyLLM::MCP.establish_connection
-        @tools += RubyLLM::MCP.tools
-      rescue StandardError => e
-        warn "Warning: Failed to connect MCP clients: #{e.message}"
+        mod = Object.const_get(const_name)
+
+        # Try common methods that libraries use to load tools
+        if mod.respond_to?(:load_all_tools)
+          mod.load_all_tools
+        elsif mod.respond_to?(:tools)
+          # Calling .tools often triggers lazy loading
+          mod.tools
+        end
+      rescue NameError
+        # Constant doesn't exist, library might use different naming
+      end
+    end
+
+    def load_tool_files
+      paths = AIA.config.tools&.paths
+      return if paths.nil? || paths.empty?
+
+      paths.each do |path|
+        expanded_path = File.expand_path(path)
+        if File.exist?(expanded_path)
+          begin
+            require expanded_path
+          rescue LoadError, StandardError => e
+            warn "Warning: Failed to load tool file '#{path}': #{e.message}"
+          end
+        else
+          warn "Warning: Tool file not found: #{path}"
+        end
       end
     end
 
 
+    # Default timeout for MCP client initialization (in milliseconds)
+    # RubyLLM::MCP expects timeout in milliseconds (e.g., 8000 = 8 seconds)
+    # Using a short timeout to prevent slow servers from blocking startup
+    MCP_DEFAULT_TIMEOUT = 8_000  # 8 seconds (same as RubyLLM::MCP default)
+
     def support_mcp
+      if AIA.config.flags.no_mcp
+        logger.debug("MCP processing bypassed via --no-mcp flag")
+        return
+      end
+
+      logger.debug("Starting MCP connection via RubyLLM::MCP.establish_connection")
+      LoggerManager.configure_mcp_logger
+
+      start_time = Time.now
       RubyLLM::MCP.establish_connection
+      elapsed = Time.now - start_time
+
+      tool_count = RubyLLM::MCP.tools.size
       @tools += RubyLLM::MCP.tools
+
+      logger.info("MCP connection established", elapsed_seconds: elapsed.round(2), tool_count: tool_count)
     rescue StandardError => e
+      logger.error("Failed to connect MCP clients", error_class: e.class.name, error_message: e.message)
+      logger.debug("MCP connection error backtrace", backtrace: e.backtrace&.first(5))
       warn "Warning: Failed to connect MCP clients: #{e.message}"
     end
 
+    # =========================================================================
+    # SimpleFlow-based Parallel MCP Connection
+    # =========================================================================
+    # Uses fiber-based concurrency to connect to all MCP servers in parallel.
+    # This reduces total connection time from sum(timeouts) to max(timeouts).
+
+    def support_mcp_with_simple_flow
+      if AIA.config.flags.no_mcp
+        logger.debug("MCP processing bypassed via --no-mcp flag")
+        return
+      end
+
+      if AIA.config.mcp_servers.nil? || AIA.config.mcp_servers.empty?
+        logger.debug("No MCP servers configured, skipping MCP setup")
+        return
+      end
+
+      # Initialize tracking (kept for compatibility with Utility.robot)
+      AIA.config.connected_mcp_servers = []
+      AIA.config.failed_mcp_servers = []
+
+      servers = AIA.config.mcp_servers
+      server_names = servers.map { |s| s[:name] || s['name'] }.compact
+
+      logger.info("Starting parallel MCP connection", server_count: servers.size, servers: server_names)
+      $stderr.puts "MCP: Connecting to #{server_names.join(', ')}..."
+      $stderr.flush
+
+      LoggerManager.configure_mcp_logger
+
+      # Build steps array first (outside the block to preserve self reference)
+      # Each step is a [name, callable] pair for parallel execution
+      adapter = self
+      steps = servers.map do |server|
+        name = (server[:name] || server['name']).to_sym
+        logger.debug("Building connection step", server: name)
+        [name, adapter.send(:build_mcp_connection_step, server)]
+      end
+
+      # Build parallel pipeline - each server is independent (depends_on: :none)
+      # All servers will connect concurrently using fiber-based async
+      logger.debug("Creating SimpleFlow pipeline", step_count: steps.size)
+      pipeline = SimpleFlow::Pipeline.new(concurrency: :async) do
+        steps.each do |name, callable|
+          step name, callable, depends_on: :none
+        end
+      end
+
+      # Execute all connections in parallel
+      start_time = Time.now
+      initial_result = SimpleFlow::Result.new({ tools: [] })
+      final_result = pipeline.call_parallel(initial_result)
+      elapsed = Time.now - start_time
+
+      logger.info("Parallel MCP connection completed", elapsed_seconds: elapsed.round(2))
+
+      # Extract results and populate config arrays for compatibility
+      extract_mcp_results(final_result)
+    end
+
+    def build_mcp_connection_step(server)
+      # Capture logger in closure for use within the lambda
+      log = logger
+
+      ->(result) {
+        name = server[:name] || server['name']
+        start_time = Time.now
+
+        begin
+          log.debug("Registering MCP client", server: name)
+
+          # Register client with RubyLLM::MCP
+          client = register_single_mcp_client(server)
+
+          log.debug("Starting client connection", server: name)
+
+          # Start and verify connection
+          client.start
+          caps = client.capabilities
+          has_capabilities = caps && (caps.is_a?(Hash) ? !caps.empty? : caps)
+
+          elapsed = Time.now - start_time
+
+          if client.alive? && has_capabilities
+            # Success - get tools and record in context
+            tools = begin
+              client.tools
+            rescue StandardError => tool_err
+              log.warn("Failed to retrieve tools", server: name, error: tool_err.message)
+              []
+            end
+
+            tool_names = tools.map { |t| t.respond_to?(:name) ? t.name : t.to_s }
+            log.info("Connected successfully", server: name, elapsed_seconds: elapsed.round(2), tool_count: tools.size)
+            log.debug("Available tools", server: name, tools: tool_names)
+
+            result
+              .with_context(name.to_sym, { status: :connected, tools: tools })
+              .continue(result.value)
+          else
+            # Connection issue - determine specific error
+            error = determine_mcp_connection_error(client, caps)
+            log.warn("Connection failed", server: name, elapsed_seconds: elapsed.round(2), error: error)
+            log.debug("Connection details", server: name, alive: client.alive?, capabilities: caps.inspect)
+
+            result
+              .with_error(name.to_sym, error)
+              .with_context(name.to_sym, { status: :failed })
+              .continue(result.value) # Continue to allow other servers
+          end
+        rescue StandardError => e
+          elapsed = Time.now - start_time
+          error_msg = e.message.downcase.include?('timeout') ?
+            "Connection timed out" : e.message
+
+          log.error("Connection exception", server: name, elapsed_seconds: elapsed.round(2), error_class: e.class.name, error: error_msg)
+          log.debug("Exception backtrace", server: name, backtrace: e.backtrace&.first(3))
+
+          result
+            .with_error(name.to_sym, error_msg)
+            .with_context(name.to_sym, { status: :failed })
+            .continue(result.value)
+        end
+      }
+    end
+
+    def register_single_mcp_client(server)
+      name    = server[:name]    || server['name']
+      command = server[:command] || server['command']
+      args    = server[:args]    || server['args'] || []
+      env     = server[:env]     || server['env'] || {}
+
+      raw_timeout = server[:timeout] || server['timeout'] ||
+                    server[:request_timeout] || server['request_timeout'] ||
+                    MCP_DEFAULT_TIMEOUT
+      request_timeout = raw_timeout.to_i < 1000 ? (raw_timeout.to_i * 1000) : raw_timeout.to_i
+      request_timeout = [request_timeout, 30_000].min
+
+      logger.debug("Configuring client", server: name, command: command, args: args, timeout_ms: request_timeout)
+      logger.debug("Environment variables", server: name, env_keys: env.keys) unless env.empty?
+
+      mcp_config = { command: command, args: Array(args) }
+      mcp_config[:env] = env unless env.empty?
+
+      begin
+        logger.debug("Adding client to RubyLLM::MCP with request_timeout", server: name)
+        RubyLLM::MCP.add_client(
+          name: name,
+          transport_type: :stdio,
+          config: mcp_config,
+          request_timeout: request_timeout,
+          start: false
+        )
+      rescue ArgumentError => e
+        # If request_timeout isn't supported in this version, try without it
+        if e.message.include?('timeout')
+          logger.debug("Retrying without request_timeout (unsupported in this RubyLLM::MCP version)", server: name)
+          RubyLLM::MCP.add_client(
+            name: name,
+            transport_type: :stdio,
+            config: mcp_config,
+            start: false
+          )
+        else
+          logger.error("Failed to add client", server: name, error: e.message)
+          raise
+        end
+      end
+
+      logger.debug("Client registered successfully", server: name)
+      RubyLLM::MCP.clients[name]
+    end
+
+    def determine_mcp_connection_error(client, caps)
+      if !client.alive?
+        "Connection failed"
+      elsif caps.nil?
+        "Connection timed out (no response)"
+      elsif caps.is_a?(Hash) && caps.empty?
+        "Connection timed out (empty capabilities)"
+      else
+        "Connection timed out (no capabilities received)"
+      end
+    end
+
+    def extract_mcp_results(result)
+      logger.debug("Extracting MCP connection results from SimpleFlow pipeline")
+      all_tools = []
+
+      result.context.each do |server_name, info|
+        name = server_name.to_s
+        if info[:status] == :connected
+          tool_count = (info[:tools] || []).size
+          logger.debug("Extracting tools from connected server", server: name, tool_count: tool_count)
+          AIA.config.connected_mcp_servers << name
+          all_tools.concat(info[:tools] || [])
+        end
+      end
+
+      result.errors.each do |server_name, messages|
+        logger.debug("Recording failure", server: server_name, error: messages.first)
+        AIA.config.failed_mcp_servers << {
+          name: server_name.to_s,
+          error: messages.first
+        }
+      end
+
+      @tools += all_tools
+
+      logger.info("MCP results",
+        connected_count: AIA.config.connected_mcp_servers.size,
+        failed_count: AIA.config.failed_mcp_servers.size,
+        total_tools: all_tools.size
+      )
+
+      # Report results
+      report_mcp_connection_results(all_tools.size)
+    end
+
+    def report_mcp_connection_results(tool_count)
+      if AIA.config.connected_mcp_servers.any?
+        logger.info("Successfully connected", servers: AIA.config.connected_mcp_servers)
+        $stderr.puts "MCP: Connected to #{AIA.config.connected_mcp_servers.join(', ')} (#{tool_count} tools)"
+      end
+
+      AIA.config.failed_mcp_servers.each do |failure|
+        logger.warn("Server failed", server: failure[:name], error: failure[:error])
+        $stderr.puts "⚠️  MCP: '#{failure[:name]}' failed - #{failure[:error]}"
+      end
+
+      if AIA.config.connected_mcp_servers.empty? && AIA.config.failed_mcp_servers.any?
+        logger.error("No MCP servers connected successfully")
+        $stderr.puts "MCP: No servers connected successfully"
+      end
+
+      $stderr.flush
+    end
 
     def drop_duplicate_tools
       seen_names = Set.new
       original_size = @tools.size
 
+      logger.debug("Checking tools for duplicates", tool_count: original_size)
+
       @tools.select! do |tool|
         tool_name = tool.name
         if seen_names.include?(tool_name)
+          logger.warn("Duplicate tool detected - keeping first occurrence only", tool: tool_name)
           warn "WARNING: Duplicate tool name detected: '#{tool_name}'. Only the first occurrence will be used."
           false
         else
@@ -280,7 +694,12 @@ module AIA
       end
 
       removed_count = original_size - @tools.size
-      warn "Removed #{removed_count} duplicate tools" if removed_count > 0
+      if removed_count > 0
+        logger.info("Removed duplicate tools", removed_count: removed_count, remaining_count: @tools.size)
+        warn "Removed #{removed_count} duplicate tools"
+      else
+        logger.debug("No duplicate tools found")
+      end
     end
 
 
@@ -328,7 +747,7 @@ module AIA
       # Get role content using PromptHandler
       # Need to create PromptHandler instance if not already available
       prompt_handler = AIA::PromptHandler.new
-      role_content = prompt_handler.load_role_for_model(spec, AIA.config.role)
+      role_content = prompt_handler.load_role_for_model(spec, AIA.config.prompts.role)
 
       return prompt unless role_content
 
@@ -409,7 +828,7 @@ module AIA
 
     def should_use_consensus_mode?
       # Only use consensus when explicitly enabled with --consensus flag
-      AIA.config.consensus == true
+      AIA.config.flags.consensus == true
     end
 
     def generate_consensus_response(results)
@@ -464,14 +883,15 @@ module AIA
     end
 
     def format_individual_responses(results)
-      # For metrics support, return a special structure if all results have token info
-      has_metrics = results.values.all? { |r| r.respond_to?(:input_tokens) && r.respond_to?(:output_tokens) }
+      # Always collect metrics if available - display logic in session.rb decides whether to show them
+      # This ensures metrics are passed through even when flags.metrics is false
+      has_metrics = results.values.any? { |r| r.respond_to?(:input_tokens) && r.respond_to?(:output_tokens) }
 
-      if has_metrics && AIA.config.show_metrics
+      if has_metrics
         # Return structured data that preserves metrics for multi-model
         format_multi_model_with_metrics(results)
       else
-        # Original string formatting for non-metrics mode with role labels (ADR-005)
+        # No metrics available - return formatted string
         output = []
         results.each do |internal_id, result|
           # Get model spec to include role in output
@@ -518,16 +938,24 @@ module AIA
       formatted_content = []
       metrics_data = []
 
-      results.each do |model_name, result|
-        formatted_content << "from: #{model_name}"
-        formatted_content << result.content
+      results.each do |internal_id, result|
+        # Get model spec to include role in output
+        spec = get_model_spec(internal_id)
+        display_name = format_model_display_name(spec)
+
+        formatted_content << "from: #{display_name}"
+        content = result.respond_to?(:content) ? result.content : result.to_s
+        formatted_content << content
         formatted_content << ""
 
         # Collect metrics for each model
+        # Use the actual model name (not internal_id) for cost calculation in RubyLLM::Models.find
+        actual_model = spec ? spec[:model] : internal_id
         metrics_data << {
-          model_id: model_name,
-          input_tokens: result.input_tokens,
-          output_tokens: result.output_tokens
+          model_id: actual_model,
+          display_name: display_name,
+          input_tokens: result.respond_to?(:input_tokens) ? result.input_tokens : nil,
+          output_tokens: result.respond_to?(:output_tokens) ? result.output_tokens : nil
         }
       end
 
@@ -566,8 +994,8 @@ module AIA
         # Try using a TTS API if available
         # For now, we'll use a mock implementation
         File.write(output_file, 'Mock TTS audio content')
-        if File.exist?(output_file) && system("which #{AIA.config.speak_command} > /dev/null 2>&1")
-          system("#{AIA.config.speak_command} #{output_file}")
+        if File.exist?(output_file) && system("which #{AIA.config.audio.speak_command} > /dev/null 2>&1")
+          system("#{AIA.config.audio.speak_command} #{output_file}")
         end
         "Audio generated and saved to: #{output_file}"
       rescue StandardError => e
@@ -639,29 +1067,98 @@ module AIA
 
     private
 
+    # Helper to access the AIA logger for application-level logging
+    def logger
+      @logger ||= LoggerManager.aia_logger
+    end
+
     def filter_tools_by_allowed_list
-      return if AIA.config.allowed_tools.nil?
+      allowed = AIA.config.tools.allowed
+      return if allowed.nil? || allowed.empty?
+
+      # allowed_tools is now an array
+      allowed_list = Array(allowed).map(&:strip)
 
       @tools.select! do |tool|
         tool_name = tool.respond_to?(:name) ? tool.name : tool.class.name
-        AIA.config.allowed_tools
-          .split(',')
-          .map(&:strip)
-          .any? { |allowed| tool_name.include?(allowed) }
+        allowed_list.any? { |allowed_pattern| tool_name.include?(allowed_pattern) }
       end
     end
 
 
     def filter_tools_by_rejected_list
-      return if AIA.config.rejected_tools.nil?
+      rejected = AIA.config.tools.rejected
+      return if rejected.nil? || rejected.empty?
+
+      # rejected_tools is now an array
+      rejected_list = Array(rejected).map(&:strip)
 
       @tools.reject! do |tool|
         tool_name = tool.respond_to?(:name) ? tool.name : tool.class.name
-        AIA.config.rejected_tools
-          .split(',')
-          .map(&:strip)
-          .any? { |rejected| tool_name.include?(rejected) }
+        rejected_list.any? { |rejected_pattern| tool_name.include?(rejected_pattern) }
+      end
+    end
+
+
+    # Handles tool execution crashes gracefully
+    # Logs error with short traceback, repairs conversation, and returns error message
+    def handle_tool_crash(chat_instance, exception)
+      error_msg = "Tool error: #{exception.class} - #{exception.message}"
+
+      # Log error with short traceback (first 5 lines)
+      warn "\n⚠️  #{error_msg}"
+      if exception.backtrace
+        short_trace = exception.backtrace.first(5).map { |line| "   #{line}" }.join("\n")
+        warn short_trace
+      end
+      warn "" # blank line for readability
+
+      # Repair incomplete tool calls to maintain conversation integrity
+      repair_incomplete_tool_calls(chat_instance, error_msg)
+
+      # Return error message so conversation can continue
+      error_msg
+    end
+
+
+    # Repairs conversation history when a tool call fails (timeout, error, etc.)
+    # When an MCP tool times out, the conversation gets into an invalid state:
+    # - Assistant message with tool_calls was added to history
+    # - But no tool result message was added (because the tool failed)
+    # - The API requires tool results for each tool_call_id
+    # This method adds synthetic error tool results to fix the conversation.
+    def repair_incomplete_tool_calls(chat_instance, error_message)
+      return unless chat_instance.respond_to?(:messages)
+
+      messages = chat_instance.messages
+      return if messages.empty?
+
+      # Find the last assistant message that has tool_calls
+      last_assistant_with_tools = messages.reverse.find do |msg|
+        msg.role == :assistant && msg.respond_to?(:tool_calls) && msg.tool_calls&.any?
+      end
+
+      return unless last_assistant_with_tools
+
+      # Get the tool_call_ids that need results
+      tool_call_ids = last_assistant_with_tools.tool_calls.keys
+
+      # Check which tool_call_ids already have results
+      existing_tool_results = messages.select { |m| m.role == :tool }.map(&:tool_call_id).compact
+
+      # Add synthetic error results for any missing tool_call_ids
+      tool_call_ids.each do |tool_call_id|
+        next if existing_tool_results.include?(tool_call_id.to_s) || existing_tool_results.include?(tool_call_id)
+
+        # Add a synthetic tool result with the error message
+        chat_instance.add_message(
+          role: :tool,
+          content: "Error: #{error_message}",
+          tool_call_id: tool_call_id
+        )
       end
+    rescue StandardError
+      # Don't let repair failures cascade
     end
 
 
@@ -704,26 +1201,30 @@ module AIA
 
 
     def extract_models_config
-      models_config = AIA.config.model
-
-      # Handle backward compatibility
-      if models_config.is_a?(String)
-        # Old format: single string
-        [{model: models_config, role: nil, instance: 1, internal_id: models_config}]
-      elsif models_config.is_a?(Array)
-        if models_config.empty?
-          # Empty array - use default
-          [{model: 'gpt-4o-mini', role: nil, instance: 1, internal_id: 'gpt-4o-mini'}]
-        elsif models_config.first.is_a?(Hash)
-          # New format: array of hashes with model specs
-          models_config
-        else
-          # Old format: array of strings
-          models_config.map { |m| {model: m, role: nil, instance: 1, internal_id: m} }
-        end
-      else
+      # Use config.models which returns array of ModelSpec objects
+      models_config = AIA.config.models
+
+      if models_config.nil? || models_config.empty?
         # Fallback to default
         [{model: 'gpt-4o-mini', role: nil, instance: 1, internal_id: 'gpt-4o-mini'}]
+      else
+        # Convert ModelSpec objects to hash format expected by adapter
+        models_config.map do |spec|
+          if spec.respond_to?(:name)
+            # ModelSpec object
+            {model: spec.name, role: spec.role, instance: spec.instance, internal_id: spec.internal_id}
+          elsif spec.is_a?(Hash)
+            # Hash format (legacy or from config.model accessor)
+            model_name = spec[:model] || spec[:name]
+            {model: model_name, role: spec[:role], instance: spec[:instance] || 1, internal_id: spec[:internal_id] || model_name}
+          elsif spec.is_a?(String)
+            # String format (legacy)
+            {model: spec, role: nil, instance: 1, internal_id: spec}
+          else
+            # Unknown format, skip
+            nil
+          end
+        end.compact
       end
     end
 
@@ -769,8 +1270,10 @@ module AIA
 
       # Return the full response object to preserve token information
       response
-    rescue StandardError => e
-      e.message
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      # Catch ALL exceptions including LoadError, ScriptError, etc.
+      # Tool crashes should not crash AIA - log and continue gracefully
+      handle_tool_crash(chat_instance, e)
     end
 
 
@@ -792,7 +1295,7 @@ module AIA
       image_name  = extract_image_path(text_prompt)
 
       begin
-        image = RubyLLM.paint(text_prompt, size: AIA.config.image_size)
+        image = RubyLLM.paint(text_prompt, size: AIA.config.image.size)
         if image_name
           image_path = image.save(image_name)
           "Image generated and saved to: #{image_path}"
@@ -837,8 +1340,8 @@ module AIA
         # NOTE: RubyLLM doesn't have a direct TTS feature
         # TODO: This is a placeholder for a custom implementation
         File.write(output_file, text_prompt)
-        if File.exist?(output_file) && system("which #{AIA.config.speak_command} > /dev/null 2>&1")
-          system("#{AIA.config.speak_command} #{output_file}")
+        if File.exist?(output_file) && system("which #{AIA.config.audio.speak_command} > /dev/null 2>&1")
+          system("#{AIA.config.audio.speak_command} #{output_file}")
         end
         "Audio generated and saved to: #{output_file}"
       rescue StandardError => e