aia 0.9.1 → 0.9.3rc1

data/lib/aia/context_manager.rb

@@ -57,7 +57,7 @@ module AIA
           RubyLLM.chat.clear_history
         end
       rescue => e
-        AIA.debug_me(tag: '== context_manager clear_context error =='){[ :e, e.message, e.backtrace ]}
+        STDERR.puts "ERROR: context_manager clear_context error #{e.message}"
       end
     end
 

data/lib/aia/directive_processor.rb

@@ -57,7 +57,7 @@ module AIA
                else
                  a_string.to_s
                end
-      
+
       content.strip.start_with?(PromptManager::Prompt::DIRECTIVE_SIGNAL)
     end
 
@@ -162,6 +162,7 @@ module AIA
       end
       ''
     end
+    alias_method :workflow, :pipeline
 
     desc "Inserts the contents of a file  Example: //include path/to/file"
     def include(args, context_manager=nil)
@@ -240,6 +241,10 @@ module AIA
 
     desc "Clears the conversation history (aka context) same as //config clear = true"
     def clear(args, context_manager=nil)
+      # TODO: review the robot's code in the Session class for when the
+      #       //clear directive is used in a follow up prompt.  That processing
+      #       should be moved here so that it is also available in batch
+      #       sessions.
       if context_manager.nil?
         return "Error: Context manager not available for //clear directive."
       end

data/lib/aia/ruby_llm_adapter.rb

@@ -1,55 +1,136 @@
 # lib/aia/ruby_llm_adapter.rb
 
 require 'ruby_llm'
-require 'mcp_client'
+
+class RubyLLM::Modalities
+  def supports?(query_mode)
+    parts = query_mode
+              .to_s
+              .downcase
+              .split(/2|-to-| to |_to_/)
+              .map(&:strip)
+
+    if 2 == parts.size
+      input.include?(parts[0]) && output.include?(parts[1])
+    elsif 1 == parts.size
+      input.include?(parts[0]) || output.include?(parts[0])
+    else
+      false
+    end
+  end
+end
 
 module AIA
   class RubyLLMAdapter
-    def initialize
+    attr_reader :tools
 
-      debug_me('=== RubyLLMAdapter ===')
+    def initialize
+      @provider, @model = extract_model_parts.values
 
-      @model     = AIA.config.model
-      model_info = extract_model_parts(@model)
+      configure_rubyllm
+      refresh_local_model_registry
+      setup_chat_with_tools
+    end
 
-      # Configure RubyLLM with available API keys
+    def configure_rubyllm
+      # TODO: Add some of these configuration items to AIA.config
       RubyLLM.configure do |config|
