legion-llm 0.9.15 → 0.9.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 206afbe8609bb8ed7df111d216967aafba55b0d523d5939aad024f169e43f5ef
-  data.tar.gz: 283f42c3d5b9ba07aa7857aad3e6d1f30b7559f35282f4a1d00986ea4ab2c646
+  metadata.gz: 4743dd41922fbca3818f72bb48d353314ed2895ce0981e779ac29315c8ffea3b
+  data.tar.gz: a235df9596b11ddfd94ef5f075a9785f4bce0ae9c849db8b0b5845bde83af4ac
 SHA512:
-  metadata.gz: 54b3e821013f9ba6f73019907821e85d1aaacc766e8942767f5e6a9630d66757c1d16a8e1b6643054895b1e5de229245e45ebf562f42bdec1cfac8f609024a5c
-  data.tar.gz: 45d349d01bef14e68527aa0c8108c4d08f71e05b63c87c331e377703bdacfcee431b903fe72dc2ad48b10c2f73a67523e9c67a0da1dd46b4b9cf3e041c290671
+  metadata.gz: 1c02e4859ef4bd824e854275fcbb1eadfe243b13477c9af9a9f2f3c484579eefa10bc70d0b1735c85b433b476ca9a8dd69b5fa788cdeafc651dcc370f71cfc40
+  data.tar.gz: 9f3ae0f1adba6bbe56653f0afce38c0eaa0dd4121b02279f5d9053be84682774f07401e346a855320c1bc006929d8ca184c88896098cd52697869c9b8d9f4630

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Legion LLM Changelog
 
+## [0.9.19] - 2026-05-11
+
+### Added
+- `GET /api/llm/tiers` — full RESTful tier hierarchy endpoint with sub-routes: `/:tier`, `/:tier/providers`, `/:tier/providers/:provider`, `/:tier/providers/:provider/instances`, `/:tier/providers/:provider/instances/:instance`, `/:tier/providers/:provider/instances/:instance/models`, `/:tier/providers/:provider/models`. Returns tier availability, provider health, instance details, and model listings in a structured tree.
+- `POST /api/llm/inference` now accepts `tier` parameter in request body, passed through to the routing pipeline via `Request.extra[:tier]`. Supports values: `local`, `fleet`, `openai_compat`, `cloud`, `frontier`.
+- Request log for `/api/llm/inference` now includes `requested_tier` field.
+
+### Changed
+- `GET /api/llm/offerings` response restructured from flat array to grouped hash: `tier → provider → instance → [offerings]`. Individual offering lookup (`GET /api/llm/offerings/:id`) unchanged.
+
+## [0.9.18] - 2026-05-11
+
+### Fixed
+- `NativeResponseAdapter` now coerces tool_calls from the Hash-keyed-by-name format (returned by OpenAI-compatible providers via lex-llm) into a flat Array of Hashes, preventing TypeError crashes in `step_tool_calls`, `response_tool_calls`, and the native tool loop when streaming tool-use responses from vllm/ollama.
+- `LexLLMAdapter#normalize_messages` merges enriched system content with an existing system message at index 0 instead of prepending a duplicate, preventing vllm "System message must be at the beginning" rejections during gaia narrator ticks.
+
+## [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/api/native/inference.rb

@@ -23,6 +23,7 @@ module Legion
               requested_tools = body[:requested_tools] || []
               model           = body[:model]
               provider        = body[:provider]
+              tier            = body[:tier]
               caller_context  = body[:caller]
               conversation_id = body[:conversation_id]
               request_id      = body[:request_id] || SecureRandom.uuid
@@ -88,12 +89,16 @@ module Legion
                 "[llm][api][inference] action=accepted request_id=#{request_id} " \
                 "conversation_id=#{conversation_id || 'none'} caller=#{caller_summary} " \
                 "messages=#{messages.size} client_tools=#{tools.size} requested_tools=#{Array(requested_tools).size} " \
-                "requested_provider=#{provider || 'auto'} requested_model=#{model || 'auto'} stream=#{streaming}"
+                "requested_tier=#{tier || 'auto'} requested_provider=#{provider || 'auto'} " \
+                "requested_model=#{model || 'auto'} stream=#{streaming}"
               )
 
               require 'legion/llm/inference/request' unless defined?(Legion::LLM::Inference::Request)
               require 'legion/llm/inference/executor' unless defined?(Legion::LLM::Inference::Executor)
 
