aia 0.9.15 → 0.9.17

data/lib/aia/ruby_llm_adapter.rb

@@ -1,6 +1,7 @@
 # lib/aia/ruby_llm_adapter.rb
 
 require 'async'
+require_relative '../extensions/ruby_llm/provider_fix'
 
 module AIA
   class RubyLLMAdapter
@@ -42,6 +43,8 @@ module AIA
 
         # --- Custom OpenAI Endpoint ---
         # Use this for Azure OpenAI, proxies, or self-hosted models via OpenAI-compatible APIs.
+        # For osaurus: Use model name prefix "osaurus/" and set OSAURUS_API_BASE env var
+        # For LM Studio: Use model name prefix "lms/" and set LMS_API_BASE env var
         config.openai_api_base = ENV.fetch('OPENAI_API_BASE', nil) # e.g., "https://your-azure.openai.azure.com"
 
         # --- Default Models ---
@@ -83,7 +86,35 @@ module AIA
 
       @models.each do |model_name|
         begin
-          chat = RubyLLM.chat(model: model_name)
+          # 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')
+
+            # 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' # 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)
+          end
           valid_chats[model_name] = chat
         rescue StandardError => e
           failed_models << "#{model_name}: #{e.message}"
@@ -212,33 +243,55 @@ module AIA
 
 
     def chat(prompt)
-      if @models.size == 1
+      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)
       else
         # Multiple models - use concurrent processing
         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
-      if modes.text_to_text?
+      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)
@@ -263,7 +316,7 @@ module AIA
 
     def format_multi_model_results(results)
       use_consensus = should_use_consensus_mode?
-      
+
       if use_consensus
         # Generate consensus response using primary model
         generate_consensus_response(results)
@@ -288,7 +341,7 @@ module AIA
       begin
         # Have the primary model generate the consensus
         consensus_result = primary_chat.ask(consensus_prompt).content
-        
+
         # Format the consensus response
         "from: #{primary_model} (consensus)\n#{consensus_result}"
       rescue StandardError => e
@@ -329,7 +382,7 @@ module AIA
     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) }
-      
+
       if has_metrics && AIA.config.show_metrics
         # Return structured data that preserves metrics for multi-model
         format_multi_model_with_metrics(results)
@@ -350,17 +403,17 @@ module AIA
         output.join("\n")
       end
     end
-    
+
     def format_multi_model_with_metrics(results)
       # Create a composite response that includes all model responses and metrics
       formatted_content = []
       metrics_data = []
-      
+
       results.each do |model_name, result|
         formatted_content << "from: #{model_name}"
         formatted_content << result.content
         formatted_content << ""
-        
+
         # Collect metrics for each model
         metrics_data << {
           model_id: model_name,
@@ -368,20 +421,20 @@ module AIA
           output_tokens: result.output_tokens
         }
       end
-      
+
       # Return a special MultiModelResponse that ChatProcessorService can handle
       MultiModelResponse.new(formatted_content.join("\n"), metrics_data)
     end
-    
+
     # Helper class to carry multi-model response with metrics
     class MultiModelResponse
       attr_reader :content, :metrics_list
-      
+
       def initialize(content, metrics_list)
         @content = content
         @metrics_list = metrics_list
       end
-      
+
       def multi_model?
         true
       end
@@ -415,7 +468,7 @@ module AIA
 
 
     # Clear the chat context/history
-    # Needed for the //clear directive
+    # Needed for the //clear and //restore directives
     def clear_context
       @chats.each do |model_name, chat|
         # Option 1: Directly clear the messages array in the current chat object
@@ -430,16 +483,65 @@ module AIA
       # This ensures any shared state is reset
       RubyLLM.instance_variable_set(:@chat, nil) if RubyLLM.instance_variable_defined?(:@chat)
 
-      # Option 3: Create completely fresh chat instances for this adapter
-      @chats = {} # First nil the chats hash
+      # 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
 
       begin
         @models.each do |model_name|
