legion-llm 0.14.16 → 0.14.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3eec433896cf314b65ac64111f414a55dc7e9639db3d54cc76359c9fb01ed567
-  data.tar.gz: 659857c6aa71573f6fbb795a655b7a59f2936672b0538db0bc14c18ae06ecfbd
+  metadata.gz: 911fae6cf0899e9ce7ed1fea909e023b411f3437ea0225d263bcc1cb95d6f9b6
+  data.tar.gz: e7f85c4c731a1e5fe8af13dfcc85f4497619256923b6eba39afc2d9e49574863
 SHA512:
-  metadata.gz: 648b2bd80386141477bf5b77b387814f768d5f64447a921d34ef828dde6d9469a15e63211e63c4173e7188e0a61c5d60eb366415ccb68c43c031a23cd4889ac3
-  data.tar.gz: 22f1a949a48470e5a6b543a683e2de4f9c86f44d1c21d706e704bb4a5f58672311ba632b03710647beb071987abed2947e6299e0ad69c06b73c72484398fb238
+  metadata.gz: bd8368de549a561693308531c6a5efd64ba2cbf09ca8f5cc638c76c335944392686a44418204eb5895e9386d388160550b79426c4ed832931c759dec0eee2c4d
+  data.tar.gz: cd03fa5498c7783c3be2a587c3d6ec8543ab203b19ddb3e6e207388107e30ed54b66f08980f7a5c2b9e64147d4c4defe23bbb62ed46ebf33257a96f3ceeae9d8

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Legion LLM Changelog
 
+## [0.14.17] - 2026-07-22
+
+### Added
+- Physical Binning (SSoT v2): Router Range Sieve steers requests to hardware based on workload size
+  - 3-tier priority: specific range match → generalist → full eligible fallback
+  - Boundaries are lower-inclusive, upper-exclusive (`[min, max)`)
+  - Escalation drains each tier naturally via `tried_lanes`
+- Inventory lane enrichment: `preferred_min_context_tokens` / `preferred_max_context_tokens` injected from instance settings
+  - Works for ALL providers automatically (same settings path as instance weights)
+  - Settings path: `settings[:extensions][:llm][provider][:instances][id][:preferred_min/max_context_tokens]`
+
 ## [0.14.16] - 2026-07-14
 
 ### Fixed

data/lib/legion/llm/api/namespaces/anthropic/messages.rb

@@ -95,6 +95,7 @@ module Legion
                   stream:            false,
                   started_at:        request_started_at
                 )
+                set_routing_response_headers(pipeline_response: pipeline_response)
 
                 if canonical_format
                   status_code, response_headers, body_string = Legion::LLM::API::DebugFormats.render_canonical_response(

data/lib/legion/llm/api/namespaces/native/inference.rb

@@ -221,6 +221,7 @@ module Legion
                     tool_calls:        tool_calls,
                     stop_reason:       stop_reason
                   )
+                  set_routing_response_headers(pipeline_response: pipeline_response)
 
                   payload = {
                     request_id:           request_id,

data/lib/legion/llm/api/namespaces/openai/chat/completions.rb

@@ -106,6 +106,7 @@ module Legion
                       stream:            false,
                       started_at:        request_started_at
                     )
+                    set_routing_response_headers(pipeline_response: pipeline_response)
 
                     if canonical_format
                       status_code, response_headers, body_string = Legion::LLM::API::DebugFormats.render_canonical_response(

data/lib/legion/llm/api/namespaces/openai/responses.rb

@@ -104,6 +104,7 @@ module Legion
                     stream:            false,
                     started_at:        request_started_at
                   )
+                  set_routing_response_headers(pipeline_response: pipeline_response)
 
                   if canonical_format
                     status_code, response_headers, body_string = Legion::LLM::API::DebugFormats.render_canonical_response(

data/lib/legion/llm/api/shared_helpers.rb

@@ -211,6 +211,17 @@ module Legion
                           request_id: request_id)
         end
 
+        def set_routing_response_headers(pipeline_response:)
+          routing = pipeline_response.respond_to?(:routing) ? pipeline_response.routing || {} : {}
+          provider_val = api_hash_value(routing, :provider)
+          instance_val = api_hash_value(routing, :instance)
+          model_val = api_hash_value(routing, :model)
+
+          headers 'X-Legion-Provider' => provider_val.to_s if provider_val
+          headers 'X-Legion-Instance' => instance_val.to_s if instance_val
+          headers 'X-Legion-Model' => model_val.to_s if model_val
+        end
+
         def api_duration_ms(started_at)
           return 0 unless started_at
 

data/lib/legion/llm/inference/executor/routing.rb

@@ -204,20 +204,16 @@ module Legion
           # dispatch. Use ContextAccounting (walks canonical structs / content
           # blocks) for messages, estimate the INJECTED system (baseline + RAG +
           # skills + prior-history text), and count client tools. Messages are the
-          # lane-independent-reduced set — what actually goes on the wire.
           def estimate_request_tokens
-            # Mirror the dispatch shape EXACTLY: native_dispatch_messages sends
-            # @request.messages (lane-independent-reduced); the conversation
-            # history lives in the injected SYSTEM (via EnrichmentInjector), not
-            # in the messages array — counting it in both would double-count.
             reduced = reduce_messages_for_dispatch(Array(@request.messages))
 