+              extra = {}
+              extra[:tier] = tier.to_sym if tier
+
               pipeline_request = Legion::LLM::Inference::Request.build(
                 id:              request_id,
                 messages:        messages,
@@ -104,7 +109,8 @@ module Legion
                 conversation_id: conversation_id,
                 metadata:        { requested_tools: requested_tools },
                 stream:          streaming,
-                cache:           { strategy: :default, cacheable: true }
+                cache:           { strategy: :default, cacheable: true },
+                extra:           extra
               )
 
               setup_ms = ((::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - route_t0) * 1000).round

data/lib/legion/llm/api/native/offerings.rb

@@ -17,11 +17,12 @@ module Legion
               require_llm!
 
               filters = Legion::LLM::API::Native::Offerings.request_filters(params)
-              offerings = Legion::LLM::Inventory.offerings(filters)
+              raw_offerings = Legion::LLM::Inventory.offerings(filters)
+              grouped = Legion::LLM::API::Native::Offerings.group_offerings(raw_offerings)
 
               json_response({
-                              offerings: offerings,
-                              summary:   Legion::LLM::API::Native::Offerings.summary(offerings, filters)
+                              offerings: grouped,
+                              summary:   Legion::LLM::API::Native::Offerings.summary(raw_offerings)
                             })
             rescue StandardError => e
               handle_exception(e, level: :error, handled: true, operation: 'llm.api.offerings.list')
@@ -59,15 +60,46 @@ module Legion
             }
           end
 
-          def self.summary(offerings, filters)
+          def self.group_offerings(offerings)
+            grouped = {}
+
+            offerings.each do |offering|
+              tier = (offering[:tier] || :unknown).to_s
+              provider = (offering[:provider_family] || :unknown).to_s
+              instance = (offering[:instance_id] || offering[:provider_instance] || :default).to_s
+
+              grouped[tier] ||= {}
+              grouped[tier][provider] ||= {}
+              grouped[tier][provider][instance] ||= []
+              grouped[tier][provider][instance] << compact_offering(offering)
+            end
+
+            grouped
+          end
+
+          def self.compact_offering(offering)
             {
-              total:     offerings.size,
-              operation: filters[:type]&.to_s,
-              models:    offerings.map { |offering| offering[:model] }.uniq.size,
-              providers: offerings.map { |offering| offering[:provider_family] }.uniq.size,
-              instances: offerings.map { |offering| offering[:instance_id] }.uniq.size
+              id:           offering[:offering_id] || offering[:id],
+              model:        offering[:model].to_s,
+              type:         offering[:type].to_s,
+              model_family: offering[:model_family]&.to_s,
+              capabilities: Array(offering[:capabilities]).map(&:to_s),
+              limits:       offering[:limits] || {},
+              enabled:      offering[:enabled] != false,
+              cost:         offering[:cost] || {},
+              health:       offering[:health] || {}
             }.compact
           end
+
+          def self.summary(offerings)
+            {
+              total:     offerings.size,
+              tiers:     offerings.map { |o| (o[:tier] || :unknown).to_s }.uniq.size,
+              providers: offerings.map { |o| (o[:provider_family] || :unknown).to_s }.uniq.size,
+              instances: offerings.map { |o| (o[:instance_id] || :default).to_s }.uniq.size,
+              models:    offerings.map { |o| o[:model] }.uniq.size
+            }
+          end
         end
       end
     end