-        config.openai_api_key    = ENV.fetch('OPENAI_API_KEY', nil)
-        config.anthropic_api_key = ENV.fetch('ANTHROPIC_API_KEY', nil)
-        config.gemini_api_key    = ENV.fetch('GEMINI_API_KEY', nil)
-        config.deepseek_api_key  = ENV.fetch('DEEPSEEK_API_KEY', nil)
-
-        # Bedrock configuration
-        config.bedrock_api_key       = ENV.fetch('AWS_ACCESS_KEY_ID', nil)
-        config.bedrock_secret_key    = ENV.fetch('AWS_SECRET_ACCESS_KEY', nil)
-        config.bedrock_region        = ENV.fetch('AWS_REGION', nil)
-        config.bedrock_session_token = ENV.fetch('AWS_SESSION_TOKEN', nil)
+        config.openai_api_key         = ENV.fetch('OPENAI_API_KEY', nil)
+        config.openai_organization_id = ENV.fetch('OPENAI_ORGANIZATION_ID', nil)
+        config.openai_project_id      = ENV.fetch('OPENAI_PROJECT_ID', nil)
+
+        config.anthropic_api_key  = ENV.fetch('ANTHROPIC_API_KEY', nil)
+        config.gemini_api_key     = ENV.fetch('GEMINI_API_KEY', nil)
+        config.deepseek_api_key   = ENV.fetch('DEEPSEEK_API_KEY', nil)
+        config.openrouter_api_key = ENV.fetch('OPENROUTER_API_KEY', nil)
+
+        config.bedrock_api_key       = ENV.fetch('BEDROCK_ACCESS_KEY_ID', nil)
+        config.bedrock_secret_key    = ENV.fetch('BEDROCK_SECRET_ACCESS_KEY', nil)
+        config.bedrock_region        = ENV.fetch('BEDROCK_REGION', nil)
+        config.bedrock_session_token = ENV.fetch('BEDROCK_SESSION_TOKEN', nil)
+
+        config.ollama_api_base    = ENV.fetch('OLLAMA_API_BASE', nil)
+
+        # --- Custom OpenAI Endpoint ---
+        # Use this for Azure OpenAI, proxies, or self-hosted models via OpenAI-compatible APIs.
+        config.openai_api_base  = ENV.fetch('OPENAI_API_BASE', nil) # e.g., "https://your-azure.openai.azure.com"
+
+        # --- Default Models ---
+        # Used by RubyLLM.chat, RubyLLM.embed, RubyLLM.paint if no model is specified.
+        # config.default_model            = 'gpt-4.1-nano'            # Default: 'gpt-4.1-nano'
+        # config.default_embedding_model  = 'text-embedding-3-small'  # Default: 'text-embedding-3-small'
+        # config.default_image_model      = 'dall-e-3'                # Default: 'dall-e-3'
+
+        # --- Connection Settings ---
+        # config.request_timeout            = 120 # Request timeout in seconds (default: 120)
+        # config.max_retries                = 3   # Max retries on transient network errors (default: 3)
+        # config.retry_interval             = 0.1 # Initial delay in seconds (default: 0.1)
+        # config.retry_backoff_factor       = 2   # Multiplier for subsequent retries (default: 2)
+        # config.retry_interval_randomness  = 0.5 # Jitter factor (default: 0.5)
+
+        # --- Logging Settings ---
+        # config.log_file   = '/logs/ruby_llm.log'
+        config.log_level  = :fatal # debug level can also be set to debug by setting RUBYLLM_DEBUG envar to true
       end
+    end
 
-      debug_me{[ :model_info ]}
+    def refresh_local_model_registry
+      if  AIA.config.refresh.nil?           ||
+          Integer(AIA.config.refresh).zero? ||
+          Date.today > (AIA.config.last_refresh + Integer(AIA.config.refresh))
+        RubyLLM.models.refresh!
+        AIA.config.last_refresh = Date.today
+        if AIA.config.config_file
+          AIA::Config.dump_config(AIA.config, AIA.config.config_file)
+        end
+      end
+    end
 
-      mcp_client, mcp_tools = generate_mcp_tools(model_info[:provider])
+    def setup_chat_with_tools
+      begin
+        @chat = RubyLLM.chat(model: @model)
+      rescue => e
+        STDERR.puts "ERROR: #{e.message}"
+        exit 1
+      end
 
-      debug_me{[ :mcp_tools ]}
+      if !AIA.config.tool_paths.empty? && !@chat.model.supports?(:function_calling)
+        STDERR.puts "ERROR: The model #{@model} does not support tools"
+        exit 1
+      end
 
-      if mcp_tools && !mcp_tools.empty?
-        RubyLLM::Chat.with_mcp(client: mcp_client, call_tool_method: :call_tool, tools: mcp_tools)
+      @tools = ObjectSpace.each_object(Class).select do |klass|
+        klass < RubyLLM::Tool
       end
 
-      @chat = RubyLLM.chat(model: model_info[:model])
+      unless tools.empty?
+        @chat.with_tools(*tools)
+        AIA.config.tools = tools.map(&:name).join(', ')
+      end
     end
 
+    # TODO: Need to rethink this dispatcher pattern w/r/t RubyLLM's capabilities
+    #       This code was originally designed for AiClient
+    #
     def chat(prompt)
-      if @model.downcase.include?('dall-e') || @model.downcase.include?('image-generation')
-        text_to_image(prompt)
-      elsif @model.downcase.include?('vision') || @model.downcase.include?('image')
+      modes = @chat.model.modalities
+
+      # TODO: Need to consider how to handle multi-mode models
+      if modes.supports? :text_to_text
+        text_to_text(prompt)
+
+      elsif modes.supports? :image_to_text
         image_to_text(prompt)
-      elsif @model.downcase.include?('tts') || @model.downcase.include?('speech')
+      elsif modes.supports? :text_to_image
+        text_to_image(prompt)
+
+      elsif modes.supports? :text_to_audio
         text_to_audio(prompt)
