legion-llm 0.3.21 → 0.3.23

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b13e641291a41a378dba7a7eca32aaf67c46bc45cb5d459ded5bc3bdab8e0b0
-  data.tar.gz: cc8c372089f5de6518222d608255d65f58968bb97d6eb4f77aac61bb475149d1
+  metadata.gz: 45a5b0befbd5b6ea879f539a30ecb6675f7481e349c115f52ffc2e167c9e7c8d
+  data.tar.gz: 66323d03c6aac956cb0ad78b9bb708cbe7e3c834ede3ab4b34c820e1289f2320
 SHA512:
-  metadata.gz: b8f38cc2091b3f09f55325192cc6d92bda63aeddbdbe1548ebb04e6c68037219d7c1a892e86dd5663ef0334289c7107c2f8326cc30faf218e53dee0c4b19e1b9
-  data.tar.gz: 50c0618742b5006211029aef080fd04c044b20f6b5e33a6bd6d5c070c8971defb3b21bf0f70341ac23900b20f3e80df2071505edf66879519e913a7e95ea1d33
+  metadata.gz: 37ace42f654c110b9e633c53f4999fadd52d447f76145f95bd8ea18a3bcd816ad7ff4b6d3c7270eceaa12ab3b2f4a00f0192066df2a0adc53643d4614f534bb8
+  data.tar.gz: 7c6d639f5f45dbc4c3fccb94e8fece4e933da6037758d8eec3590c35fa15c24f55c19cdc9cc534b848a879d5de585d1c2cef070faa0b3bf354417cef25f86ab7

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Legion LLM Changelog
 
+## [0.3.23] - 2026-03-23
+
+### Added
+- Auto-metering hook: records token usage after every LLM call via gateway MeteringWriter or AMQP transport
+- `Hooks::Metering.install` registers an `after_chat` hook during `LLM.start`
+- Extracts input/output tokens, provider, model, status from response
+- Opt-out via `llm.metering.auto: false` in settings
+- 11 specs covering hook installation, data extraction, availability checks, and edge cases
+
+## [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

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/hooks/metering.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Legion
+  module LLM
+    module Hooks
+      module Metering
+        module_function
+
+        def install
+          Legion::LLM::Hooks.after_chat do |response:, model:, **|
+            record(response, model)
+            nil
+          end
+        end
+
+        def record(response, model)
+          return unless metering_available?
+
+          payload = extract_metering_data(response, model)
+          return if payload[:input_tokens].zero? && payload[:output_tokens].zero?
+
+          publish_metering(payload)
+        rescue StandardError => e
+          Legion::Logging.debug("[LLM::Metering] record failed: #{e.message}") if defined?(Legion::Logging)
+        end
+
+        def extract_metering_data(response, model)
+          usage = extract_usage(response)
+          {
+            provider:      extract_provider(response),
+            model_id:      (extract_model(response) || model).to_s,
+            input_tokens:  usage[:input_tokens],
+            output_tokens: usage[:output_tokens],
+            event_type:    'llm_completion',
+            status:        response.is_a?(Hash) && response[:error] ? 'failure' : 'success'
+          }
+        end
+
+        def extract_usage(response)
+          return { input_tokens: 0, output_tokens: 0 } unless response.is_a?(Hash)
+
+          usage = response[:usage] || {}
+          {
+            input_tokens:  usage[:input_tokens] || usage[:prompt_tokens] || 0,
+            output_tokens: usage[:output_tokens] || usage[:completion_tokens] || 0
+          }
+        end
+
+        def extract_provider(response)
+          return nil unless response.is_a?(Hash)
+
+          response.dig(:meta, :provider) || response[:provider]
+        end
+
+        def extract_model(response)
+          return nil unless response.is_a?(Hash)
+
+          response.dig(:meta, :model) || response[:model]
+        end
+
+        def publish_metering(payload)
+          if gateway_metering?
+            Legion::Extensions::LLM::Gateway::Runners::MeteringWriter.write_metering_record(payload)
+          elsif transport_metering?
+            Legion::Transport.publish(
+              'lex.metering.record',
+              Legion::JSON.dump(payload)
+            )
+          end
+        end
+
+        def gateway_metering?
+          defined?(Legion::Extensions::LLM::Gateway::Runners::MeteringWriter)
+        end
+
+        def transport_metering?
+          defined?(Legion::Transport) &&
+            Legion::Transport.respond_to?(:connected?) &&
+            Legion::Transport.connected?
+        rescue StandardError
+          false
+        end
+
+        def metering_available?
+          gateway_metering? || transport_metering?
+        end
+      end
+    end
+  end
+end

data/lib/legion/llm/hooks.rb

@@ -2,6 +2,7 @@
 
 require 'legion/llm/hooks/rag_guard'
 require 'legion/llm/hooks/response_guard'
+require 'legion/llm/hooks/metering'
 
 module Legion
   module LLM

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/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.3.21'
+    VERSION = '0.3.23'
   end
 end

data/lib/legion/llm.rb

@@ -46,6 +46,8 @@ module Legion
         run_discovery
         set_defaults
 
+        install_hooks
+
         @started = true
         Legion::Settings[:llm][:connected] = true
         Legion::Logging.info 'Legion::LLM started'
@@ -494,6 +496,13 @@ module Legion
         cloud_providers.include?(resolved&.to_sym)
       end
 
+      def install_hooks
+        metering_enabled = settings.dig(:metering, :auto) != false
+        Hooks::Metering.install if metering_enabled
+      rescue StandardError => e
+        Legion::Logging.debug("LLM hook installation failed: #{e.message}") if defined?(Legion::Logging)
+      end
+
       def set_defaults
         default_model    = settings[:default_model]
         default_provider = settings[:default_provider]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.3.21
+  version: 0.3.23
 platform: ruby
 authors:
 - Esity
@@ -145,6 +145,7 @@ files:
 - lib/legion/llm/escalation_history.rb
 - lib/legion/llm/helpers/llm.rb
 - lib/legion/llm/hooks.rb
+- lib/legion/llm/hooks/metering.rb
 - lib/legion/llm/hooks/rag_guard.rb
 - lib/legion/llm/hooks/response_guard.rb
 - lib/legion/llm/off_peak.rb