aia 0.9.18 → 0.9.20

data/lib/aia/config/file_loader.rb

@@ -79,10 +79,42 @@ module AIA
 
         def apply_file_config_to_struct(config, file_config)
           file_config.each do |key, value|
-            config[key] = value
+            # Special handling for model array with roles (ADR-005 v2)
+            if (key == :model || key == 'model') && value.is_a?(Array) && value.first.is_a?(Hash)
+              config[:model] = process_model_array_with_roles(value)
+            else
+              config[key] = value
+            end
           end
         end
 
+        # Process model array with roles from config file (ADR-005 v2)
+        # Format: [{model: "gpt-4o", role: "architect"}, ...]
+        # Also supports models without roles: [{model: "gpt-4o"}, ...]
+        def process_model_array_with_roles(models_array)
+          return [] if models_array.nil? || models_array.empty?
+
+          model_specs = []
+          model_counts = Hash.new(0)
+
+          models_array.each do |spec|
+            model_name = spec[:model] || spec['model']
+            role_name = spec[:role] || spec['role']
+
+            model_counts[model_name] += 1
+            instance = model_counts[model_name]
+
+            model_specs << {
+              model: model_name,
+              role: role_name,
+              instance: instance,
+              internal_id: instance > 1 ? "#{model_name}##{instance}" : model_name
+            }
+          end
+
+          model_specs
+        end
+
         def normalize_last_refresh_date(config)
           return unless config.last_refresh&.is_a?(String)
 

data/lib/aia/prompt_handler.rb

@@ -101,7 +101,7 @@ module AIA
     def fetch_role(role_id)
       # Handle nil role_id
       return handle_missing_role("roles/") if role_id.nil?
-      
+
       # Prepend roles_prefix if not already present
       unless role_id.start_with?(AIA.config.roles_prefix)
         role_id = "#{AIA.config.roles_prefix}/#{role_id}"
@@ -126,6 +126,27 @@ module AIA
       handle_missing_role(role_id)
     end
 
+    # Load role for a specific model (ADR-005)
+    # Takes a model spec hash and default role, returns role text
+    def load_role_for_model(model_spec, default_role = nil)
+      # Determine which role to use
+      role_id = if model_spec.is_a?(Hash)
+                  model_spec[:role] || default_role
+                else
+                  # Backward compatibility: if model_spec is a string, use default role
+                  default_role
+                end
+
+      return nil if role_id.nil? || role_id.empty?
+
+      # Load the role using existing fetch_role method
+      role_prompt = fetch_role(role_id)
+      role_prompt.text
+    rescue => e
+      puts "Warning: Could not load role '#{role_id}' for model: #{e.message}"
+      nil
+    end
+
     def handle_missing_role(role_id)
       # Handle empty/nil role_id
       role_id = role_id.to_s.strip

data/lib/aia/ruby_llm_adapter.rb

@@ -5,11 +5,13 @@ require_relative '../extensions/ruby_llm/provider_fix'
 
 module AIA
   class RubyLLMAdapter
-    attr_reader :tools
+    attr_reader :tools, :model_specs
 
     def initialize
-      @models = extract_models_config
+      @model_specs = extract_models_config  # Full specs with role info
+      @models = extract_model_names(@model_specs)  # Just model names for backward compat
       @chats = {}
+      @contexts = {} # Store isolated contexts for each model
 
       configure_rubyllm
       refresh_local_model_registry
@@ -80,44 +82,72 @@ module AIA
     end
 
 