-      elsif @model.downcase.include?('whisper') || @model.downcase.include?('transcription')
+      elsif modes.supports? :audio_to_text
         audio_to_text(prompt)
+
       else
-        text_to_text(prompt)
+        # TODO: what else can be done?
       end
     end
 
@@ -73,74 +154,56 @@ module AIA
       end
     end
 
-    def method_missing(method, *args, &block)
-      debug_me(tag: '== missing ==', levels: 25){[ :method, :args ]}
-      if @chat.respond_to?(method)
-        @chat.public_send(method, *args, &block)
-      else
-        super
-      end
-    end
-
     # Clear the chat context/history
     # Needed for the //clear directive
     def clear_context
-      AIA.debug_me(tag: '== AGGRESSIVELY clearing LLM context ==') do
+      begin
+        # Option 1: Directly clear the messages array in the current chat object
+        if @chat.instance_variable_defined?(:@messages)
+          old_messages = @chat.instance_variable_get(:@messages)
+          # Force a completely empty array, not just attempting to clear it
+          @chat.instance_variable_set(:@messages, [])
+        end
+
+        # Option 2: Force RubyLLM to create a new chat instance at the global level
+        # This ensures any shared state is reset
+        @provider, @model = extract_model_parts.values
+        RubyLLM.instance_variable_set(:@chat, nil) if RubyLLM.instance_variable_defined?(:@chat)
+
+        # Option 3: Create a completely fresh chat instance for this adapter
+        @chat = nil  # First nil it to help garbage collection
+
         begin
-          # Option 1: Directly clear the messages array in the current chat object
-          if @chat.instance_variable_defined?(:@messages)
-            AIA.debug_me("Directly clearing @messages array")
-            old_messages = @chat.instance_variable_get(:@messages)
-            AIA.debug_me{[:old_messages, old_messages.length]}
-            # Force a completely empty array, not just attempting to clear it
-            @chat.instance_variable_set(:@messages, [])
-          end
-
-          # Option 2: Force RubyLLM to create a new chat instance at the global level
-          # This ensures any shared state is reset
-          AIA.debug_me("Force global RubyLLM chat reset")
-          model_info = extract_model_parts(@model)
-          RubyLLM.instance_variable_set(:@chat, nil) if RubyLLM.instance_variable_defined?(:@chat)
-          
-          # Option 3: Create a completely fresh chat instance for this adapter
-          @chat = nil  # First nil it to help garbage collection
-          @chat = RubyLLM.chat(model: model_info[:model])
-          AIA.debug_me("Created fresh RubyLLM::Chat instance")
-          
-          # Option 4: Call official clear_history method if it exists
-          if @chat.respond_to?(:clear_history)
-            AIA.debug_me("Calling clear_history method")
-            @chat.clear_history
-          end
-          
-          # Option 5: If chat has messages, force set it to empty again as a final check
-          if @chat.instance_variable_defined?(:@messages) && !@chat.instance_variable_get(:@messages).empty?
-            AIA.debug_me("FINAL CHECK: @messages still not empty, forcing empty")
-            @chat.instance_variable_set(:@messages, [])
-          end
-          
-          # Reset any MCP tools configuration
-          begin
-            mcp_client, mcp_tools = generate_mcp_tools(model_info[:provider])
-            if mcp_tools && !mcp_tools.empty?
-              AIA.debug_me("Reconfiguring MCP tools")
-              RubyLLM::Chat.with_mcp(client: mcp_client, call_tool_method: :call_tool, tools: mcp_tools)
-            end
-          rescue => mcp_error
-            AIA.debug_me{[:mcp_error, mcp_error.message]}
-          end
-          
-          # Final verification
-          new_messages = @chat.instance_variable_defined?(:@messages) ? @chat.instance_variable_get(:@messages) : []
-          AIA.debug_me{[:new_messages, new_messages.length]}
-          
-          return "Chat context successfully cleared."
+          @chat = RubyLLM.chat(model: @model)
         rescue => e
-          AIA.debug_me{
-            [ :e, e.message, e.backtrace ]
-          }
-          return "Error clearing chat context: #{e.message}"
+          STDERR.puts "ERROR: #{e.message}"
+          exit 1
+        end
+
+        # Option 4: Call official clear_history method if it exists
+        if @chat.respond_to?(:clear_history)
+          @chat.clear_history
         end