-            estimated  = ContextAccounting.estimate_message_tokens(reduced)
-            estimated += ContextAccounting.estimate_text_tokens(routing_estimate_injected_system)
-            estimated += ContextAccounting.estimate_json_tokens(routing_estimate_tool_defs)
-            estimated += ContextAccounting.estimate_json_tokens(@request.tool_choice) if @request.tool_choice
-            estimated += ContextAccounting.estimate_json_tokens(@request.thinking) if @request.thinking.is_a?(Hash) && @request.thinking.any?
-            estimated
+            msg_tokens = ContextAccounting.estimate_message_tokens(reduced)
+            sys_tokens = ContextAccounting.estimate_text_tokens(routing_estimate_injected_system)
+            tool_tokens = ContextAccounting.estimate_json_tokens(routing_estimate_tool_defs)
+            choice_tokens = @request.tool_choice ? ContextAccounting.estimate_json_tokens(@request.tool_choice) : 0
+            thinking_tokens = @request.thinking.is_a?(Hash) && @request.thinking.any? ? ContextAccounting.estimate_json_tokens(@request.thinking) : 0
+
+            msg_tokens + sys_tokens + tool_tokens + choice_tokens + thinking_tokens
           end
 
           # The system prompt as it will be dispatched — baseline + GAIA + prior
@@ -227,17 +223,10 @@ module Legion
             EnrichmentInjector.inject(system: @request.system, enrichments: @enrichments || {})
           end
 
-          # The tool catalog dispatch will send (special + client + registry), NOT
-          # just @request.tools — the dispatch guard counts native_dispatch_tools,
-          # so routing must too or a heavy-tool request under-counts and picks a
-          # too-small lane. Built read-only here (never memoized) because
-          # native_tool_definitions caches and applies the local-provider cap
-          # against @resolved_provider, which is not set at routing time; an
-          # uncapped over-estimate is the safe direction for a "will it fit" filter.
           def routing_estimate_tool_defs
             defs = Tools::Special.pinned_definitions.map(&:to_h)
             Array(@request.tools).each { |t| defs << (t.respond_to?(:to_h) ? t.to_h : t) }
-            Legion::Settings::Extensions.filter_tools(deferred: false).each { |e| defs << e } if registry_tool_injection_requested?
+            Array(@discovered_tools).each { |t| defs << (t.respond_to?(:to_h) ? t.to_h : t) }
             defs
           rescue StandardError => e
             handle_exception(e, level: :warn, handled: true, operation: 'llm.pipeline.routing_estimate_tool_defs')

data/lib/legion/llm/inventory.rb

@@ -25,6 +25,8 @@ module Legion
           validate_lane!(lane: lane)
           return policy_skip(lane: lane) if policy_denied?(lane: lane)
 
+          lane = enrich_lane_range(lane: lane)
+
           existing = live_map[lane[:id]]
           resolved_health = if health == :preserve
                               existing&.dig(:health) || default_health
@@ -180,6 +182,26 @@ module Legion
           (base * health_mult).to_i
         end
 
+        def enrich_lane_range(lane:)
+          provider_settings = Legion::Settings.dig(:extensions, :llm, lane[:provider_family].to_sym)
+          return lane unless provider_settings.is_a?(Hash)
+
+          instances = provider_settings[:instances]
+          return lane unless instances.is_a?(Hash)
+
+          inst_cfg = instances[lane[:instance_id]] || instances[lane[:instance_id]&.to_sym]
+          return lane unless inst_cfg.is_a?(Hash)
+
+          min_val = inst_cfg[:preferred_min_context_tokens]
+          max_val = inst_cfg[:preferred_max_context_tokens]
+          return lane if min_val.nil? && max_val.nil?
+
+          enriched = lane.dup
+          enriched[:preferred_min_context_tokens] = min_val if min_val
+          enriched[:preferred_max_context_tokens] = max_val if max_val
+          enriched
+        end
+
         def lane_weights_from_settings(lane:)
           tier_weights    = Legion::Settings.dig(:llm, :routing, :tier_weights) || {}
           provider_sym    = lane[:provider_family].to_sym

data/lib/legion/llm/router.rb

@@ -76,7 +76,9 @@ module Legion
 
           return nil if eligible.empty?
 
-          eligible
+          pool = range_sieve(eligible: eligible, estimated_context: estimated_context)
+
+          pool
             .group_by { |lane| lane[:lane_weight] }
             .max_by { |weight, _| weight }
             .last
@@ -190,6 +192,30 @@ module Legion
 
         private
 
+        def range_sieve(eligible:, estimated_context:)
+          return eligible if estimated_context.nil?
+
+          specific, generalist = eligible.partition { |lane| lane_has_range?(lane) }
+          matched = specific.select { |lane| lane_in_range?(lane: lane, estimated_context: estimated_context) }
+
+          return matched unless matched.empty?
+          return generalist unless generalist.empty?
+
+          eligible
+        end
+
+        def lane_has_range?(lane)
+          !lane[:preferred_min_context_tokens].nil? || !lane[:preferred_max_context_tokens].nil?
+        end
+
+        def lane_in_range?(lane:, estimated_context:)
+          lower = (lane[:preferred_min_context_tokens] || 0).to_i
+          upper = lane[:preferred_max_context_tokens]
+          upper = upper ? upper.to_i : Float::INFINITY
+
+          estimated_context >= lower && estimated_context < upper
+        end
+
         def lane_passes_hard_filters?(lane:, type:, tiers:, providers:, instances:, models:,
                                       capabilities:, thinking:, privacy:, estimated_context:, **)
           return false if lane[:type] != type

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.14.16'
+    VERSION = '0.14.17'
   end
 end

metadata

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