aia 0.9.17 → 0.9.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae5c7e9497837763b36226f8fc44aeb7dffe692c964e450938ff83aea043c10a
-  data.tar.gz: b839a219cb3f6e5b34d9aa02ff7f3ced77ff039816b6b2a3d9ef79076d32c302
+  metadata.gz: 8fb298b4e9a1ddc4748425decde69e1c11d8e7eb195cf264b918c4d69bf64e01
+  data.tar.gz: a0cffea9fec68a81fbe5e5d36fed20255e33c1d230ec0dd518e08ad7adc56afa
 SHA512:
-  metadata.gz: 7df6fe4bbf0fd2ce33b9827390340d3cf1f8fd5ad5b4f52ceb343769dee6d699ab87c5dd2686472cd480bf5ac1e20b612f5c69e70b72eab68735560601423d7c
-  data.tar.gz: 9fa99822319f6e3ff213f62ba0c26121c045e4fa96035596df46b4d723df72cecb19c1abb98f760e6b435941a3cc9b869f6401da771452c3d226930b4f4ea104
+  metadata.gz: 6076117839c543fda6756e6657f69d9c35fb561213697e464701eb1515a1d38cff130e7cc57159bf44a8586387144257887906e2ffc63cf183886e816cfd6b84
+  data.tar.gz: 42a6d282bcf587edf84e0db8d13998e0f233f9a66f52977cbaa2d0c152d44e7691207a48a8bec68800e18b1abe81bd2964d841c29eca7437a69f91a2febfd67b

data/.version

@@ -1 +1 @@
-0.9.17
+0.9.19

data/CHANGELOG.md

@@ -1,6 +1,88 @@
 # Changelog
 ## [Unreleased]
 