+    # Create an isolated RubyLLM::Context for a model to prevent cross-talk (ADR-002)
+    # Each model gets its own context with provider-specific configuration
+    def create_isolated_context_for_model(model_name)
+      config = RubyLLM.config.dup
+
+      # Apply provider-specific configuration
+      if model_name.start_with?('lms/')
+        config.openai_api_base = ENV.fetch('LMS_API_BASE', 'http://localhost:1234/v1')
+        config.openai_api_key = 'dummy' # Local servers don't need a real API key
+      elsif model_name.start_with?('osaurus/')
+        config.openai_api_base = ENV.fetch('OSAURUS_API_BASE', 'http://localhost:11434/v1')
+        config.openai_api_key = 'dummy' # Local servers don't need a real API key
+      end
+
+      RubyLLM::Context.new(config)
+    end
+
+
+    # Extract the actual model name and provider from the prefixed model_name
+    # Returns: [actual_model, provider] where provider may be nil for auto-detection
+    def extract_model_and_provider(model_name)
+      if model_name.start_with?('ollama/')
+        [model_name.sub('ollama/', ''), 'ollama']
+      elsif model_name.start_with?('lms/') || model_name.start_with?('osaurus/')
+        [model_name.sub(%r{^(lms|osaurus)/}, ''), 'openai']
+      else
+        [model_name, nil] # Let RubyLLM auto-detect provider
+      end
+    end
+
+
     def setup_chats_with_tools
       valid_chats = {}
+      valid_contexts = {}
+      valid_specs = []
       failed_models = []
 
-      @models.each do |model_name|
+      @model_specs.each do |spec|
+        model_name = spec[:model]          # Actual model name (e.g., "gpt-4o")
+        internal_id = spec[:internal_id]   # Key for storage (e.g., "gpt-4o#1", "gpt-4o#2")
+
         begin
-          # Check if this is a local provider model and handle it specially
-          if model_name.start_with?('ollama/')
-            # For Ollama models, extract the actual model name and use assume_model_exists
-            actual_model = model_name.sub('ollama/', '')
-            chat = RubyLLM.chat(model: actual_model, provider: 'ollama', assume_model_exists: true)
-          elsif model_name.start_with?('osaurus/')
-            # For Osaurus models (OpenAI-compatible), create a custom context with the right API base
-            actual_model = model_name.sub('osaurus/', '')
-            custom_config = RubyLLM.config.dup
-            custom_config.openai_api_base = ENV.fetch('OSAURUS_API_BASE', 'http://localhost:11434/v1')
-            custom_config.openai_api_key = 'dummy' # Local servers don't need a real API key
-            context = RubyLLM::Context.new(custom_config)
-            chat = context.chat(model: actual_model, provider: 'openai', assume_model_exists: true)
-          elsif model_name.start_with?('lms/')
-            # For LM Studio models (OpenAI-compatible), create a custom context with the right API base
-            actual_model = model_name.sub('lms/', '')
-            lms_api_base = ENV.fetch('LMS_API_BASE', 'http://localhost:1234/v1')
+          # Create isolated context for this model to prevent cross-talk (ADR-002)
+          context = create_isolated_context_for_model(model_name)
 
-            # Validate model exists in LM Studio
-            validate_lms_model!(actual_model, lms_api_base)
+          # Determine provider and actual model name
+          actual_model, provider = extract_model_and_provider(model_name)
 
-            custom_config = RubyLLM.config.dup
-            custom_config.openai_api_base = lms_api_base
-            custom_config.openai_api_key = 'dummy' # Local servers don't need a real API key
-            context = RubyLLM::Context.new(custom_config)
-            chat = context.chat(model: actual_model, provider: 'openai', assume_model_exists: true)
-          else
-            chat = RubyLLM.chat(model: model_name)
+          # Validate LM Studio models
+          if model_name.start_with?('lms/')
+            lms_api_base = ENV.fetch('LMS_API_BASE', 'http://localhost:1234/v1')
+            validate_lms_model!(actual_model, lms_api_base)
           end
-          valid_chats[model_name] = chat
+
+          # Create chat using isolated context
+          chat = if provider
+                   context.chat(model: actual_model, provider: provider, assume_model_exists: true)
+                 else
+                   context.chat(model: actual_model)
+                 end
+
+          valid_chats[internal_id] = chat
+          valid_contexts[internal_id] = context
+          valid_specs << spec
         rescue StandardError => e
-          failed_models << "#{model_name}: #{e.message}"
+          failed_models << "#{internal_id}: #{e.message}"
         end
       end
 
@@ -135,10 +165,12 @@ module AIA
       end
 
       @chats = valid_chats
+      @contexts = valid_contexts
+      @model_specs = valid_specs
       @models = valid_chats.keys
 
