legion-llm 0.9.15 → 0.9.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 206afbe8609bb8ed7df111d216967aafba55b0d523d5939aad024f169e43f5ef
-  data.tar.gz: 283f42c3d5b9ba07aa7857aad3e6d1f30b7559f35282f4a1d00986ea4ab2c646
+  metadata.gz: ce44e3d928a848ab67e5cd50574c7454ff3490a455c1d040c7089641e1091e5e
+  data.tar.gz: ef3eaa05c9340b08f94af99c7b4f35334cef2a1d8dd09aeafb3535532840b4ce
 SHA512:
-  metadata.gz: 54b3e821013f9ba6f73019907821e85d1aaacc766e8942767f5e6a9630d66757c1d16a8e1b6643054895b1e5de229245e45ebf562f42bdec1cfac8f609024a5c
-  data.tar.gz: 45d349d01bef14e68527aa0c8108c4d08f71e05b63c87c331e377703bdacfcee431b903fe72dc2ad48b10c2f73a67523e9c67a0da1dd46b4b9cf3e041c290671
+  metadata.gz: 1dc635c864ac647911bc6d55a34209f10273471b63683ab4eaa7dc69fdee7d3047c6b028b9d5180688b0b7ed4624c89fa90e5a7745f2462cb30371fe84607a11
+  data.tar.gz: ddd2e32d57a9a56d1fff22c4b7e423145d743183efd7044290482612b704b4c787db9790d28733df53e69a90ed57e4af1d7f6bef89f069ad3a25fafbe09b63ae

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Legion LLM Changelog
 
+## [0.9.17] - 2026-05-11
+
+### Fixed
+- `total_memory_mb` now fetched exactly once on first access and never re-fetched; hardware memory is static so repeated `sysctl` calls every 60s were wasteful. `refresh!` only clears the available memory cache; `reset!` still clears everything (for tests).
+- `trivial_query?` now correctly identifies short/trivial messages: a query is trivial if it matches a known trivial pattern (exact normalized match), or if no custom patterns are configured and the query is short (under `trivial_max_chars`) and a single word. Previously, an empty patterns list caused `.any?` to always return false, so nothing was ever trivial.
+- Added `trivial_patterns` helper with configurable defaults (`ping`, `pong`, `ding`, `test`, `foobar`) readable via `rag.trivial_patterns` setting; when custom patterns are explicitly configured, the short-query heuristic is disabled so only listed patterns are treated as trivial.
+
+## [0.9.16] - 2026-05-11
+
+### Fixed
+- Renamed `Metering#settings_value` to `extract_hash_value` to fix method shadowing with `Legion::Logging::Helper#settings_value`, which resolves a `wrong number of arguments (given 3, expected 2)` error raised from `instance_log_level` when metering is active.
+
 ## [0.9.15] - 2026-05-08
 
 ### Fixed

data/lib/legion/llm/context/curator.rb

@@ -247,11 +247,13 @@ module Legion
         def load_curated(conversation_id)
           return nil unless Inference::Conversation.conversation_exists?(conversation_id)
 
-          raw = Inference::Conversation.messages(conversation_id)
+          # Use raw_messages so CURATED_ROLE entries are visible even though they
+          # are filtered out of the public-facing Conversation#messages array.
+          raw = Inference::Conversation.raw_messages(conversation_id)
           curated_entries = raw.select { |m| m[:role] == CURATED_KEY }
           return nil if curated_entries.empty?
 
-          regular = raw.reject { |m| m[:role] == CURATED_KEY }
+          regular = raw.reject { |m| [CURATED_KEY, Inference::Conversation::METADATA_ROLE].include?(m[:role]) }
           summaries = normalized_curated_summaries(curated_entries)
           if summaries.empty?
             apply_curation_pipeline(regular)

data/lib/legion/llm/discovery/system.rb

@@ -31,9 +31,7 @@ module Legion
           end
 
           def refresh!
-            @total_fetched_at = nil
             @available_fetched_at = nil
-            @total_memory_mb = nil
             @available_memory_mb = nil
             @last_refreshed_at = Time.now
           end
@@ -57,7 +55,6 @@ module Legion
           private
 
           def ensure_total_fresh
-            refresh! if stale?
             return unless @total_fetched_at.nil?
 
             fetch_total

data/lib/legion/llm/inference/conversation.rb

@@ -11,6 +11,7 @@ module Legion
 
         MAX_CONVERSATIONS = 256
         METADATA_ROLE = :__metadata__