data/lib/legion/llm/api/native/tiers.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require 'legion/logging/helper'
+
+module Legion
+  module LLM
+    module API
+      module Native
+        module Tiers
+          extend Legion::Logging::Helper
+
+          def self.registered(app) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
+            log.debug('[llm][api][tiers] registering tier routes')
+
+            app.get '/api/llm/tiers' do
+              require_llm!
+
+              tiers_data = Legion::LLM::API::Native::Tiers.build_tiers_tree
+              json_response({
+                              tiers:        tiers_data,
+                              priority:     Legion::LLM::API::Native::Tiers.tier_priority,
+                              privacy_mode: Legion::LLM::API::Native::Tiers.privacy_mode?
+                            })
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'llm.api.tiers.list')
+              json_error('tiers_error', e.message, status_code: 500)
+            end
+
+            app.get '/api/llm/tiers/:tier' do
+              require_llm!
+
+              tier_name = params[:tier].to_s
+              tiers_data = Legion::LLM::API::Native::Tiers.build_tiers_tree
+              tier = tiers_data[tier_name]
+              halt json_error('tier_not_found', "Tier '#{tier_name}' not found", status_code: 404) unless tier
+
+              json_response({ tier: tier_name, **tier })
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'llm.api.tiers.get')
+              json_error('tiers_error', e.message, status_code: 500)
+            end
+
+            app.get '/api/llm/tiers/:tier/providers' do
+              require_llm!
+
+              tier_name = params[:tier].to_s
+              tiers_data = Legion::LLM::API::Native::Tiers.build_tiers_tree
+              tier = tiers_data[tier_name]
+              halt json_error('tier_not_found', "Tier '#{tier_name}' not found", status_code: 404) unless tier
+
+              json_response({ tier: tier_name, providers: tier[:providers] })
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'llm.api.tiers.providers')
+              json_error('tiers_error', e.message, status_code: 500)
+            end
+
+            app.get '/api/llm/tiers/:tier/providers/:provider' do
+              require_llm!
+
+              tier_name = params[:tier].to_s
+              provider_name = params[:provider].to_s
+              tiers_data = Legion::LLM::API::Native::Tiers.build_tiers_tree
+              tier = tiers_data[tier_name]
+              halt json_error('tier_not_found', "Tier '#{tier_name}' not found", status_code: 404) unless tier
+
+              provider = tier.dig(:providers, provider_name)
+              halt json_error('provider_not_found', "Provider '#{provider_name}' not found in tier '#{tier_name}'", status_code: 404) unless provider
+
+              json_response({ tier: tier_name, provider: provider_name, **provider })
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'llm.api.tiers.provider')
+              json_error('tiers_error', e.message, status_code: 500)
+            end
+
+            app.get '/api/llm/tiers/:tier/providers/:provider/instances' do
+              require_llm!
+
+              tier_name = params[:tier].to_s
+              provider_name = params[:provider].to_s
+              tiers_data = Legion::LLM::API::Native::Tiers.build_tiers_tree
+              tier = tiers_data[tier_name]
+              halt json_error('tier_not_found', "Tier '#{tier_name}' not found", status_code: 404) unless tier
+
+              provider = tier.dig(:providers, provider_name)
+              halt json_error('provider_not_found', "Provider '#{provider_name}' not found in tier '#{tier_name}'", status_code: 404) unless provider
+
+              json_response({ tier: tier_name, provider: provider_name, instances: provider[:instances] })
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'llm.api.tiers.instances')
+              json_error('tiers_error', e.message, status_code: 500)
+            end
+
+            app.get '/api/llm/tiers/:tier/providers/:provider/instances/:instance' do
+              require_llm!
+
+              tier_name = params[:tier].to_s
+              provider_name = params[:provider].to_s
+              instance_name = params[:instance].to_s
+              tiers_data = Legion::LLM::API::Native::Tiers.build_tiers_tree
+              tier = tiers_data[tier_name]
+              halt json_error('tier_not_found', "Tier '#{tier_name}' not found", status_code: 404) unless tier
+
+              provider = tier.dig(:providers, provider_name)
+              halt json_error('provider_not_found', "Provider '#{provider_name}' not found in tier '#{tier_name}'", status_code: 404) unless provider
+
+              instance = provider.dig(:instances, instance_name)
+              halt json_error('instance_not_found', "Instance '#{instance_name}' not found", status_code: 404) unless instance
+
+              json_response({ tier: tier_name, provider: provider_name, instance: instance_name, **instance })
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'llm.api.tiers.instance')
+              json_error('tiers_error', e.message, status_code: 500)
+            end
+
+            app.get '/api/llm/tiers/:tier/providers/:provider/instances/:instance/models' do
+              require_llm!
+
+              tier_name = params[:tier].to_s
+              provider_name = params[:provider].to_s
+              instance_name = params[:instance].to_s
+              tiers_data = Legion::LLM::API::Native::Tiers.build_tiers_tree
+              tier = tiers_data[tier_name]
+              halt json_error('tier_not_found', "Tier '#{tier_name}' not found", status_code: 404) unless tier
+
+              provider = tier.dig(:providers, provider_name)
+              halt json_error('provider_not_found', "Provider '#{provider_name}' not found in tier '#{tier_name}'", status_code: 404) unless provider
+
+              instance = provider.dig(:instances, instance_name)
+              halt json_error('instance_not_found', "Instance '#{instance_name}' not found", status_code: 404) unless instance
+
+              json_response({ tier: tier_name, provider: provider_name, instance: instance_name, models: instance[:models] })
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'llm.api.tiers.instance_models')
+              json_error('tiers_error', e.message, status_code: 500)
+            end
+
+            app.get '/api/llm/tiers/:tier/providers/:provider/models' do
+              require_llm!
+
+              tier_name = params[:tier].to_s
+              provider_name = params[:provider].to_s
+              tiers_data = Legion::LLM::API::Native::Tiers.build_tiers_tree
+              tier = tiers_data[tier_name]
+              halt json_error('tier_not_found', "Tier '#{tier_name}' not found", status_code: 404) unless tier
+
+              provider = tier.dig(:providers, provider_name)
+              halt json_error('provider_not_found', "Provider '#{provider_name}' not found in tier '#{tier_name}'", status_code: 404) unless provider
+
+              all_models = provider[:instances].values.flat_map { |inst| inst[:models] }
+              seen = {}
+              unique_models = all_models.select { |m| seen[m[:id]] ? false : (seen[m[:id]] = true) }
+
+              json_response({ tier: tier_name, provider: provider_name, models: unique_models })
+            rescue StandardError => e
+              handle_exception(e, level: :error, handled: true, operation: 'llm.api.tiers.provider_models')
+              json_error('tiers_error', e.message, status_code: 500)
+            end
+
+            log.debug('[llm][api][tiers] tier routes registered')
+          end
+
+          def self.tier_priority
+            routing_config = Legion::LLM::Settings.value(:routing) || {}
+            Array(routing_config[:tier_priority] || %w[local fleet openai_compat cloud frontier])
+          end
+
+          def self.privacy_mode?
+            return false unless defined?(Legion::LLM::Router)
+
+            Legion::LLM::Router.respond_to?(:privacy_mode?) && Legion::LLM::Router.privacy_mode?
+          end
+
+          def self.tier_available?(tier_sym)
+            return true unless defined?(Legion::LLM::Router) && Legion::LLM::Router.respond_to?(:tier_available?)
+
+            Legion::LLM::Router.tier_available?(tier_sym)
+          end
+
+          def self.build_tiers_tree
+            offerings = Legion::LLM::Inventory.offerings({})
+            grouped = {}
+
+            offerings.each do |offering|
+              tier_name = (offering[:tier] || :unknown).to_s
+              provider_name = (offering[:provider_family] || :unknown).to_s
+              instance_name = (offering[:instance_id] || offering[:provider_instance] || :default).to_s
+
+              grouped[tier_name] ||= { available: tier_available?(tier_name.to_sym), providers: {} }
+              grouped[tier_name][:providers][provider_name] ||= { instances: {} }
+              grouped[tier_name][:providers][provider_name][:instances][instance_name] ||= {
+                health:       offering_instance_health(provider_name, instance_name),
+                capabilities: [],
+                models:       []
+              }
+
+              inst = grouped[tier_name][:providers][provider_name][:instances][instance_name]
+              inst[:capabilities] = (inst[:capabilities] + Array(offering[:capabilities])).uniq.sort
+              inst[:models] << build_model_entry(offering)
+            end
+
+            # Sort tiers by priority order
+            priority = tier_priority
+            sorted = {}
+            priority.each { |t| sorted[t] = grouped.delete(t) if grouped.key?(t) }
+            grouped.each { |t, v| sorted[t] = v }
+
+            # Ensure all priority tiers appear even if empty
+            priority.each do |t|
+              sorted[t] ||= { available: tier_available?(t.to_sym), providers: {} }
+            end
+
+            sorted
+          end
+
+          def self.build_model_entry(offering)
+            {
+              id:           offering[:model].to_s,
+              offering_id:  offering[:offering_id] || offering[:id],
+              type:         offering[:type].to_s,
+              capabilities: Array(offering[:capabilities]).map(&:to_s),
+              limits:       offering[:limits] || {},
+              enabled:      offering[:enabled] != false,
+              cost:         offering[:cost] || {},
+              model_family: offering[:model_family]&.to_s
+            }.compact
+          end
+
+          def self.offering_instance_health(provider_name, instance_name)
+            return 'unknown' unless defined?(Legion::LLM::Router) && Legion::LLM::Router.respond_to?(:health_tracker)
+
+            tracker = Legion::LLM::Router.health_tracker
+            return 'unknown' unless tracker
+
+            tracker.circuit_state(provider_name.to_sym, instance: instance_name.to_sym).to_s
+          rescue StandardError
+            'unknown'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/llm/api.rb

