aia 1.1.0 → 2.0.0.0.pre.alpha

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,155 @@
+# 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]
+    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]
+    def build_consensus_network(config, namer)
+      run_config = RobotFactory.build_run_config(config)
+      tools = ToolLoader.filtered_tools(config)
+      mcp = RobotFactory.mcp_server_configs(config)
+      primary = config.models.first
+      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-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: config.models.map { |s| s.internal_id.to_sym }
+      end
+    end
+
+    # Shared helper: builds a single roster robot (used by parallel and consensus networks).
+    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]
+    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)
+
+        memory = network.memory
+        memory.data.session_id  = SecureRandom.hex(8)
+        memory.data.model_count = config.models.size
+        memory.data.model_names = config.models.map(&:name)
+        memory.data.mode        = config.flags.consensus ? :consensus : :parallel
+        memory.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

data/lib/aia/patches/ruby_llm_tool_error.rb

@@ -0,0 +1,96 @@
+# lib/aia/patches/ruby_llm_tool_error.rb
+#
+# Two ruby_llm hardening patches:
+#
+#   1. RubyLLM::Chat#execute_tool — rescue any exception raised during tool
+#      execution and return it as an error hash instead of raising. Without
+#      this, an exception inside a tool skips the add_message call in
+#      handle_tool_calls, leaving an orphaned tool_call in the conversation
+#      history with no matching tool_result. Most LLMs reject that state on the
+#      next request, killing the session. ruby_llm's own execute_tool does NOT
+#      rescue tool exceptions, so this is still required as of 1.16.
+#
+#   2. RubyLLM::Provider#complete — normalize OpenAI o-series / gpt-5 params
+#      (max_tokens -> max_completion_tokens) before the request.
+#
+# Both patches are applied via #prepend + super so they preserve ruby_llm's own
+# method body (including its instrumentation) and survive internal changes to
+# that body. They are guarded against drift: if a future ruby_llm renames or
+# removes the target method, the patch is skipped with a loud warning rather
+# than silently installing dead code or breaking every request.
+
+module AIA
+  class OpenAIParameterNormalizer
+    class << self
+      def normalize(params, model, provider)
+        normalized = params.dup
+        return normalized unless uses_completion_tokens_param?(model, provider)
+        return normalized unless normalized.key?(:max_tokens)
+
+        max_tokens = normalized.delete(:max_tokens)
+        normalized[:max_completion_tokens] ||= max_tokens
+        normalized
+      end
+
+      private
+
+      def uses_completion_tokens_param?(model, provider)
+        provider_slug(provider) == 'openai' && model_id(model).match?(/\A(o\d|gpt-5)/i)
+      end
+
+      def provider_slug(provider)
+        provider.respond_to?(:slug) ? provider.slug.to_s : nil
+      end
+
+      def model_id(model)
+        model.respond_to?(:id) ? model.id.to_s : model.to_s
+      end
+    end
+  end
+
+  # Prepended onto RubyLLM::Provider. Uses a pass-through (*args, **kwargs)
+  # signature so any kwargs ruby_llm adds in future are forwarded to super
+  # unchanged; we only rewrite params before delegating.
+  module RubyLLMOpenAIParameters
+    def complete(*, **kwargs, &)
+      kwargs[:params] = AIA::OpenAIParameterNormalizer.normalize(
+        kwargs[:params] || {}, kwargs[:model], self
+      )
+      super
+    end
+  end
+
+  # Prepended onto RubyLLM::Chat. Calls super (ruby_llm's own instrumented
+  # execute_tool) and only adds exception rescue, so tool-call instrumentation
+  # is preserved.
+  module RubyLLMChatToolError
+    private
+
+    def execute_tool(tool_call)
+      super
+    rescue SignalException, SystemExit
+      raise
+    rescue Exception => e # rubocop:disable Lint/RescueException
+      RubyLLM.logger.warn { "Tool #{tool_call.name} raised #{e.class}: #{e.message}" }
+      { error: "#{e.class}: #{e.message}" }
+    end
+  end
+end
+
+# --- Apply patches, guarded against ruby_llm API drift ---
+
+if RubyLLM::Provider.private_method_defined?(:complete) ||
+   RubyLLM::Provider.method_defined?(:complete)
+  RubyLLM::Provider.prepend(AIA::RubyLLMOpenAIParameters)
+else
+  $stderr.puts "WARNING: [AIA] ruby_llm patch skipped: RubyLLM::Provider#complete " \
+               "not found (ruby_llm #{RubyLLM::VERSION}). OpenAI param normalization is off."
+end
+
+if RubyLLM::Chat.private_method_defined?(:execute_tool) ||
+   RubyLLM::Chat.method_defined?(:execute_tool)
+  RubyLLM::Chat.prepend(AIA::RubyLLMChatToolError)
+else
+  $stderr.puts "WARNING: [AIA] ruby_llm patch skipped: RubyLLM::Chat#execute_tool " \
+               "not found (ruby_llm #{RubyLLM::VERSION}). Tool-exception handling is degraded."
+end