legion-llm 0.14.4 → 0.14.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 433b9bf3832cc3c6fcb25ab53d135306475b4147a242af49a3df5fe52eab9946
-  data.tar.gz: 94873f17f47ef2c08cab12e8ad6de884af7bb108bdb7967cf30df5b32c21234e
+  metadata.gz: f67a1a83e7213a2e50437b07e71afd74302c2b1da8229708ec8d99506d45354e
+  data.tar.gz: fa1dcc7ae0d4b64dd2716271dd5c50778ff178fa3987704b16302c00b75029ab
 SHA512:
-  metadata.gz: 8c96394a77c183d9441d3b56461c0d1303dc93823e2ca87bb68e8e21e6903a484fc36e7242ef297ea9312e4de9d36ec5abfcbd36a8b7966566d98d123ed85085
-  data.tar.gz: b3bb6181d62ef27e6c812d34f3c9efc6b540e041025324e92fe7d199cfe28f3a619baa20a4dd5bde1eea7153afa0420d98332bcf96c941923e0d15afe563c722
+  metadata.gz: b3c1802c7bc32daa15d15c0fc8b16923d8fac48531adc5bcfb2997eec6234534166b85c43e9262774dedb63e28a7a62c148614bdac53e00c15fe44598770823b
+  data.tar.gz: cc6ae96b0bfc1e1e54298b028334d1bd1f19e18147ac0d7a7d61bb849c86e157ff26b986082be3027ba4199570481d91b960ce6eb1d82b2ec5aa66d787d3a9b7

data/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Legion LLM Changelog
 
+## [0.14.9] - 2026-06-25
+
+### Fixed
+
+- Routing token estimate (`estimate_request_tokens`) now includes system prompt, tool definitions, and thinking config — matching what `enforce_final_context_budget!` checks at dispatch time. Previously only counted messages, causing large-context requests (e.g. Copilot Chat with 81 tools + system prompt) to route to small-context models and fail with ContextOverflow at dispatch.
+- `resolve_routing_state` always consults `request_lane` when Inventory has lanes, removing the gate that required explicit routing flags. Enables weight-based lane selection for all callers including `Legion::LLM.chat`.
+
+### Added
+
+- `:subcall` profile in `Inference::Profile` — skips all pipeline steps except routing, provider_call, and metering. Used for in-pipeline LLM sub-calls (debate, lex-knowledge, lex-apollo) to avoid recursive full-pipeline execution.
+- `Executor.new(request, skip_pipeline: true)` kwarg forces `:subcall` profile without requiring caller identity manipulation.
+- `dispatch_chat` unified path — builds a `Request` via `from_chat_args` and runs the Executor directly, detecting in-pipeline context via `Thread.current[:legion_llm_in_pipeline]`.
+
+## [0.14.8] - 2026-06-25
+
+### Fixed
+
+- Responses translator (`format_response`) no longer emits a message item with empty `output_text` when the response is pure tool_use (function_call items present). The empty text triggered Codex's `[Your previous response had no visible output]` injection on every tool turn.
+
+## [0.14.7] - 2026-06-25
+
+### Fixed
+
+- `step_context_store` stores `typed_msg.text` (extracted string) instead of `typed_msg.content` (raw Array), preventing ContentBlock objects from being serialized as `#inspect` strings in conversation history.
+- `Types::Message#text_from_block` recognizes `output_text`/`input_text` content block types so token estimation and text extraction work for Responses API content.
+- `lex_llm_adapter.rb` `text_part_content` Data struct branch handles `output_text`/`input_text` types (previously only matched `type == 'text'`).
+- `context_window.rb` `compact_to_fit` loops halving until messages fit the target token budget instead of a single halve that leaves payloads 2x over threshold for very large conversations.
+- `emit_non_pipeline_metering` reads tokens from `response.usage.input_tokens` (correct) instead of `response.input_tokens` (non-existent on Canonical::Response), fixing zero-token metering for internal extension LLM calls (lex-apollo, legion-gaia, lex-knowledge, etc.).
+- `emit_non_pipeline_metering` reads `response.metadata` instead of `response.meta`, passes `messages` and `response_content` to metering events.
+
+## [0.14.5] - 2026-06-24
+
+### Fixed
+
+- Non-pipeline metering (`emit_non_pipeline_metering`) now correctly reads token counts from `response.usage` instead of the non-existent top-level `input_tokens`/`output_tokens` on `Canonical::Response`. Previously all internal LLM calls (via `Legion::LLM.structured`, `chat_single_native`) emitted zero-token metering events.
+- Non-pipeline metering now includes `messages` and `response_content` fields, fixing null request/response JSON columns in the ledger for internal extension calls (lex-apollo, lex-agentic-self, legion-gaia, etc.).
+- Non-pipeline metering reads `response.metadata` (correct field) instead of `response.meta` (does not exist on `Canonical::Response`) for latency/timing extraction.
+
 ## [0.14.4] - 2026-06-23
 
 ### Fixed