@@ -9,6 +9,7 @@ require_relative 'api/native/models'
 require_relative 'api/native/offerings'
 require_relative 'api/native/instances'
 require_relative 'api/native/routing'
+require_relative 'api/native/tiers'
 require_relative 'api/translators/openai_request'
 require_relative 'api/translators/openai_response'
 require_relative 'api/openai/chat_completions'
@@ -36,6 +37,7 @@ module Legion
         Native::Offerings.registered(app)
         Native::Instances.registered(app)
         Native::Routing.registered(app)
+        Native::Tiers.registered(app)
         OpenAI::ChatCompletions.registered(app)
         OpenAI::Models.registered(app)
         OpenAI::Embeddings.registered(app)

data/lib/legion/llm/call/dispatch.rb

@@ -2,11 +2,7 @@
 
 require 'legion/logging/helper'
 
-begin
-  require 'legion/extensions/llm/responses/thinking_extractor'
-rescue LoadError
-  nil
-end
+require 'legion/extensions/llm/responses/thinking_extractor'
 
 module Legion
   module LLM
@@ -37,7 +33,7 @@ module Legion
           @content             = extracted[:result].to_s
           @model               = result_hash[:model]
           @metadata            = extracted[:metadata] || {}
-          @tool_calls          = result_hash[:tool_calls] || []
+          @tool_calls          = self.class.coerce_tool_calls(result_hash[:tool_calls])
           @stop_reason         = result_hash[:stop_reason]
           @thinking            = extracted[:thinking]
           usage                = self.class.coerce_usage(result_hash[:usage])
