legion-llm 0.3.20 → 0.3.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19f442b46ed976f59b4f44878bff395fc497dde75bc9b3df8a4471442e0cb3eb
-  data.tar.gz: 590d08bf5499d7a95989ea2a8e098c386a6a4b9eae1e5bcbda89b390f50c20a9
+  metadata.gz: db13bc01a538ce15c213a0ee49dae011b79c0bdf0148ebb940dad6b54cc769c4
+  data.tar.gz: a68d77b17f0eeff3e841620cc43bae9601e9a9069b555ca583b507ab258677db
 SHA512:
-  metadata.gz: 490852eca96d4356949c3dc2a3bfa811c35a539ea47d89f8a12cc5a5098b3709ec03cf83677927378f8f96357af2de88dfbb24ffed68f2268535d3b692c0d1ce
-  data.tar.gz: ae3efe882cde912a9cae6bca01605200027e13f6ff72232f04140bd67f030224600a6a6f4692d221c986e4d4d2228e3c64d1c7bbb50112521f78612f5aad3f46
+  metadata.gz: ab9351b4781dcf146d552f555d0da7eaa444a94d15125af387af33b5ae3741863fccccaafd1fd981faca6e3781589fd6f5a4a273b9a02bf940d389763c55150c
+  data.tar.gz: 4e17454656a9baf87b78a75e99bfe5cc6215a48d1135cc053abab4e85b8b300e3ece10ab5e6628dabbd7a22cbc167d1d3e1d5c63d87da226a8092db6f1ed3b64

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Legion LLM Changelog
 
+## [0.3.22] - 2026-03-23
+
+### Changed
+- `Batch.submit_single` now calls `Legion::LLM.chat_direct` instead of returning a stub response
+- Batch flush returns `status: :completed` on success or `status: :failed` with error on exception
+- `OffPeak` module now delegates to `Scheduling` (consolidated duplicate peak-hour logic)
+- `Scheduling.peak_hours?` and `Scheduling.next_off_peak` accept optional `time` parameter
+
+## [0.3.21] - 2026-03-23
+
+### Added
+- `Legion::LLM::ToolRegistry` thread-safe tool class registry for auto-attaching tools to chat sessions
+- Wire ToolRegistry into `chat_single` so globally registered tools are available in every session
+
+### Fixed
+- Fix `CostTracker.settings_pricing` reading from wrong settings key (`:'legion-llm'` instead of `:llm`)
+- Fix `ShadowEval.evaluate` not passing `messages:` to shadow model (shadow got no context to respond to)
+
 ## [0.3.20] - 2026-03-22
 
 ### Changed

data/lib/legion/llm/batch.rb

@@ -101,13 +101,30 @@ module Legion
         end
 
         def submit_single(entry, provider:, model:)
+          response = Legion::LLM.chat_direct(
+            messages: entry[:messages],
+            model:    model,
+            **entry[:opts]
+          )
+
+          {
+            status:   :completed,
+            model:    model,
+            provider: provider,
+            id:       entry[:id],
+            response: response,
+            meta:     { batched: true, queued_at: entry[:queued_at], completed_at: Time.now.utc }
+          }
+        rescue StandardError => e
+          Legion::Logging.warn("Batch submit_single failed for #{entry[:id]}: #{e.message}") if defined?(Legion::Logging)
           {
-            status:   :batched,
+            status:   :failed,
             model:    model,
             provider: provider,
             id:       entry[:id],
             response: nil,
-            meta:     { batched: true, queued_at: entry[:queued_at] }
+            error:    e.message,
+            meta:     { batched: true, queued_at: entry[:queued_at], failed_at: Time.now.utc }
           }
         end
       end

data/lib/legion/llm/cost_tracker.rb

@@ -84,7 +84,7 @@ module Legion
         def settings_pricing
           return {} unless defined?(Legion::Settings)
 
-          pricing = Legion::Settings.dig(:'legion-llm', :pricing)
+          pricing = Legion::Settings.dig(:llm, :pricing)
           pricing.is_a?(Hash) ? pricing : {}
         rescue StandardError => e
           Legion::Logging.warn("CostTracker settings unavailable: #{e.message}") if defined?(Legion::Logging)