+        CURATED_ROLE  = :__curated__
 
         class << self
           def append(conversation_id, role:, content:, parent_id: nil, sidechain: false,
@@ -38,29 +39,41 @@ module Legion
 
           # Returns flat ordered message array — backward-compatible.
           # Uses chain reconstruction when parent links exist; falls back to seq order.
+          # Internal-only roles (__metadata__, __curated__) are filtered out.
           def messages(conversation_id)
             if in_memory?(conversation_id)
               touch(conversation_id)
-              raw = conversations[conversation_id][:messages].reject { |m| m[:role] == METADATA_ROLE }
+              raw = conversations[conversation_id][:messages].reject { |m| internal_role?(m[:role]) }
               chain_or_seq(raw)
             else
               load_from_db(conversation_id)
             end
           end
 
+          # Returns ALL messages including internal-role entries (__metadata__, __curated__).
+          # Use this when you need access to curation markers or metadata entries.
+          def raw_messages(conversation_id)
+            if in_memory?(conversation_id)
+              touch(conversation_id)
+              conversations[conversation_id][:messages].dup
+            else
+              load_all_from_db(conversation_id)
+            end
+          end
+
           # Build ordered chain from parent links.
           # Excludes sidechain messages by default.
           def build_chain(conversation_id, include_sidechains: false)
             raw = all_raw_messages(conversation_id)
             raw = raw.reject { |m| m[:sidechain] } unless include_sidechains
-            raw = raw.reject { |m| m[:role] == METADATA_ROLE }
+            raw = raw.reject { |m| internal_role?(m[:role]) }
             reconstruct_chain(raw)
           end
 
           # Return sidechain messages; optionally filter by agent_id.
           def sidechain_messages(conversation_id, agent_id: nil)
             raw = all_raw_messages(conversation_id)
-            result = raw.select { |m| m[:sidechain] && m[:role] != METADATA_ROLE }
+            result = raw.select { |m| m[:sidechain] && !internal_role?(m[:role]) }
             result = result.select { |m| m[:agent_id] == agent_id } unless agent_id.nil?
             result.sort_by { |m| m[:seq] }
           end
@@ -243,6 +256,12 @@ module Legion
 
           private
 
+          # Returns true for roles that are internal bookkeeping and should not
+          # appear in the public-facing message array returned by #messages.
+          def internal_role?(role)
+            [METADATA_ROLE, CURATED_ROLE].include?(role)
+          end
+
           def conversations
             @conversations ||= {}
           end
@@ -543,9 +562,22 @@ module Legion
                                .where(conversation_id: conversation_id)
                                .order(:seq)
                                .map { |row| symbolize_message(row) }
+                               .reject { |m| internal_role?(m[:role]) }
             chain_or_seq(rows)
           end
 
+          def load_all_from_db(conversation_id)
+            return [] unless db_available?
+
+            Legion::Data.connection[:conversation_messages]
+                        .where(conversation_id: conversation_id)
+                        .order(:seq)
+                        .map { |row| symbolize_message(row) }
+          rescue StandardError => e
+            handle_exception(e, level: :debug)
+            []
+          end
+
           def db_conversation_record?(conversation_id)
             Legion::Data.connection[:conversations].where(id: conversation_id).any?
           end

data/lib/legion/llm/inference/steps/rag_context.rb

@@ -134,12 +134,18 @@ module Legion
           def trivial_query?(query)
             query = content_text(query)
             max_chars = rag_setting(:trivial_max_chars, 20)
-            patterns  = rag_setting(:trivial_patterns, [])
-
-            return false if query.length > max_chars
+            configured_patterns = rag_setting(:trivial_patterns)
 
             normalized = query.strip.downcase.gsub(/[^a-z0-9\s]/, '')
-            patterns.any? { |p| normalized == p }
+            patterns = configured_patterns || trivial_patterns
+            return true if patterns.any? { |p| normalized == p }
+            return true if configured_patterns.nil? && query.length <= max_chars && normalized.split.length <= 1
+
+            false
+          end
+
+          def trivial_patterns
+            rag_setting(:trivial_patterns, %w[ping pong ding test foobar])
           end
 
           def apollo_available?
@@ -314,7 +320,8 @@ module Legion
           def positive_integer(value)
             integer = Integer(value)
             integer.positive? ? integer : nil
-          rescue ArgumentError, TypeError
+          rescue ArgumentError, TypeError => e
+            handle_exception(e, level: :debug, handled: true, operation: 'llm.pipeline.steps.rag_context.positive_integer')
             nil
           end
         end

data/lib/legion/llm/metering.rb

@@ -142,26 +142,26 @@ module Legion
       def extract_usage(response)
         return { input_tokens: 0, output_tokens: 0 } unless response.is_a?(Hash)
 
-        usage = settings_value(response, :usage) || {}
+        usage = extract_hash_value(response, :usage) || {}
         {
-          input_tokens:  settings_value(usage, :input_tokens) || settings_value(usage, :prompt_tokens) || 0,
-          output_tokens: settings_value(usage, :output_tokens) || settings_value(usage, :completion_tokens) || 0
+          input_tokens:  extract_hash_value(usage, :input_tokens) || extract_hash_value(usage, :prompt_tokens) || 0,
+          output_tokens: extract_hash_value(usage, :output_tokens) || extract_hash_value(usage, :completion_tokens) || 0
         }
       end
 
       def extract_provider(response)
         return nil unless response.is_a?(Hash)
 
-        settings_value(settings_value(response, :meta), :provider) || settings_value(response, :provider)
+        extract_hash_value(extract_hash_value(response, :meta), :provider) || extract_hash_value(response, :provider)
       end
 
       def extract_model(response)
         return nil unless response.is_a?(Hash)
 
-        settings_value(settings_value(response, :meta), :model) || settings_value(response, :model)
+        extract_hash_value(extract_hash_value(response, :meta), :model) || extract_hash_value(response, :model)
       end
 
-      def settings_value(hash, key)
+      def extract_hash_value(hash, key)
         return nil unless hash.respond_to?(:key?)
 
         string_key = key.to_s

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.9.15'
+    VERSION = '0.9.17'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.9.15
+  version: 0.9.17
 platform: ruby
 authors:
 - Esity