@@ -73,7 +69,7 @@ module Legion
               cache_write_tokens: raw.respond_to?(:cache_creation_tokens) ? raw.cache_creation_tokens.to_i : 0
             ),
             metadata:    raw.respond_to?(:metadata) && raw.metadata.is_a?(Hash) ? raw.metadata : {},
-            tool_calls:  raw.respond_to?(:tool_calls) ? raw.tool_calls : [],
+            tool_calls:  raw.respond_to?(:tool_calls) ? coerce_tool_calls(raw.tool_calls) : [],
             stop_reason: raw.respond_to?(:stop_reason) ? raw.stop_reason : nil,
             thinking:    raw.respond_to?(:thinking) ? raw.thinking : nil
           }.compact
@@ -107,6 +103,29 @@ module Legion
           )
         end
 
+        def self.coerce_tool_calls(raw)
+          return [] if raw.nil?
+          return raw if raw.is_a?(Array)
+
+          return raw.values.filter_map { |entry| coerce_single_tool_call(entry) } if raw.is_a?(Hash) && !single_tool_call_hash?(raw)
+
+          [coerce_single_tool_call(raw)].compact
+        end
+
+        def self.single_tool_call_hash?(hash)
+          hash.key?(:name) || hash.key?('name') || hash.key?(:function) || hash.key?('function')
+        end
+
+        def self.coerce_single_tool_call(entry)
+          if entry.respond_to?(:id) && entry.respond_to?(:name)
+            return { id: entry.id, name: entry.name, arguments: entry.respond_to?(:arguments) ? entry.arguments : {} }
+          end
+
+          return entry if entry.is_a?(Hash)
+
+          nil
+        end
+
         def self.merge_thinking_payloads(existing, extracted)
           return existing || extracted unless existing && extracted
 

data/lib/legion/llm/call/lex_llm_adapter.rb

@@ -150,7 +150,7 @@ module Legion
         def normalize_messages(messages, system: nil)
           message_class = lex_llm_namespace::Message
           raw_messages = Array(messages)
-          raw_messages = [{ role: :system, content: system }] + raw_messages if present_system?(system)
+          raw_messages = prepend_or_merge_system(raw_messages, system) if present_system?(system)
 
           raw_messages.map do |message|
             next message if message.is_a?(message_class)
@@ -165,6 +165,22 @@ module Legion
           end
         end
 
+        def prepend_or_merge_system(raw_messages, system)
+          first = raw_messages.first
+          first_role = if first.is_a?(Hash)
+                         first[:role] || first['role']
+                       elsif first.respond_to?(:role)
+                         first.role
+                       end
+          if first_role.to_s == 'system'
+            existing_content = first.is_a?(Hash) ? (first[:content] || first['content']) : first.content
+            merged = { role: :system, content: "#{system}\n\n#{existing_content}" }
+            [merged] + raw_messages[1..]
+          else
+            [{ role: :system, content: system }] + raw_messages
+          end
+        end
+
         def present_system?(system)
           return false if system.nil?
           return false if system.respond_to?(:empty?) && system.empty?

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.19'
   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.19
 platform: ruby
 authors:
 - Esity
@@ -200,6 +200,7 @@ files:
 - lib/legion/llm/api/native/offerings.rb
 - lib/legion/llm/api/native/providers.rb
 - lib/legion/llm/api/native/routing.rb
+- lib/legion/llm/api/native/tiers.rb
 - lib/legion/llm/api/openai/chat_completions.rb
 - lib/legion/llm/api/openai/embeddings.rb
 - lib/legion/llm/api/openai/models.rb