data/lib/legion/llm/off_peak.rb

@@ -1,44 +1,25 @@
 # frozen_string_literal: true
 
+require_relative 'scheduling'
+
 module Legion
   module LLM
+    # Simplified peak-hour interface delegating to Scheduling.
+    # Preserved for backward compatibility.
     module OffPeak
-      # Peak hours in UTC: 14:00-22:00 (9 AM - 5 PM CT)
-      PEAK_HOURS = (14..22)
-
       class << self
-        # Returns true if the given time falls within peak hours.
-        #
-        # @param time [Time] time to check (defaults to now)
-        # @return [Boolean]
         def peak_hour?(time = Time.now.utc)
-          result = PEAK_HOURS.cover?(time.hour)
-          Legion::Logging.debug("OffPeak peak_hour check hour=#{time.hour} peak=#{result}") if defined?(Legion::Logging)
-          result
+          Scheduling.peak_hours?(time)
         end
 
-        # Returns true when a non-urgent request should be deferred to off-peak.
-        #
-        # @param priority [Symbol] :urgent bypasses deferral; :normal and :low defer during peak
-        # @return [Boolean]
         def should_defer?(priority: :normal)
           return false if priority.to_sym == :urgent
 
           peak_hour?
         end
 
-        # Returns the next off-peak Time (UTC).
-        # If already off-peak, returns the current time.
-        # Off-peak begins at the hour after the peak window ends (23:00 UTC).
-        #
-        # @param time [Time] reference time (defaults to now)
-        # @return [Time]
         def next_off_peak(time = Time.now.utc)
-          if time.hour < PEAK_HOURS.first || time.hour >= PEAK_HOURS.last
-            time
-          else
-            Time.utc(time.year, time.month, time.day, PEAK_HOURS.last, 0, 0)
-          end
+          Scheduling.next_off_peak(time)
         end
       end
     end

data/lib/legion/llm/scheduling.rb

@@ -29,9 +29,9 @@ module Legion
           result
         end
 
-        # Returns true if the current UTC hour falls within the configured peak window.
-        def peak_hours?
-          hour = Time.now.utc.hour
+        # Returns true if the given UTC hour falls within the configured peak window.
+        def peak_hours?(time = Time.now.utc)
+          hour = time.is_a?(Time) ? time.hour : Time.now.utc.hour
           peak_range.cover?(hour)
         end
 
@@ -39,19 +39,19 @@ module Legion
         # Off-peak begins at the hour after the peak window ends.
         #
         # @return [Time] next off-peak start time
-        def next_off_peak
-          now = Time.now.utc
+        def next_off_peak(time = Time.now.utc)
+          now = time.is_a?(Time) ? time : Time.now.utc
           peak_end = peak_range.last
           max_defer = settings.fetch(:max_defer_hours, 8)
 
-          next_time = if now.hour < peak_range.first
-                        # Before peak — off-peak is now
-                        now
-                      else
-                        # During or after peak — next off-peak is at peak_end + 1
+          next_time = if peak_hours?(now)
+                        # During peak — next off-peak is at peak_end + 1
                         candidate = Time.utc(now.year, now.month, now.day, peak_end + 1, 0, 0)
                         candidate += 86_400 if candidate <= now
                         candidate
+                      else
+                        # Already off-peak — return now
+                        now
                       end
 
           # Cap at max_defer_hours from now

data/lib/legion/llm/shadow_eval.rb

@@ -15,14 +15,14 @@ module Legion
           rand < rate
         end
 
-        def evaluate(primary_response:, messages: nil, shadow_model: nil) # rubocop:disable Lint/UnusedMethodArgument
+        def evaluate(primary_response:, messages: nil, shadow_model: nil)
           shadow_model ||= Legion::Settings.dig(:llm, :shadow, :model) || 'gpt-4o-mini'
           Legion::Logging.debug("ShadowEval triggered primary_model=#{primary_response[:model]} shadow_model=#{shadow_model}") if defined?(Legion::Logging)
 
           shadow_response = Legion::LLM.send(:chat_single,
                                              model: shadow_model, provider: nil,
-                                             intent: nil, tier: nil,
-                                             skip_shadow: true)
+                                             messages: messages, intent: nil,
+                                             tier: nil)
 
           comparison = compare(primary_response, shadow_response, shadow_model)
           Legion::Events.emit('llm.shadow_eval', comparison) if defined?(Legion::Events)