-          @chats[model_name] = RubyLLM.chat(model: 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
+
+            # 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
+          end
         end
       rescue StandardError => e
-        warn "ERROR: #{e.message}"
-        exit 1
+        # 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)
+            chat.instance_variable_set(:@messages, [])
+          end
+        end
       end
 
       # Option 4: Call official clear_history method if it exists
@@ -498,6 +600,44 @@ module AIA
     end
 
 
+    def validate_lms_model!(model_name, api_base)
+      require 'net/http'
+      require 'json'
+
+      # Build the /v1/models endpoint URL
+      uri = URI("#{api_base.gsub(%r{/v1/?$}, '')}/v1/models")
+
+      begin
+        response = Net::HTTP.get_response(uri)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise "Cannot connect to LM Studio at #{api_base}. Is LM Studio running?"
+        end
+
+        data = JSON.parse(response.body)
+        available_models = data['data']&.map { |m| m['id'] } || []
+
+        unless available_models.include?(model_name)
+          error_msg = "❌ '#{model_name}' is not a valid LM Studio model.\n\n"
+          if available_models.empty?
+            error_msg += "No models are currently loaded in LM Studio.\n"
+            error_msg += "Please load a model in LM Studio first."
+          else
+            error_msg += "Available LM Studio models:\n"
+            available_models.each { |m| error_msg += "  - lms/#{m}\n" }
+          end
+          raise error_msg
+        end
+      rescue JSON::ParserError => e
+        raise "Invalid response from LM Studio at #{api_base}: #{e.message}"
+      rescue StandardError => e
+        # Re-raise our custom error messages, wrap others
+        raise if e.message.start_with?('❌')
+        raise "Error connecting to LM Studio: #{e.message}"
+      end
+    end
+
+
     def extract_models_config
       models_config = AIA.config.model
 
@@ -531,15 +671,30 @@ module AIA
     def text_to_text_single(prompt, model_name)
       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

@@ -418,23 +418,23 @@ module AIA
 
     def handle_clear_directive
       # The directive processor has called context_manager.clear_context
-      # but we need a more aggressive approach to fully clear all 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)
 
       # Second, try clearing the client's context
       if AIA.config.client && AIA.config.client.respond_to?(:clear_context)
-        AIA.config.client.clear_context
+        begin
+          AIA.config.client.clear_context
+        rescue => e
+          STDERR.puts "Warning: Error clearing client context: #{e.message}"
+          # Continue anyway - the context manager has been cleared which is the main goal
+        end
       end
 
-      # Third, completely reinitialize the client to ensure fresh state
-      # This is the most aggressive approach to ensure no context remains
-      begin
-        AIA.config.client = AIA::RubyLLMAdapter.new
-      rescue => e
-        STDERR.puts "Error reinitializing client: #{e.message}"
-      end
+      # Note: We intentionally do NOT reinitialize the client here
+      # as that could cause termination if model initialization fails
 
       @ui_presenter.display_info("Chat context cleared.")
       nil
@@ -448,16 +448,27 @@ module AIA
     def handle_restore_directive(directive_output)
       # If the restore was successful, we also need to refresh the client's context
       if directive_output.start_with?("Context restored")
-        # Try to clear and rebuild the client's context
+        # 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)
-          AIA.config.client.clear_context
+          begin
+            AIA.config.client.clear_context
+          rescue => e
+            STDERR.puts "Warning: Error clearing client context after restore: #{e.message}"
+            # Continue anyway - the context manager has been restored which is the main goal
+          end
         end
 
-        # Optionally reinitialize the client for a clean state
-        begin
-          AIA.config.client = AIA::RubyLLMAdapter.new
-        rescue => e
-          STDERR.puts "Error reinitializing client after restore: #{e.message}"
+        # 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
       end
 

data/lib/extensions/ruby_llm/provider_fix.rb

@@ -0,0 +1,34 @@
+# lib/extensions/ruby_llm/provider_fix.rb
+#
+# Monkey patch to fix LM Studio compatibility with RubyLLM Provider
+# 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
+
+module RubyLLM
+  class Provider
+    # Override the parse_error method to handle String responses from LM Studio
+    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')
+      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
+        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}"
+    end
+  end
+end

data/mkdocs.yml

@@ -151,6 +151,7 @@ nav:
     - Getting Started: guides/getting-started.md
     - Chat Mode: guides/chat.md
     - Working with Models: guides/models.md
+    - Local Models: guides/local-models.md
     - Available Models: guides/available-models.md
     - Image Generation: guides/image-generation.md
     - Tools Integration: guides/tools.md

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: aia
 version: !ruby/object:Gem::Version
-  version: 0.9.15
+  version: 0.9.17
 platform: ruby
 authors:
 - Dewayne VanHoozer
@@ -289,6 +289,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov_lcov_formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: tocer
   requirement: !ruby/object:Gem::Requirement
@@ -303,6 +317,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 'AIA is a revolutionary CLI console application that brings multi-model
   AI capabilities to your command line, supporting 20+ providers including OpenAI,
   Anthropic, and Google. Run multiple AI models simultaneously for comparison, get
@@ -354,6 +382,7 @@ files:
 - docs/guides/getting-started.md
 - docs/guides/image-generation.md
 - docs/guides/index.md
+- docs/guides/local-models.md
 - docs/guides/models.md
 - docs/guides/tools.md
 - docs/index.md
@@ -416,6 +445,7 @@ files:
 - lib/extensions/openstruct_merge.rb
 - lib/extensions/ruby_llm/.irbrc
 - lib/extensions/ruby_llm/modalities.rb
+- lib/extensions/ruby_llm/provider_fix.rb
 - lib/refinements/string.rb
 - main.just
 - mcp_servers/README.md