+### [0.9.19] 2025-10-06
+
+#### Bug Fixes
+- **CRITICAL BUG FIX**: Fixed multi-model cross-talk issue (#118) where models could see each other's conversation history
+- **BUG FIX**: Implemented complete two-level context isolation to prevent models from contaminating each other's responses
+- **BUG FIX**: Fixed token count inflation caused by models processing combined conversation histories
+
+#### Technical Changes
+- **Level 1 (Library)**: Implemented per-model RubyLLM::Context isolation - each model now has its own Context instance (lib/aia/ruby_llm_adapter.rb)
+- **Level 2 (Application)**: Implemented per-model ContextManager isolation - each model maintains its own conversation history (lib/aia/session.rb)
+- Added `parse_multi_model_response` method to extract individual model responses from combined output (lib/aia/session.rb:502-533)
+- Enhanced `multi_model_chat` to accept Hash of per-model conversations (lib/aia/ruby_llm_adapter.rb:305-334)
+- Updated ChatProcessorService to handle both Array (single model) and Hash (multi-model with per-model contexts) inputs (lib/aia/chat_processor_service.rb:68-83)
+- Refactored RubyLLMAdapter:
+  - Added `@contexts` hash to store per-model Context instances
+  - Added `create_isolated_context_for_model` helper method (lines 84-99)
+  - Added `extract_model_and_provider` helper method (lines 102-112)
+  - Simplified `clear_context` from 92 lines to 40 lines (56% reduction)
+- Updated directive handlers to work with per-model context managers
+- Added comprehensive test coverage with 6 new tests for multi-model isolation
+- Updated LocalProvidersTest to reflect Context-based architecture
+
+#### Architecture
+- **ADR-002-revised**: Complete Multi-Model Isolation (see `.architecture/decisions/adrs/ADR-002-revised-multi-model-isolation.md`)
+- Eliminated global state dependencies in multi-model chat sessions
+- Maintained backward compatibility with single-model mode (verified with tests)
+
+#### Test Coverage
+- Added `test/aia/multi_model_isolation_test.rb` with comprehensive isolation tests
+- Tests cover: response parsing, per-model context managers, single-model compatibility, RubyLLM::Context isolation
+- Full test suite: 282 runs, 837 assertions, 0 failures, 0 errors, 13 skips ✅
+
+#### Expected Behavior After Fix
+Previously, when running multi-model chat with repeated prompts:
+- ❌ Models would see BOTH their own AND other models' responses
+- ❌ Models would report inflated counts (e.g., "5 times", "6 times" instead of "3 times")
+- ❌ Token counts would be inflated due to contaminated context
+
+Now with the fix:
+- ✅ Each model sees ONLY its own conversation history
+- ✅ Each model correctly reports its own interaction count
+- ✅ Token counts accurately reflect per-model conversation size
+
+#### Usage Examples
+```bash
+# Multi-model chat now properly isolates each model's context
+bin/aia --chat --model lms/openai/gpt-oss-20b,ollama/gpt-oss:20b --metrics
+
+> pick a random language and say hello
+# LMS: "Habari!" (Swahili)
+# Ollama: "Kaixo!" (Basque)
+
+> do it again
+# LMS: "Habari!" (only sees its own previous response)
+# Ollama: "Kaixo!" (only sees its own previous response)
+
+> do it again
+> how many times did you say hello to me?
+
+# Both models correctly respond: "3 times"
+# (Previously: LMS would say "5 times", Ollama "6 times" due to cross-talk)
+```
+
+### [0.9.18] 2025-10-05
+
+#### Bug Fixes
+- **BUG FIX**: Fixed RubyLLM provider error parsing to handle both OpenAI and LM Studio error formats
+- **BUG FIX**: Fixed "String does not have #dig method" errors when parsing error responses from local providers
+- **BUG FIX**: Enhanced error parsing to gracefully handle malformed JSON responses
+
+#### Improvements
+- **ENHANCEMENT**: Removed debug output statements from RubyLLMAdapter for cleaner production logs
+- **ENHANCEMENT**: Improved error handling with debug logging for JSON parsing failures
+
+#### Documentation
+- **DOCUMENTATION**: Added Local Models entry to MkDocs navigation for better documentation accessibility
+
+#### Technical Changes
+- Enhanced provider_fix extension to support multiple error response formats (lib/extensions/ruby_llm/provider_fix.rb)
+- Cleaned up debug puts statements from RubyLLMAdapter and provider_fix
+- Added robust JSON parsing with fallback error handling
+
 ### [0.9.17] 2025-10-04
 
 #### New Features

data/lib/aia/chat_processor_service.rb

@@ -63,13 +63,22 @@ module AIA
     end
 
 
-    # conversation is an Array of Hashes.  Each entry is an interchange
-    # with the LLM.
-    def send_to_client(conversation)
+    # conversation is an Array of Hashes (single model) or Hash of Arrays (multi-model per-model contexts)
+    # Each entry is an interchange with the LLM.
+    def send_to_client(conversation_or_conversations)
       maybe_change_model
 
-      puts "[DEBUG ChatProcessor] Sending conversation to client: #{conversation.inspect[0..500]}..." if AIA.config.debug
-      result = AIA.client.chat(conversation)
+      # Handle per-model conversations (Hash) or single conversation (Array) - ADR-002 revised
+      if conversation_or_conversations.is_a?(Hash)
+        # Multi-model with per-model contexts: pass Hash directly to adapter
+        puts "[DEBUG ChatProcessor] Sending per-model conversations to client" if AIA.config.debug
+        result = AIA.client.chat(conversation_or_conversations)
+      else
+        # Single conversation for single model
+        puts "[DEBUG ChatProcessor] Sending conversation to client: #{conversation_or_conversations.inspect[0..500]}..." if AIA.config.debug
+        result = AIA.client.chat(conversation_or_conversations)
+      end
+
       puts "[DEBUG ChatProcessor] Client returned: #{result.class} - #{result.inspect[0..500]}..." if AIA.config.debug
       result
     end

data/lib/aia/ruby_llm_adapter.rb

@@ -10,6 +10,7 @@ module AIA
     def initialize
       @models = extract_models_config
       @chats = {}
+      @contexts = {} # Store isolated contexts for each model
 
       configure_rubyllm
       refresh_local_model_registry
@@ -80,42 +81,65 @@ 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 = {}
       failed_models = []
 
       @models.each do |model_name|
         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
+
+          # 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[model_name] = chat
+          valid_contexts[model_name] = context
         rescue StandardError => e
           failed_models << "#{model_name}: #{e.message}"
         end
@@ -135,6 +159,7 @@ module AIA
       end
 
       @chats = valid_chats
+      @contexts = valid_contexts
       @models = valid_chats.keys
 
       # Update the config to reflect only the valid models
@@ -243,10 +268,6 @@ module AIA
 
 
     def chat(prompt)
-      puts "[DEBUG RubyLLMAdapter.chat] Received prompt class: #{prompt.class}" if AIA.config.debug
-      puts "[DEBUG RubyLLMAdapter.chat] Prompt inspect: #{prompt.inspect[0..500]}..." if AIA.config.debug
-      puts "[DEBUG RubyLLMAdapter.chat] Models: #{@models.inspect}" if AIA.config.debug
-
       result = if @models.size == 1
         # Single model - use the original behavior
         single_model_chat(prompt, @models.first)
@@ -255,52 +276,50 @@ module AIA
         multi_model_chat(prompt)
       end
 
-      puts "[DEBUG RubyLLMAdapter.chat] Returning result class: #{result.class}" if AIA.config.debug
-      puts "[DEBUG RubyLLMAdapter.chat] Result inspect: #{result.inspect[0..500]}..." if AIA.config.debug
       result
     end
 
     def single_model_chat(prompt, model_name)
-      puts "[DEBUG single_model_chat] Model name: #{model_name}" if AIA.config.debug
       chat_instance = @chats[model_name]
-      puts "[DEBUG single_model_chat] Chat instance: #{chat_instance.class}" if AIA.config.debug
-
       modes = chat_instance.model.modalities
-      puts "[DEBUG single_model_chat] Modalities: #{modes.inspect}" if AIA.config.debug
 
       # TODO: Need to consider how to handle multi-mode models
       result = if modes.text_to_text?
-        puts "[DEBUG single_model_chat] Using text_to_text_single" if AIA.config.debug
         text_to_text_single(prompt, model_name)
       elsif modes.image_to_text?
-        puts "[DEBUG single_model_chat] Using image_to_text_single" if AIA.config.debug
         image_to_text_single(prompt, model_name)
       elsif modes.text_to_image?
-        puts "[DEBUG single_model_chat] Using text_to_image_single" if AIA.config.debug
         text_to_image_single(prompt, model_name)
       elsif modes.text_to_audio?
-        puts "[DEBUG single_model_chat] Using text_to_audio_single" if AIA.config.debug
         text_to_audio_single(prompt, model_name)
       elsif modes.audio_to_text?
-        puts "[DEBUG single_model_chat] Using audio_to_text_single" if AIA.config.debug
         audio_to_text_single(prompt, model_name)
       else
-        puts "[DEBUG single_model_chat] No matching modality!" if AIA.config.debug
         # TODO: what else can be done?
         "Error: No matching modality for model #{model_name}"
       end
 
-      puts "[DEBUG single_model_chat] Result class: #{result.class}" if AIA.config.debug
       result
     end
 
-    def multi_model_chat(prompt)
+    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|
           task.async do
             begin
+              # Use model-specific context if available, otherwise shared prompt
+              prompt = if per_model_contexts
+                         prompt_or_contexts[model_name]
+                       else
+                         prompt_or_contexts
+                       end
+
               result = single_model_chat(prompt, model_name)
               results[model_name] = result
             rescue StandardError => e
@@ -469,96 +488,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
+      old_chats = @chats.dup
+      new_chats = {}
 
-      # 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)
-
-      # 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
 
 
@@ -672,29 +641,15 @@ module AIA
       chat_instance = @chats[model_name]
       text_prompt = extract_text_prompt(prompt)
 
-      puts "[DEBUG RubyLLMAdapter] Sending to model #{model_name}: #{text_prompt[0..100]}..." if AIA.config.debug
-
       response = if AIA.config.context_files.empty?
                    chat_instance.ask(text_prompt)
                  else
                    chat_instance.ask(text_prompt, with: AIA.config.context_files)
                  end
 
-      # Debug output to understand the response structure
-      puts "[DEBUG RubyLLMAdapter] Response class: #{response.class}" if AIA.config.debug
-      puts "[DEBUG RubyLLMAdapter] Response inspect: #{response.inspect[0..500]}..." if AIA.config.debug
-
-      if response.respond_to?(:content)
-        puts "[DEBUG RubyLLMAdapter] Response content: #{response.content[0..200]}..." if AIA.config.debug
-      else
-        puts "[DEBUG RubyLLMAdapter] Response (no content method): #{response.to_s[0..200]}..." if AIA.config.debug
-      end
-
       # Return the full response object to preserve token information
       response
     rescue StandardError => e
-      puts "[DEBUG RubyLLMAdapter] Error in text_to_text_single: #{e.class} - #{e.message}" if AIA.config.debug
-      puts "[DEBUG RubyLLMAdapter] Backtrace: #{e.backtrace[0..5].join("\n")}" if AIA.config.debug
       e.message
     end
 

data/lib/aia/session.rb

@@ -45,7 +45,21 @@ module AIA
     end
 
     def initialize_components
-      @context_manager = ContextManager.new(system_prompt: AIA.config.system_prompt)
+      # For multi-model: create separate context manager per model (ADR-002 revised)
+      # For single-model: maintain backward compatibility with single context manager
+      if AIA.config.model.is_a?(Array) && AIA.config.model.size > 1
+        @context_managers = {}
+        AIA.config.model.each do |model_name|
+          @context_managers[model_name] = ContextManager.new(
+            system_prompt: AIA.config.system_prompt
+          )
+        end
+        @context_manager = nil # Signal we're using per-model managers
+      else
+        @context_manager = ContextManager.new(system_prompt: AIA.config.system_prompt)
+        @context_managers = nil
+      end
+
       @ui_presenter = UIPresenter.new
       @directive_processor = DirectiveProcessor.new
       @chat_processor = ChatProcessorService.new(@ui_presenter, @directive_processor)
@@ -368,11 +382,29 @@ module AIA
         @chat_prompt.text = follow_up_prompt
         processed_prompt = @chat_prompt.to_s
 
-        @context_manager.add_to_context(role: "user", content: processed_prompt)
-        conversation = @context_manager.get_context
+        # Handle per-model contexts (ADR-002 revised)
+        if @context_managers
+          # Multi-model: add user prompt to each model's context
+          @context_managers.each_value do |ctx_mgr|
+            ctx_mgr.add_to_context(role: "user", content: processed_prompt)
+          end
 
-        @ui_presenter.display_thinking_animation
-        response_data = @chat_processor.process_prompt(conversation)
+          # Get per-model conversations
+          conversations = {}
+          @context_managers.each do |model_name, ctx_mgr|
+            conversations[model_name] = ctx_mgr.get_context
+          end
+
+          @ui_presenter.display_thinking_animation
+          response_data = @chat_processor.process_prompt(conversations)
+        else
+          # Single-model: use original logic
+          @context_manager.add_to_context(role: "user", content: processed_prompt)
+          conversation = @context_manager.get_context
+
+          @ui_presenter.display_thinking_animation
+          response_data = @chat_processor.process_prompt(conversation)
+        end
 
         # Handle new response format with metrics
         if response_data.is_a?(Hash)
@@ -386,7 +418,7 @@ module AIA
         end
 
         @ui_presenter.display_ai_response(content)
-        
+
         # Display metrics if enabled and available (chat mode only)
         if AIA.config.show_metrics
           if multi_metrics
@@ -397,8 +429,22 @@ module AIA
             @ui_presenter.display_token_metrics(metrics)
           end
         end
-        
-        @context_manager.add_to_context(role: "assistant", content: content)
+
+        # Add responses to context (ADR-002 revised)
+        if @context_managers
+          # Multi-model: parse combined response and add each model's response to its own context
+          parsed_responses = parse_multi_model_response(content)
+          parsed_responses.each do |model_name, model_response|
+            @context_managers[model_name]&.add_to_context(
+              role: "assistant",
+              content: model_response
+            )
+          end
+        else
+          # Single-model: add response to single context
+          @context_manager.add_to_context(role: "assistant", content: content)
+        end
+
         @chat_processor.speak(content)
 
         @ui_presenter.display_separator
@@ -406,7 +452,10 @@ module AIA
     end
 
     def process_chat_directive(follow_up_prompt)
-      directive_output = @directive_processor.process(follow_up_prompt, @context_manager)
+      # For multi-model, use first context manager for directives (ADR-002 revised)
+      # TODO: Consider if directives should affect all contexts or just one
+      context_for_directive = @context_managers ? @context_managers.values.first : @context_manager
+      directive_output = @directive_processor.process(follow_up_prompt, context_for_directive)
 
       return handle_clear_directive if follow_up_prompt.strip.start_with?("//clear")
       return handle_checkpoint_directive(directive_output) if follow_up_prompt.strip.start_with?("//checkpoint")
@@ -417,13 +466,16 @@ module AIA
     end
 
     def handle_clear_directive
-      # The directive processor has called context_manager.clear_context
-      # but we need to also clear the LLM client's context
-
-      # First, clear the context manager's context
-      @context_manager.clear_context(keep_system_prompt: true)
+      # Clear context manager(s) - ADR-002 revised
+      if @context_managers
+        # Multi-model: clear all context managers
+        @context_managers.each_value { |ctx_mgr| ctx_mgr.clear_context(keep_system_prompt: true) }
+      else
+        # Single-model: clear single context manager
+        @context_manager.clear_context(keep_system_prompt: true)
+      end
 
-      # Second, try clearing the client's context
+      # Try clearing the client's context
       if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
         begin
           AIA.config.client.clear_context
@@ -446,10 +498,9 @@ module AIA
     end
 
     def handle_restore_directive(directive_output)
-      # If the restore was successful, we also need to refresh the client's context
+      # If the restore was successful, we also need to refresh the client's context - ADR-002 revised
       if directive_output.start_with?("Context restored")
         # Clear the client's context without reinitializing the entire adapter
-        # This avoids the risk of exiting if model initialization fails
         if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
           begin
             AIA.config.client.clear_context
@@ -459,17 +510,9 @@ module AIA
           end
         end
 
-        # Rebuild the conversation in the LLM client from the restored context
-        # This ensures the LLM's internal state matches what we restored
-        if AIA.config.client && @context_manager
-          begin
-            restored_context = @context_manager.get_context
-            # The client's context has been cleared, so we can safely continue
-            # The next interaction will use the restored context from context_manager
-          rescue => e
-            STDERR.puts "Warning: Error syncing restored context: #{e.message}"
-          end
-        end
+        # Note: For multi-model, only the first context manager was used for restore
+        # This is a limitation of the current directive system
+        # TODO: Consider supporting restore for all context managers
       end
 
       @ui_presenter.display_info(directive_output)
@@ -485,6 +528,39 @@ module AIA
       "I executed this directive: #{follow_up_prompt}\nHere's the output: #{directive_output}\nLet's continue our conversation."
     end
 
+    # Parse multi-model response into per-model responses (ADR-002 revised)
+    # Input:  "from: lms/model\nHabari!\n\nfrom: ollama/model\nKaixo!"
+    # Output: {"lms/model" => "Habari!", "ollama/model" => "Kaixo!"}
+    def parse_multi_model_response(combined_response)
+      return {} if combined_response.nil? || combined_response.empty?
+
+      responses = {}
+      current_model = nil
+      current_content = []
+
+      combined_response.each_line do |line|
+        if line =~ /^from:\s+(.+)$/
+          # Save previous model's response
+          if current_model
+            responses[current_model] = current_content.join.strip
+          end
+
+          # Start new model
+          current_model = $1.strip
+          current_content = []
+        elsif current_model
+          current_content << line
+        end
+      end
+
+      # Save last model's response
+      if current_model
+        responses[current_model] = current_content.join.strip
+      end
+
+      responses
+    end
+
     def cleanup_chat_prompt
       if @chat_prompt_id
         puts "[DEBUG] Cleaning up chat prompt: #{@chat_prompt_id}" if AIA.debug?

data/lib/extensions/ruby_llm/provider_fix.rb

@@ -1,34 +1,79 @@
 # lib/extensions/ruby_llm/provider_fix.rb
 #
-# Monkey patch to fix LM Studio compatibility with RubyLLM Provider
+# Monkey patch to fix LM Studio compatibility with RubyLLM
 # LM Studio sometimes returns response.body as a String that fails JSON parsing
 # This causes "String does not have #dig method" errors in parse_error
 
+# Load RubyLLM first to ensure Provider class exists
+require 'ruby_llm'
+
 module RubyLLM
-  class Provider
+  module ProviderErrorFix
     # Override the parse_error method to handle String responses from LM Studio
+    # Parses error response from provider API.
+    #
+    # Supports two error formats:
+    # 1. OpenAI standard: {"error": {"message": "...", "type": "...", "code": "..."}}
+    # 2. Simple format: {"error": "error message"}
+    #
+    # @param response [Faraday::Response] The HTTP response
+    # @return [String, nil] The error message or nil if parsing fails
+    #
+    # @example OpenAI format
+    #   response = double(body: '{"error": {"message": "Rate limit exceeded"}}')
+    #   parse_error(response) #=> "Rate limit exceeded"
+    #
+    # @example Simple format (LM Studio, some local providers)
+    #   response = double(body: '{"error": "Token limit exceeded"}')
+    #   parse_error(response) #=> "Token limit exceeded"
     def parse_error(response)
       return if response.body.empty?
 
       body = try_parse_json(response.body)
-
-      # Be more explicit about type checking to prevent String#dig errors
       case body
       when Hash
-        # Only call dig if we're certain it's a Hash
-        body.dig('error', 'message')
+        # Handle both formats:
+        # - {"error": "message"}          (LM Studio, some providers)
+        # - {"error": {"message": "..."}} (OpenAI standard)
+        error_value = body['error']
+        return nil unless error_value
+
+        case error_value
+        when Hash
+          error_value['message']
+        when String
+          error_value
+        else
+          error_value.to_s if error_value
+        end
       when Array
-        # Only call dig on array elements if they're Hashes
         body.filter_map do |part|
-          part.is_a?(Hash) ? part.dig('error', 'message') : part.to_s
+          next unless part.is_a?(Hash)
+
+          error_value = part['error']
+          next unless error_value
+
+          case error_value
+          when Hash then error_value['message']
+          when String then error_value
+          else error_value.to_s if error_value
+          end
         end.join('. ')
       else
-        # For Strings or any other type, convert to string
         body.to_s
       end
     rescue StandardError => e
-      # Fallback in case anything goes wrong
-      "Error parsing response: #{e.message}"
+      RubyLLM.logger.debug "Error parsing response: #{e.message}"
+      nil
     end
   end
-end
+end
+
+# Apply the prepend to all Provider subclasses
+# LM Studio uses the OpenAI provider, so we need to prepend to all provider classes
+RubyLLM::Provider.prepend(RubyLLM::ProviderErrorFix)
+
+# Also prepend to all registered provider classes
+RubyLLM::Provider.providers.each do |slug, provider_class|
+  provider_class.prepend(RubyLLM::ProviderErrorFix)
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aia
 version: !ruby/object:Gem::Version
-  version: 0.9.17
+  version: 0.9.19
 platform: ruby
 authors:
 - Dewayne VanHoozer