data/lib/legion/llm/tool_registry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Legion
+  module LLM
+    module ToolRegistry
+      @tools = []
+      @mutex = Mutex.new
+
+      class << self
+        def register(tool_class)
+          @mutex.synchronize do
+            @tools << tool_class unless @tools.include?(tool_class)
+          end
+        end
+
+        def tools
+          @mutex.synchronize { @tools.dup }
+        end
+
+        def clear
+          @mutex.synchronize { @tools.clear }
+        end
+      end
+    end
+  end
+end

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.3.20'
+    VERSION = '0.3.22'
   end
 end

data/lib/legion/llm.rb

@@ -17,6 +17,7 @@ require_relative 'llm/batch'
 require_relative 'llm/scheduling'
 require_relative 'llm/off_peak'
 require_relative 'llm/cost_tracker'
+require_relative 'llm/tool_registry'
 
 begin
   require 'legion/extensions/llm/gateway'
@@ -119,6 +120,9 @@ module Legion
           end
         end
 
+        if defined?(Legion::Logging)
+          Legion::Logging.debug "[LLM] chat_direct escalate=#{escalate} message_present=#{!message.nil?} model=#{model} provider=#{provider}"
+        end
         result = if escalate && message
                    chat_with_escalation(
                      model: model, provider: provider, intent: intent, tier: tier,
@@ -129,6 +133,7 @@ module Legion
                    chat_single(model: model, provider: provider, intent: intent, tier: tier,
                                temperature: temperature, message: message, **kwargs)
                  end
+        Legion::Logging.debug "[LLM] chat_direct result_class=#{result.class} result_nil=#{result.nil?}" if defined?(Legion::Logging)
 
         if cache_key && result.is_a?(Hash)
           ttl = settings.dig(:prompt_caching, :response_cache, :ttl_seconds) || Cache::DEFAULT_TTL
@@ -283,7 +288,11 @@ module Legion
         Legion::Extensions::LLM::Gateway::Runners::Inference.chat(**)
       end
 
-      def chat_single(model:, provider:, intent:, tier:, message: nil, **kwargs)
+      def chat_single(model:, provider:, intent:, tier:, message: nil, **kwargs) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+        explicit_tools = kwargs.delete(:tools)
+        tools = explicit_tools || ToolRegistry.tools
+        tools = nil if tools.empty?
+
         if (intent || tier) && Router.routing_enabled?
           resolution = Router.resolve(intent: intent, tier: tier, model: model, provider: provider)
           if resolution
@@ -307,10 +316,17 @@ module Legion
 
         inject_anthropic_cache_control!(opts, provider)
 
+        if defined?(Legion::Logging)
+          Legion::Logging.debug "[LLM] chat_single model=#{opts[:model]} provider=#{opts[:provider]} message_present=#{!message.nil?} tools=#{tools&.size || 0}"
+        end
         session = RubyLLM.chat(**opts)
+        tools&.each { |tool| session.with_tool(tool) }
         return session unless message
 
-        session.ask(message)
+        Legion::Logging.debug '[LLM] chat_single calling session.ask' if defined?(Legion::Logging)
+        response = session.ask(message)
+        Legion::Logging.debug "[LLM] chat_single response_class=#{response.class} response_nil=#{response.nil?}" if defined?(Legion::Logging)
+        response
       end
 
       def chat_with_escalation(model:, provider:, intent:, tier:, max_escalations:, quality_check:, message:, **kwargs)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.3.20
+  version: 0.3.22
 platform: ruby
 authors:
 - Esity
@@ -161,6 +161,7 @@ files:
 - lib/legion/llm/settings.rb
 - lib/legion/llm/shadow_eval.rb
 - lib/legion/llm/structured_output.rb
+- lib/legion/llm/tool_registry.rb
 - lib/legion/llm/transport/exchanges/escalation.rb
 - lib/legion/llm/transport/messages/escalation_event.rb
 - lib/legion/llm/version.rb