data/legion-llm.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-settings', '>= 1.4.0'
   spec.add_dependency 'legion-transport', '>= 1.4.14'
   spec.add_dependency 'lex-knowledge'
-  spec.add_dependency 'lex-llm', '>= 0.6.0'
+  spec.add_dependency 'lex-llm', '>= 0.6.3'
   spec.add_dependency 'pdf-reader'
   spec.add_dependency 'sinatra-contrib', '>= 2.0'
   spec.add_dependency 'tzinfo', '>= 2.0'

data/lib/legion/llm/api/client_translators/openai_responses.rb

@@ -151,18 +151,16 @@ module Legion
             server_tool_items = build_output_server_tool_items(pipeline_response)
             reasoning = build_output_reasoning(pipeline_response)
 
-            output = [
-              *reasoning,
-              *server_tool_items,
-              *actionable_tool_calls,
-              {
+            output = [*reasoning, *server_tool_items, *actionable_tool_calls]
+            unless content.to_s.strip.empty? && (actionable_tool_calls.any? || server_tool_items.any?)
+              output << {
                 type:    'message',
                 id:      "msg_#{SecureRandom.hex(12)}",
                 role:    'assistant',
                 content: [{ type: 'output_text', text: content }],
                 status:  'completed'
               }
-            ]
+            end
 
             # Responses protocol: a turn is always status `completed`. Both
             # client-callable calls (actionable_tool_calls) and LegionIO-run

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

@@ -753,7 +753,7 @@ module Legion
           if part.respond_to?(:type) || part.respond_to?(:text)
             type = (part.respond_to?(:type) ? part.type.to_s : '')
             text = part.respond_to?(:text) ? part.text : nil
-            return text.to_s if type == 'text' || (type.empty? && !text.nil?)
+            return text.to_s if %w[text output_text input_text].include?(type) || (type.empty? && !text.nil?)
 
             return nil
           end

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

@@ -83,8 +83,8 @@ module Legion
 
             return messages if estimate_message_tokens(messages) <= target_tokens
 
-            half = messages.size / 2
-            messages.last(half)
+            messages = messages.last(messages.size / 2) while messages.size > 2 && estimate_message_tokens(messages) > target_tokens
+            messages
           end
 
           def resolved_context_window

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

@@ -199,14 +199,15 @@ module Legion
           end
 
           def estimate_request_tokens
-            # Estimate total tokens from current request messages + conversation history.
-            # This is used by the router to exclude models whose context window can't fit.
             all_messages = []
             all_messages.concat(@enrichments['context:conversation_history'] || [])
             all_messages.concat(@request.messages || [])
-            return 0 if all_messages.empty?
 
-            estimate_message_tokens(all_messages)
+            estimated = all_messages.empty? ? 0 : estimate_message_tokens(all_messages)
+            estimated += ((@request.system || '').length / 4.0).ceil
+            estimated += estimate_tool_token_budget if @request.tools&.any?
+            estimated += (Legion::JSON.dump(@request.thinking).length / 3.5).ceil if @request.thinking.is_a?(Hash) && @request.thinking.any?
+            estimated
           end
 
           def chain_required_capabilities
@@ -367,11 +368,7 @@ module Legion
 
           def resolve_routing_state(state)
             return state unless defined?(Router)
-
-            explicit_route = state[:provider_explicit] || state[:instance_explicit] || state[:tier_explicit]
-            auto_route = state[:auto_route] == true
-            intent_route = state[:intent_explicit] && state[:intent] && Router.routing_enabled?
-            return state unless explicit_route || auto_route || intent_route
+            return state unless Legion::LLM::Inventory.lanes.any?
 
             resolution = routing_resolution_for(state)
             return state unless resolution

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

@@ -947,7 +947,7 @@ module Legion
 
             attrs = {
               role:            typed_msg.role,
-              content:         typed_msg.content,
+              content:         typed_msg.text,
               conversation_id: conv_id,
               task_id:         typed_msg.task_id
             }

data/lib/legion/llm/inference.rb

@@ -605,7 +605,7 @@ module Legion
                    Call::Dispatch.call(provider: provider, instance: instance, capability: :chat, model: model,
                                        messages: messages, **)
                  end
-        emit_non_pipeline_metering(result, model: model, provider: provider, caller: caller)
+        emit_non_pipeline_metering(result, model: model, provider: provider, caller: caller, messages: messages)
         result
       end
 
@@ -890,14 +890,13 @@ module Legion
         esc[:quality_threshold] || 50
       end
 
-      def emit_non_pipeline_metering(response, model:, provider:, caller: nil)
+      def emit_non_pipeline_metering(response, model:, provider:, caller: nil, messages: nil)
         return unless response
 
-        input  = response.respond_to?(:input_tokens)  ? response.input_tokens.to_i  : 0
-        output = response.respond_to?(:output_tokens) ? response.output_tokens.to_i : 0
-        usage = response.respond_to?(:usage) ? response.usage : {}
-        usage_hash = usage.is_a?(Hash) ? usage : {}
-        thinking = (usage_hash[:thinking_tokens] || usage_hash[:thinking] || 0).to_i
+        usage = response.respond_to?(:usage) ? response.usage : nil
+        input    = usage.respond_to?(:input_tokens)    ? usage.input_tokens.to_i    : 0
+        output   = usage.respond_to?(:output_tokens)   ? usage.output_tokens.to_i   : 0
+        thinking = usage.respond_to?(:thinking_tokens) ? usage.thinking_tokens.to_i : 0
 
         finish = nil
         if response.respond_to?(:stop_reason)
@@ -906,11 +905,17 @@ module Legion
           finish = response.stop[:reason]&.to_s
         end
 
-        meta = response.respond_to?(:meta) ? response.meta : {}
+        meta = response.respond_to?(:metadata) ? response.metadata : {}
         meta_hash = meta.is_a?(Hash) ? meta : {}
         latency = (meta_hash[:latency_ms] || meta_hash.dig(:timing, :latency_ms) || 0).to_i
         wall_clock = (meta_hash[:wall_clock_ms] || meta_hash.dig(:timing, :wall_clock_ms) || 0).to_i
 
+        response_content = if response.respond_to?(:text)
+                             response.text
+                           elsif response.respond_to?(:content)
+                             response.content
+                           end
+
         Legion::LLM::Metering.emit(
           provider:          provider,
           model_id:          model,
@@ -926,7 +931,9 @@ module Legion
           wall_clock_ms:     wall_clock,
           caller:            caller,
           event_type:        'llm_completion',
-          status:            'success'
+          status:            'success',
+          messages:          messages,
+          response_content:  response_content
         )
       rescue StandardError => e
         handle_exception(e, level: :warn, operation: 'llm.inference.non_pipeline_metering')

data/lib/legion/llm/types/message.rb

@@ -93,7 +93,7 @@ module Legion
           return nil unless block.is_a?(Hash)
 
           type = block[:type] || block['type']
-          return nil unless type.nil? || type.to_s == 'text'
+          return nil unless type.nil? || %w[text output_text input_text].include?(type.to_s)
 
           block[:text] || block['text'] || block[:content] || block['content']
         end

data/lib/legion/llm/version.rb

@@ -2,6 +2,6 @@
 
 module Legion
   module LLM
-    VERSION = '0.14.4'
+    VERSION = '0.14.9'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legion-llm
 version: !ruby/object:Gem::Version
-  version: 0.14.4
+  version: 0.14.9
 platform: ruby
 authors:
 - Esity
@@ -141,14 +141,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.6.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.6.0
+        version: 0.6.3
 - !ruby/object:Gem::Dependency
   name: pdf-reader
   requirement: !ruby/object:Gem::Requirement