legion-llm 0.9.17 → 0.9.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce44e3d928a848ab67e5cd50574c7454ff3490a455c1d040c7089641e1091e5e
-  data.tar.gz: ef3eaa05c9340b08f94af99c7b4f35334cef2a1d8dd09aeafb3535532840b4ce
+  metadata.gz: 428a14e141f5cbbb278e05f49fd198ef13f6e789727037c90154a855b76a8b34
+  data.tar.gz: 8dc2aea0cd776675aad1c8ff198b35f0eba573e4a37c6e2bcdc0b6dfbbb7210b
 SHA512:
-  metadata.gz: 1dc635c864ac647911bc6d55a34209f10273471b63683ab4eaa7dc69fdee7d3047c6b028b9d5180688b0b7ed4624c89fa90e5a7745f2462cb30371fe84607a11
-  data.tar.gz: ddd2e32d57a9a56d1fff22c4b7e423145d743183efd7044290482612b704b4c787db9790d28733df53e69a90ed57e4af1d7f6bef89f069ad3a25fafbe09b63ae
+  metadata.gz: 3b9f1b9fae5371eefcbfbc89262bfa422e23df0e2e52d56735c5f3af9912b7245883ae4864568b6d8828e2dfdc3ab8c3d9fd4f125f662d6f8ae51602976d9952
+  data.tar.gz: dcdbf11006d26b929779bdb0e2ae8a541225b3a62c820dd027ef6801198a5056eb1d9a93e7cd504846b11b2196c187d7a415e263592864c3eae5ace4153b31ee

data/CHANGELOG.md

@@ -1,5 +1,55 @@
 # Legion LLM Changelog
 
+## [0.9.22] - 2026-05-12
+
+### Added
+- Pin `legion_list_special_tools` before client and registry tools so models can inspect Legion special tools and the current `Legion::Settings::Extensions` inventory.
+- Surface special Ruby runtime execution with current process/PATH environment metadata, and add Legion-managed Python and pip tools when `legionio setup python` is available.
+
+### Changed
+- Route Python command interception through the same Legion Python runtime detection used by special tool injection.
+- Replace ad hoc `/api/llm/inference` tool-payload debug prints with structured debug logging.
+
+### Fixed
+- Chunk Ollama embedding requests according to configured model context limits and aggregate chunk vectors so large Apollo knowledge-capture documents do not exceed provider context windows.
+
+## [0.9.21] - 2026-05-12
+
+### Fixed
+- Route metering strictly through `legion-transport`, dropping events when transport is unavailable instead of writing metric events to `Legion::Data::Spool`.
+- Keep override confidence database access read-only by removing `Legion::Data::Local` upserts from `legion-llm`.
+- Stop conversation history and sticky state from writing directly to `Legion::Data` tables.
+
+## [0.9.20] - 2026-05-12
+
+### Added
+- Added `llm.gaia.advisory_enabled`, defaulting to `true`, so GAIA pre-request advisory shaping can be disabled without code changes.
+
+### Fixed
+- Preserve accumulated streamed native tool-call arguments from lex-llm provider responses instead of rebuilding final responses from partial stream chunks.
+- Symbolize extension tool arguments before invoking runner keyword methods so JSON string keys such as `chat_id` satisfy Ruby keyword parameters.
+- Match tool triggers from `Legion::Settings::Extensions` registry entries and keep registry tools injectable alongside client tools with better diagnostics.
+- Skip trigger matching cleanly when `Legion::Settings::Extensions` is not loaded instead of warning through a rescued `NameError`.
+- Accumulate only stream fallback state in the lex-llm adapter instead of retaining every streamed chunk when providers return final messages.
+- Apply explicit vLLM tool-name forcing only on the first native tool-loop round, allowing follow-up automatic tool calls after the requested tool returns.
+- Ignore absent GAIA advisory context-window limits when sizing RAG retrieval instead of routing nil through debug exception handling.
+
+## [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

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
@@ -42,6 +43,11 @@ module Legion
 
               tools = raw_tools || []
               validate_tools!(tools) unless tools.empty?
+              raw_tool_count = raw_tools.is_a?(Array) ? raw_tools.size : 0
+              log.debug(
+                "[llm][api][tools] action=request_tools_received request_id=#{request_id} " \
+                "has_tools=#{body.key?(:tools)} raw_tools_class=#{raw_tools&.class} raw_tools_count=#{raw_tool_count}"
+              )
 
               caller_identity = identity_canonical_name(env)
               last_user = messages.select { |m| (m[:role] || m['role']).to_s == 'user' }.last
@@ -88,12 +94,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 +114,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
 
@@ -231,6 +250,14 @@ module Legion
           ext = Registry.for(provider, instance: instance)
           return ext if ext
 
+          if instance && instance.to_s != 'default'
+            ext = Registry.for(provider, instance: :default)
+            if ext
+              log.warn("[llm][native] instance_fallback provider=#{provider} requested=#{instance} using=default")
+              return ext
+            end
+          end
+
           instance_suffix = instance ? "/#{instance}" : ''
           log.error("[llm][native] provider_not_registered provider=#{provider}#{instance_suffix}")
           raise Legion::LLM::ProviderError,
@@ -277,7 +304,6 @@ module Legion
 
           tool_calls = normalize_tool_calls(raw[:tool_calls] || raw['tool_calls'] || raw[:tools] || raw['tools'] || result)
           stop_reason = raw[:stop_reason] || raw['stop_reason'] || (tool_calls.any? ? :tool_use : nil)
-
           {
             result:      result,
             model:       raw[:model] || raw['model'],