-      # Update the config to reflect only the valid models
-      AIA.config.model = @models
+      # Update the config to reflect only the valid models (keep as specs)
+      AIA.config.model = @model_specs
 
       # Report successful models
       if failed_models.any?
@@ -254,40 +286,96 @@ module AIA
       result
     end
 
-    def single_model_chat(prompt, model_name)
-      chat_instance = @chats[model_name]
+    def single_model_chat(prompt, internal_id)
+      chat_instance = @chats[internal_id]
       modes = chat_instance.model.modalities
 
       # TODO: Need to consider how to handle multi-mode models
       result = if modes.text_to_text?
-        text_to_text_single(prompt, model_name)
+        text_to_text_single(prompt, internal_id)
       elsif modes.image_to_text?
-        image_to_text_single(prompt, model_name)
+        image_to_text_single(prompt, internal_id)
       elsif modes.text_to_image?
-        text_to_image_single(prompt, model_name)
+        text_to_image_single(prompt, internal_id)
       elsif modes.text_to_audio?
-        text_to_audio_single(prompt, model_name)
+        text_to_audio_single(prompt, internal_id)
       elsif modes.audio_to_text?
-        audio_to_text_single(prompt, model_name)
+        audio_to_text_single(prompt, internal_id)
       else
         # TODO: what else can be done?
-        "Error: No matching modality for model #{model_name}"
+        "Error: No matching modality for model #{internal_id}"
       end
 
       result
     end
 
-    def multi_model_chat(prompt)
+    # Prepend role content to prompt for a specific model (ADR-005)
+    def prepend_model_role(prompt, internal_id)
+      # Get model spec to find role
+      spec = get_model_spec(internal_id)
+      return prompt unless spec && spec[:role]
+
+      # 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)
+
+      return prompt unless role_content
+
+      # Prepend role to prompt based on prompt type
+      if prompt.is_a?(String)
+        # Simple string prompt
+        "#{role_content}\n\n#{prompt}"
+      elsif prompt.is_a?(Array)
+        # Conversation array - prepend to first user message
+        prepend_role_to_conversation(prompt, role_content)
+      else
+        prompt
+      end
+    end
+
+    def prepend_role_to_conversation(conversation, role_content)
+      # Find the first user message and prepend role
+      modified = conversation.dup
+      first_user_index = modified.find_index { |msg| msg[:role] == "user" || msg["role"] == "user" }
+
+      if first_user_index
+        msg = modified[first_user_index].dup
+        role_key = msg.key?(:role) ? :role : "role"
+        content_key = msg.key?(:content) ? :content : "content"
+
+        msg[content_key] = "#{role_content}\n\n#{msg[content_key]}"
+        modified[first_user_index] = msg
+      end
+
+      modified
+    end
+
+    def multi_model_chat(prompt_or_contexts)
       results = {}
 
+      # Check if we're receiving per-model contexts (Hash) or shared prompt (String/Array) - ADR-002 revised
+      per_model_contexts = prompt_or_contexts.is_a?(Hash) &&
+                           prompt_or_contexts.keys.all? { |k| @models.include?(k) }
+
       Async do |task|
-        @models.each do |model_name|
+        @models.each do |internal_id|
           task.async do
             begin
-              result = single_model_chat(prompt, model_name)
-              results[model_name] = result
+              # Use model-specific context if available, otherwise shared prompt
+              prompt = if per_model_contexts
+                         prompt_or_contexts[internal_id]
+                       else
+                         prompt_or_contexts
+                       end
+
+              # Add per-model role if specified (ADR-005)
+              prompt = prepend_model_role(prompt, internal_id)
+
+              result = single_model_chat(prompt, internal_id)
+              results[internal_id] = result
             rescue StandardError => e
-              results[model_name] = "Error with #{model_name}: #{e.message}"
+              results[internal_id] = "Error with #{internal_id}: #{e.message}"
             end
           end
         end
@@ -319,14 +407,17 @@ module AIA
       primary_chat = @chats[primary_model]
 
       # Build the consensus prompt with all model responses
+      # Note: This prompt does NOT include the model's role (ADR-005)
+      # The primary model synthesizes neutrally without role bias
       consensus_prompt = build_consensus_prompt(results)
 
       begin
         # Have the primary model generate the consensus