+
+        # Option 5: If chat has messages, force set it to empty again as a final check
+        if @chat.instance_variable_defined?(:@messages) && !@chat.instance_variable_get(:@messages).empty?
+          @chat.instance_variable_set(:@messages, [])
+        end
+
+        # Final verification
+        new_messages = @chat.instance_variable_defined?(:@messages) ? @chat.instance_variable_get(:@messages) : []
+
+        return "Chat context successfully cleared."
+      rescue => e
+        return "Error clearing chat context: #{e.message}"
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      if @chat.respond_to?(method)
+        @chat.public_send(method, *args, &block)
+      else
+        super
       end
     end
 
@@ -150,49 +213,19 @@ module AIA
 
     private
 
-    # Generate an array of MCP tools, filtered and formatted for the correct provider.
-    # @param config [OpenStruct] the config object containing mcp_servers, allowed_tools, and model
-    # @return [Array<Hash>, nil] the filtered and formatted MCP tools or nil if no tools
-    def generate_mcp_tools(provider)
-      return [nil, nil] unless AIA.config.mcp_servers && !AIA.config.mcp_servers.empty?
-
-      debug_me('=== generate_mcp_tools ===')
-
-      # AIA.config.mcp_servers is now a path to the combined JSON file
-      mcp_client     = MCPClient.create_client(server_definition_file: AIA.config.mcp_servers)
-      debug_me
-      all_tools      = mcp_client.list_tools(cache: false).map(&:name)
-      debug_me
-      allowed        = AIA.config.allowed_tools
-      debug_me
-      filtered_tools = allowed.nil? ? all_tools : all_tools & allowed
-      debug_me{[ :filtered_tools ]}
-
-      debug_me{[ :provider ]}
-
-      mcp_tools = if :anthropic == provider.to_sym
-                    debug_me
-                    mcp_client.to_anthropic_tools(tool_names: filtered_tools)
-                  else
-                    debug_me
-                    mcp_client.to_openai_tools(tool_names: filtered_tools)
-                  end
-      [mcp_client, mcp_tools]
-    rescue => e
-      STDERR.puts "ERROR: Failed to generate MCP tools: #{e.message}"
-      nil
-    end
-
-    def extract_model_parts(model_string)
-      parts = model_string.split('/')
+    def extract_model_parts
+      parts = AIA.config.model.split('/')
       parts.map!(&:strip)
 
-      if parts.length > 1
-        provider = parts[0]
-        model = parts[1]
+      if 2 == parts.length
+        provider  = parts[0]
+        model     = parts[1]
+      elsif 1 == parts.length
+        provider  = nil # RubyLLM will figure it out from the model name
+        model     = parts[0]
       else
-        provider = nil # RubyLLM will figure it out from the model name
-        model = parts[0]
+        STDERR.puts "ERROR: malformed model name: #{AIA.config.model}"
+        exit 1
       end
 
       { provider: provider, model: model }
@@ -212,7 +245,7 @@ module AIA
 
     def text_to_text(prompt)
       text_prompt = extract_text_prompt(prompt)
-      @chat.ask(text_prompt)
+      @chat.ask(text_prompt).content
     end
 
     def text_to_image(prompt)
@@ -221,9 +254,9 @@ module AIA
 
       begin
         RubyLLM.paint(text_prompt, output_path: output_file,
-                      size: AIA.config.image_size,
-                      quality: AIA.config.image_quality,
-                      style: AIA.config.image_style)
+                      size:     AIA.config.image_size,
+                      quality:  AIA.config.image_quality,
+                      style:    AIA.config.image_style)
         "Image generated and saved to: #{output_file}"
       rescue => e
         "Error generating image: #{e.message}"
@@ -231,12 +264,12 @@ module AIA
     end
 
     def image_to_text(prompt)
-      image_path = extract_image_path(prompt)
+      image_path  = extract_image_path(prompt)
       text_prompt = extract_text_prompt(prompt)
 
       if image_path && File.exist?(image_path)
         begin
-          @chat.ask(text_prompt, with: { image: image_path })
+          @chat.ask(text_prompt, with: { image: image_path }).content
         rescue => e
           "Error analyzing image: #{e.message}"
         end
@@ -260,11 +293,16 @@ module AIA
       end
     end
 
+    # TODO: what if its a multi-mode model and a text prompt is provided with
+    #       the audio file?
     def audio_to_text(prompt)