+        # The consensus prompt is already role-neutral
         consensus_result = primary_chat.ask(consensus_prompt).content
 
-        # Format the consensus response
-        "from: #{primary_model} (consensus)\n#{consensus_result}"
+        # Format the consensus response - no role label for consensus
+        "from: #{primary_model}\n#{consensus_result}"
       rescue StandardError => e
         # If consensus fails, fall back to individual responses
         "Error generating consensus: #{e.message}\n\n" + format_individual_responses(results)
@@ -370,10 +461,14 @@ module AIA
         # Return structured data that preserves metrics for multi-model
         format_multi_model_with_metrics(results)
       else
-        # Original string formatting for non-metrics mode
+        # Original string formatting for non-metrics mode with role labels (ADR-005)
         output = []
-        results.each do |model_name, result|
-          output << "from: #{model_name}"
+        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)
+
+          output << "from: #{display_name}"
           # Extract content from RubyLLM::Message if needed
           content = if result.respond_to?(:content)
                       result.content
@@ -387,6 +482,27 @@ module AIA
       end
     end
 
+    # Format display name with instance number and role (ADR-005)
+    def format_model_display_name(spec)
+      return spec unless spec.is_a?(Hash)
+
+      model_name = spec[:model]
+      instance = spec[:instance]
+      role = spec[:role]
+
+      # Add instance number if > 1
+      display = if instance > 1
+                  "#{model_name} ##{instance}"
+                else
+                  model_name
+                end
+
+      # Add role label if present
+      display += " (#{role})" if role
+
+      display
+    end
+
     def format_multi_model_with_metrics(results)
       # Create a composite response that includes all model responses and metrics
       formatted_content = []
@@ -452,96 +568,46 @@ module AIA
 
     # Clear the chat context/history
     # Needed for the //clear and //restore directives
+    # Simplified with ADR-002: Each model has isolated context, no global state to manage
     def clear_context
-      @chats.each do |model_name, chat|
-        # Option 1: Directly clear the messages array in the current chat object
-        if chat.instance_variable_defined?(:@messages)
-          chat.instance_variable_get(:@messages)
-          # Force a completely empty array, not just attempting to clear it
-          chat.instance_variable_set(:@messages, [])
-        end
-      end
-
-      # Option 2: Force RubyLLM to create a new chat instance at the global level
-      # This ensures any shared state is reset
-      RubyLLM.instance_variable_set(:@chat, nil) if RubyLLM.instance_variable_defined?(:@chat)
+      old_chats = @chats.dup
+      new_chats = {}
 
-      # Option 3: Try to create fresh chat instances, but don't exit on failure
-      # This is safer for use in directives like //restore
-      old_chats = @chats
-      @chats = {} # First clear the chats hash
+      @models.each do |model_name|
+        begin
+          # Get the isolated context for this model
+          context = @contexts[model_name]
+          actual_model, provider = extract_model_and_provider(model_name)
 
-      begin
-        @models.each do |model_name|
-          # Try to recreate each chat, but if it fails, keep the old one
-          begin
-            # Check if this is a local provider model and handle it specially
-            if model_name.start_with?('ollama/')
-              actual_model = model_name.sub('ollama/', '')
-              @chats[model_name] = RubyLLM.chat(model: actual_model, provider: 'ollama', assume_model_exists: true)
-            elsif model_name.start_with?('osaurus/')
-              actual_model = model_name.sub('osaurus/', '')
-              custom_config = RubyLLM.config.dup
-              custom_config.openai_api_base = ENV.fetch('OSAURUS_API_BASE', 'http://localhost:11434/v1')
-              custom_config.openai_api_key = 'dummy'
-              context = RubyLLM::Context.new(custom_config)
-              @chats[model_name] = context.chat(model: actual_model, provider: 'openai', assume_model_exists: true)
-            elsif model_name.start_with?('lms/')
-              actual_model = model_name.sub('lms/', '')
-              lms_api_base = ENV.fetch('LMS_API_BASE', 'http://localhost:1234/v1')
-
-              # Validate model exists in LM Studio
-              validate_lms_model!(actual_model, lms_api_base)
-
-              custom_config = RubyLLM.config.dup
-              custom_config.openai_api_base = lms_api_base
-              custom_config.openai_api_key = 'dummy'
-              context = RubyLLM::Context.new(custom_config)
-              @chats[model_name] = context.chat(model: actual_model, provider: 'openai', assume_model_exists: true)
-            else
-              @chats[model_name] = RubyLLM.chat(model: model_name)
-            end
+          # Create a fresh chat instance from the same isolated context
+          chat = if provider
+                   context.chat(model: actual_model, provider: provider, assume_model_exists: true)
+                 else
+                   context.chat(model: actual_model)
+                 end
 
-            # Re-add tools if they were previously loaded
-            if @tools && !@tools.empty? && @chats[model_name].model&.supports_functions?
-              @chats[model_name].with_tools(*@tools)
-            end
-          rescue StandardError => e
-            # If we can't create a new chat, keep the old one but clear its context
-            warn "Warning: Could not recreate chat for #{model_name}: #{e.message}. Keeping existing instance."
-            @chats[model_name] = old_chats[model_name]
-            # Clear the old chat's messages if possible
-            if @chats[model_name] && @chats[model_name].instance_variable_defined?(:@messages)
-              @chats[model_name].instance_variable_set(:@messages, [])
-            end
+          # Re-add tools if they were previously loaded
+          if @tools && !@tools.empty? && chat.model&.supports_functions?
+            chat.with_tools(*@tools)
           end
-        end
-      rescue StandardError => e
-        # If something went terribly wrong, restore the old chats but clear their contexts
-        warn "Warning: Error during context clearing: #{e.message}. Attempting to recover."
-        @chats = old_chats
-        @chats.each_value do |chat|
-          if chat.instance_variable_defined?(:@messages)
+
+          new_chats[model_name] = chat
+        rescue StandardError => e
+          # If recreation fails, keep the old chat but clear its messages
+          warn "Warning: Could not recreate chat for #{model_name}: #{e.message}. Clearing existing chat."
+          chat = old_chats[model_name]
+          if chat&.instance_variable_defined?(:@messages)
             chat.instance_variable_set(:@messages, [])
           end
+          chat.clear_history if chat&.respond_to?(:clear_history)
+          new_chats[model_name] = chat
         end
       end
 
-      # Option 4: Call official clear_history method if it exists
-      @chats.each_value do |chat|
-        chat.clear_history if chat.respond_to?(:clear_history)
-      end
-
-      # Final verification
-      @chats.each_value do |chat|
-        if chat.instance_variable_defined?(:@messages) && !chat.instance_variable_get(:@messages).empty?
-          chat.instance_variable_set(:@messages, [])
-        end
-      end
-
-      return 'Chat context successfully cleared.'
+      @chats = new_chats
+      'Chat context successfully cleared.'
     rescue StandardError => e
-      return "Error clearing chat context: #{e.message}"
+      "Error clearing chat context: #{e.message}"
     end
 
 
@@ -624,16 +690,40 @@ module AIA
     def extract_models_config
       models_config = AIA.config.model
 
-      # Handle backward compatibility - if it's a string, convert to array
+      # Handle backward compatibility
       if models_config.is_a?(String)
-        [models_config]
+        # Old format: single string
+        [{model: models_config, role: nil, instance: 1, internal_id: models_config}]
       elsif models_config.is_a?(Array)
-        models_config
+        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
-        ['gpt-4o-mini'] # fallback to default
+        # Fallback to default
+        [{model: 'gpt-4o-mini', role: nil, instance: 1, internal_id: 'gpt-4o-mini'}]
       end
     end
 
+    def extract_model_names(model_specs)
+      # Extract just the model names from the specs
+      # For models with instance > 1, use internal_id (e.g., "gpt-4o#2")
+      model_specs.map do |spec|
+        spec[:internal_id]
+      end
+    end
+
+    def get_model_spec(internal_id)
+      # Find the spec for a given internal_id
+      @model_specs.find { |spec| spec[:internal_id] == internal_id }
+    end
+
 
     def extract_text_prompt(prompt)
       if prompt.is_a?(String)