+      text = extract_text_prompt(prompt)
+      text = 'Transcribe this audio' if text.nil? || text.empty?
+
       if prompt.is_a?(String) && File.exist?(prompt) &&
          prompt.downcase.end_with?('.mp3', '.wav', '.m4a', '.flac')
         begin
-          @chat.ask("Transcribe this audio", with: { audio: prompt })
+          @chat.ask(text, with: { audio: prompt }).content
         rescue => e
           "Error transcribing audio: #{e.message}"
         end

data/lib/aia/session.rb

@@ -184,8 +184,8 @@ module AIA
         @chat_prompt = PromptManager::Prompt.new(
           id: @chat_prompt_id,
           directives_processor: @directive_processor,
-          erb_flag:             AIA.config.erb,
-          envar_flag:           AIA.config.shell,
+          erb_flag:             true,
+          envar_flag:           true,
           external_binding:     binding,
         )
 
@@ -259,24 +259,23 @@ module AIA
             if follow_up_prompt.strip.start_with?('//clear')
                # The directive processor has called context_manager.clear_context
                # but we need a more aggressive approach to fully clear all 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
                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
-                 AIA.debug_me("Completely reinitialized client for //clear directive")
                rescue => e
-                 AIA.debug_me("Error reinitializing client: #{e.message}")
+                 STDERR.puts "Error reinitializing client: #{e.message}"
                end
-               
+
                @ui_presenter.display_info("Chat context cleared.")
                next
             elsif directive_output.nil? || directive_output.strip.empty?

data/lib/aia/utility.rb

@@ -1,23 +1,33 @@
 # lib/aia/utility.rb
 
+require 'word_wrapper'      # Pure ruby word wrapping
+
 module AIA
   class Utility
     class << self
       # Displays the AIA robot ASCII art
+      # Yes, its slightly frivolous but it does contain some
+      # useful configuration information.
       def robot
+        indent  = 18
+        spaces  = " "*indent
+        width   = TTY::Screen.width - indent - 2
+
         puts <<-ROBOT
 
        ,      ,
-       (\\____/) AI Assistant
+       (\\____/) AI Assistant (v#{AIA::VERSION}) is Online
         (_oo_)   #{AIA.config.model}
-         (O)      is Online
-       __||__    \\) using #{AIA.config.adapter}
-     [/______\\]  /
-    / \\__AI__/ \\/
+         (O)       using #{AIA.config.adapter} (v#{RubyLLM::VERSION})
+       __||__    \\) model db was last refreshed on
+     [/______\\]  /    #{AIA.config.last_refresh}
+    / \\__AI__/ \\/      #{AIA.config.tool_paths.empty? ? 'I forgot my toolbox' : 'I brought some tools'}
    /    /__\\
-  (\\   /____\\
-
+  (\\   /____\\   #{AIA.config.tool_paths.empty? ? '' : 'My Toolbox contains:'}
         ROBOT
+        if AIA.config.tools
+          puts WordWrapper::MinimumRaggedness.new(width, AIA.config.tools).wrap.split("\n").map{|s| spaces+s+"\n"}.join
+        end
       end
     end
   end

data/lib/aia.rb

@@ -5,10 +5,7 @@
 # provides an interface for interacting with AI models and managing prompts.
 
 require 'ruby_llm'
-require_relative 'extensions/ruby_llm/chat'
-
 require 'prompt_manager'
-require 'mcp_client'
 
 require 'debug_me'
 include DebugMe
@@ -82,12 +79,21 @@ module AIA
     prompt_handler = PromptHandler.new
 
     # Initialize the appropriate client adapter based on configuration
-    @config.client = if @config.adapter == 'ruby_llm'
+    @config.client = if 'ruby_llm' == @config.adapter
                       RubyLLMAdapter.new
                     else
-                      AIClientAdapter.new
+                      # TODO: ?? some other LLM API wrapper
+                      STDERR.puts "ERROR: There is no adapter for #{@config.adapter}"
+                      exit 1
                     end
 
+    # There are two kinds of sessions: batch and chat
+    # A chat session is started when the --chat CLI option is used
+    # BUT its also possible to start a chat session with an initial prompt AND
+    # within that initial prompt there can be a workflow (aka pipeline)
+    # defined.  If that is the case, then the chat session will not start
+    # until the initial prompt has completed its workflow.
+
     session        = Session.new(prompt_handler)
 
     session.start