lex-llm-vllm 0.3.0 → 0.3.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 172c35debe332979f48575e43bd59c04828449a41a195f3d899bc15afa18bdb2
-  data.tar.gz: c423c24ff7a5e4b33f1b6e562b50c196d2870b347bbcad61b38cd228d54ee318
+  metadata.gz: 66c6939650ded871419a3833d9d0a89e5c31a104f3acccbb065af86af17709cb
+  data.tar.gz: e639e39a60ff4c03838100bd361048997fecfe38e92fdd9f1763809958a43f8e
 SHA512:
-  metadata.gz: dbf9166b8302c7dc786562b7e2e17381b4cf33b570825570cc153dc438bfbef4991e53b0e86811821f08b2a4a00e3b6522bac903764a6bfe3e90f04be4d556ea
-  data.tar.gz: 5ee6cda495f98e9f68c4b3ea79b1a0fa28ab833113a00c3aa9a43e9a67e94c4aa79995faf8d8745e063d7c480d77dde246940d8d6b9c3570d678c39be19b496f
+  metadata.gz: cf346327446a5e3c7b8666c8ea04269d7fea32b7bbe89b9a0c11b7578fe3ca1a8f948cf4fc639265bfcfa6f0a65bca7007f24ce90146f6234f1589fcb6fe5c31
+  data.tar.gz: 1e324da7463bd1a63b14b5fde9b3f6030be0f8cdd933d802d350066beaf40fe8208998a298a848b00126bf5d1d68868b8384c2ed719fb863c825179aa8c92ced

data/CHANGELOG.md

@@ -1,5 +1,62 @@
 # Changelog
 
+## [0.3.11] - 2026-06-20
+
+### Fixed
+- Stub shared registry publishing through `RegistryPublisher#schedule` in specs so async availability-event coverage stays stable after the shared publisher moved off raw `Thread.new`.
+
+## [0.3.10] - 2026-06-20
+
+### Fixed
+- Stop bulk-publishing vLLM model availability from `list_models`; discovery now emits one registry event per seen model from the shared `lex-llm` policy-filter path so blocked models stay observable without duplicate publishes.
+
+## [0.3.9] - 2026-06-20
+
+### Changed
+- Slow the live discovery refresh cadence from 60 seconds to 300 seconds for vLLM instances; `extensions.llm.vllm.discovery_interval` still overrides the default.
+
+## [0.3.8] - 2026-06-20
+
+### Fixed
+- Use the shared `lex-llm` capability override contract for provider, instance, and model settings, with canonical capability normalization for embedding/tool/thinking routing.
+
+## [0.3.7] - 2026-06-19
+
+### Changed
+- Adopt `Legion::Extensions::Llm::Inventory::ScopedRefresher` mixin (lex-llm 0.6.0). Discovery
+  refresh actors now write directly to the live `Inventory` catalog via `Inventory.write_lane`.
+- Pin `lex-llm >= 0.6.0` and `legion-llm >= 0.14.0` in gemspec.
+- Standard `weight: 100` default added to provider instance settings schema.
+
+## 0.3.6 - 2026-06-18
+
+- **Streaming token usage** — request `stream_options: { include_usage: true }` on streaming chat so
+  vLLM emits the final usage-only chunk. Streaming responses now carry input/output token counts;
+  previously every streamed response reported zero tokens, which blinded metering/cost. Overridable
+  per-instance via `config[:stream_token_usage] = false` for a non-conforming OpenAI-compatible
+  backend that rejects the field. The chunk parser already handled the trailing `choices: []` usage
+  chunk; the gap was only that the request never asked for it.
+
+## 0.3.5 - 2026-06-16
+
+- Extract `vllm_api_key` from `credentials: { api_key: ... }` in instance settings so Bearer auth works with the standard settings layout.
+- Fix `Dalli::RingError` crash in `offering_from_model` when cache server is unavailable; cache write is now best-effort.
+
+## 0.3.3 - 2026-06-16
+
+- Dependency updates (concurrent-ruby 1.3.7, faraday 2.14.3, rubocop 1.88.0) and code quality improvements.
+
+## 0.3.2 - 2026-06-15
+
+- **CapabilityPolicy integration** — Optional capabilities default false; use `CapabilityPolicy.resolve` for offerings. Static all-true predicates no longer used for routing truth. Settings overrides at provider/instance/model level supported.
+
+## 0.3.1 - 2026-06-13
+
+- **Gemfile cleanup** — Remove local path overrides; dependencies resolve from gemspec via rubygems.
+- **Bug fix** — Restore vLLM streaming; private `ThinkingExtractor` call was killing every text delta.
+- **Canonical tool normalization** — Use canonical normalization for tool parameter schemas.
+- 155 examples, 0 failures; 17 files, 0 rubocop offenses.
+
 ## 0.3.0 - 2026-06-10
 
 - Add canonical provider translator (`Translator`) implementing `render_request`,

data/Gemfile

@@ -2,12 +2,6 @@
 
 source 'https://rubygems.org'
 
-group :test do
-  transport_path = ENV.fetch('LEGION_TRANSPORT_PATH', File.expand_path('../../legion-transport', __dir__))
-  gem 'legion-transport', path: transport_path if File.directory?(transport_path)
-  # lex-llm >= 0.5.0 carries canonical types + conformance kit (released on rubygems.org)
-end
-
 gemspec
 
 group :development do

data/lex-llm-vllm.gemspec

@@ -27,5 +27,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'legion-logging', '>= 1.3.2'
   spec.add_dependency 'legion-settings', '>= 1.3.14'
   spec.add_dependency 'legion-transport', '>= 1.4.14'
-  spec.add_dependency 'lex-llm', '>= 0.5.0'
+  spec.add_dependency 'lex-llm', '>= 0.6.0'
 end

data/lib/legion/extensions/llm/vllm/actors/discovery_refresh.rb

@@ -1,11 +1,19 @@
 # frozen_string_literal: true
 
+require 'digest'
+
 begin
   require 'legion/extensions/actors/every'
 rescue LoadError => e
   warn(e.message) if $VERBOSE
 end
 
+begin
+  require 'legion/extensions/llm/inventory/scoped_refresher'
+rescue LoadError => e
+  warn(e.message) if $VERBOSE
+end
+
 return unless defined?(Legion::Extensions::Actors::Every)
 
 module Legion
@@ -17,7 +25,11 @@ module Legion
           class DiscoveryRefresh < Legion::Extensions::Actors::Every
             include Legion::Logging::Helper
 
-            REFRESH_INTERVAL = 1800
+            if defined?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
+              include Legion::Extensions::Llm::Inventory::ScopedRefresher
+            end
+
+            def self.every_seconds = 300
 
             def runner_class    = self.class
             def runner_function = 'manual'
@@ -27,19 +39,118 @@ module Legion
             def generate_task?  = false
 
             def time
-              return REFRESH_INTERVAL unless defined?(Legion::Settings)
+              return self.class.every_seconds unless defined?(Legion::Settings)
 
-              Legion::Settings.dig(:extensions, :llm, :vllm, :discovery_interval) || REFRESH_INTERVAL
+              Legion::Settings.dig(:extensions, :llm, :vllm, :discovery_interval) || self.class.every_seconds
             end
 
-            def manual
-              log.debug('[vllm][discovery_refresh] refreshing model list')
-              return unless defined?(Legion::LLM::Discovery)
+            def scope_key                = { provider: :vllm }
+            def offering_type(raw_type)  = %i[embed embedding].include?(raw_type) ? :embedding : :inference
+
+            def vllm_cfg
+              return unless defined?(Legion::Settings)
 
-              Legion::LLM::Discovery.refresh_discovered_models!(provider: :vllm)
+              Legion::Settings.dig(:extensions, :llm,
+                                   :vllm)
+            end
+
+            def compute_lanes_for_scope(**)
+              return [] unless defined?(Legion::LLM::Call::Registry)
+
+              vllm_instances.flat_map { |entry| lanes_from_instance(entry) }
+            rescue StandardError => e
+              handle_exception(e, level: :warn, handled: true, operation: 'vllm.actor.compute_lanes_for_scope')
+              []
+            end
+
+            def credential_hash(**)
+              cfg = vllm_cfg
+              Digest::SHA256.hexdigest(cfg&.dig(:api_key).to_s + cfg&.dig(:instances).to_s)[0, 16]
+            rescue StandardError
+              'unknown'
+            end
+
+            def manual
+              run_scoped_tick
             rescue StandardError => e
               handle_exception(e, level: :warn, handled: true, operation: 'vllm.actor.discovery_refresh')
             end
+
+            private
+
+            def run_scoped_tick
+              return unless defined?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
+              return unless self.class.ancestors.include?(Legion::Extensions::Llm::Inventory::ScopedRefresher)
+
+              tick
+            end
+
+            def vllm_instances
+              Legion::LLM::Call::Registry.all_instances.select { |e| (e[:provider] || '').to_sym == :vllm }
+            end
+
+            def lanes_from_instance(instance_entry)
+              adapter = instance_entry[:adapter]
+              return [] unless adapter.respond_to?(:discover_offerings)
+
+              Array(adapter.discover_offerings(live: true)).flat_map do |offering|
+                raw  = offering_to_hash(offering)
+                lane = build_lane(raw, instance_entry)
+                fleet = maybe_fleet_lane(lane)
+                fleet ? [lane, fleet] : [lane]
+              end
+            end
+
+            # ModelOffering objects do not implement `[]`; normalize to a Hash so the
+            # rest of the writer stays Hash-shaped. Hash inputs pass through untouched.
+            def offering_to_hash(offering)
+              return offering if offering.is_a?(Hash)
+
+              hash = offering.to_h
+              hash[:type] ||= hash[:usage_type]
+              hash[:enabled] = offering.respond_to?(:enabled?) ? offering.enabled? : true
+              hash
+            end
+
+            def build_lane(offering, instance_entry) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity
+              tier            = offering[:tier] || :direct
+              type            = offering_type(offering[:type])
+              instance_id     = offering[:instance_id] ||
+                                instance_entry[:instance] ||
+                                instance_entry[:instance_id] ||
+                                instance_entry[:id]
+              provider_family = offering[:provider_family] || :vllm
+              model           = offering[:model]
+              lane_id = Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(
+                tier: tier, provider_family: provider_family, instance_id: instance_id, type: type, model: model
+              )
+              { id: lane_id, tier: tier, provider_family: provider_family, instance_id: instance_id,
+                model: model, canonical_model_alias: offering[:canonical_model_alias], type: type,
+                capabilities: normalize_caps(offering[:capabilities]),
+                limits: offering[:limits] || {}, enabled: offering.fetch(:enabled, true), cost: offering[:cost] || {} }
+            end
+
+            def maybe_fleet_lane(lane)
+              return unless lane[:type] == :inference && vllm_cfg&.dig(:fleet, :dispatch, :enabled)
+
+              fleet_id = Legion::Extensions::Llm::Inventory::ScopedRefresher.compose_id(
+                tier: :fleet, provider_family: lane[:provider_family],
+                instance_id: lane[:instance_id], type: lane[:type], model: lane[:model]
+              )
+              lane.merge(id: fleet_id, tier: :fleet)
+            end
+
+            def normalize_caps(caps)
+              # Inventory::Capabilities lives in lex-llm; the previous fallback (`return []
+              # unless defined?(...)`) silently swallowed every capability the operator
+              # declared via enable_thinking/enable_tools when the constant wasn't loaded.
+              # Always normalize through the shared vocabulary so aliases collapse.
+              if defined?(Legion::Extensions::Llm::Inventory::Capabilities)
+                Legion::Extensions::Llm::Inventory::Capabilities.normalize(caps)
+              else
+                Array(caps).compact.map(&:to_sym).uniq
+              end
+            end
           end
         end
       end

data/lib/legion/extensions/llm/vllm/provider.rb

@@ -33,9 +33,9 @@ module Legion
 
             def chat?(_model) = true
             def streaming?(_model) = true
-            def vision?(_model) = true
-            def functions?(_model) = true
-            def embeddings?(_model) = true
+            def vision?(_model) = false
+            def functions?(_model) = false
+            def embeddings?(_model) = false
 
             def critical_capabilities_for(model)
               [
@@ -78,7 +78,7 @@ module Legion
 
           def health(live: false)
             log.info { "checking health live=#{live} at #{api_base}#{health_url}" }
-            connection.get(health_url).body
+            super
           end
 
           def readiness(live: false)
@@ -88,27 +88,20 @@ module Legion
             end
           end
 
-          def list_models
+          def list_models(live: false, **filters)
             log.info { "discovering models from #{api_base}#{models_url}" }
             super.tap do |models|
               log.info { "discovered #{models.size} model(s) from vLLM" }
-              self.class.registry_publisher.publish_models_async(models, readiness: readiness(live: false))
             end
           end
 
-          def discover_offerings(live: false, **)
-            models = if live
-                       @cached_models = list_models
-                     else
-                       Array(@cached_models)
-                     end
-            offerings = models.filter_map do |model_info|
-              next unless model_allowed?(model_info.id)
+          def discover_offerings(live: false, **filters)
+            return filter_cached_offerings(Array(@cached_offerings), filters) unless live
 
-              offering_from_model(model_info)
-            end
-            log.debug { "built #{offerings.size} vLLM offering(s) live=#{live}" }
-            offerings
+            provider_health = health(live:)
+            @cached_offerings = discover_live_offerings(filters, provider_health, live:)
+            log_discover_complete(@cached_offerings)
+            @cached_offerings
           rescue StandardError => e
             handle_exception(e, level: :warn, handled: true, operation: 'vllm.discover_offerings')
             []
@@ -161,9 +154,68 @@ module Legion
 
           private
 
-          def offering_from_model(model_info)
+          def discovery_registry_readiness(provider_health, live:)
+            {
+              provider: slug.to_sym,
+              configured: configured?,
+              ready: provider_health[:ready] == true,
+              live: live,
+              health: provider_health
+            }
+          end
+
+          def discover_live_offerings(filters, provider_health, live:)
+            readiness = discovery_registry_readiness(provider_health, live:)
+            Array(list_models(live:, **filters)).filter_map do |model|
+              self.class.registry_publisher.publish_models_async([model], readiness:)
+              next unless model_matches_filters?(model, filters)
+              next unless model_allowed?(model.id)
+
+              log_model_discovered(model)
+              offering_from_model(model, health: provider_health)
+            end
+          end
+
+          def log_model_discovered(model)
+            log.debug(
+              "[#{slug}] instance=#{provider_instance_id} action=model_discovered " \
+              "model=#{model.id} family=#{model.family}"
+            )
+          end
+
+          def log_discover_complete(offerings)
+            log.info(
+              "[#{slug}] instance=#{provider_instance_id} action=discover_complete " \
+              "model_count=#{Array(offerings).size}"
+            )
+          end
+
+          def offering_from_model(model_info, health: {})
             ctx = model_info.context_length
-            cache_set(model_detail_cache_key(model_info.id), { context_window: ctx }, ttl: 86_400) if ctx
+            if ctx
+              begin
+                cache_set(model_detail_cache_key(model_info.id), { context_window: ctx }, ttl: 86_400)
+              rescue StandardError => e
+                handle_exception(e, level: :warn, handled: true, operation: 'vllm.cache_model_detail')
+              end
+            end
+
+            policy = Legion::Extensions::Llm::CapabilityPolicy.resolve(
+              real: extract_real_capabilities(model_info),
+              provider_catalog: {},
+              probe: {},
+              provider_envelope: provider_envelope_capabilities,
+              provider_config: provider_capability_config,
+              instance_config: instance_capability_config,
+              model_config: model_capability_config(model_info.id)
+            )
+
+            build_offering(model_info, policy, ctx, health)
+          end
+
+          def build_offering(model_info, policy, ctx, health) # rubocop:disable Metrics/AbcSize
+            max_out = model_info.respond_to?(:max_output_tokens) ? model_info.max_output_tokens : nil
+            usage_type = policy[:capabilities].include?(:embedding) ? :embedding : :inference
 
             Legion::Extensions::Llm::Routing::ModelOffering.new(
               provider_family: :vllm,
@@ -171,13 +223,39 @@ module Legion
               transport: offering_transport,
               tier: offering_tier,
               model: model_info.id,
-              usage_type: model_info.embedding? ? :embedding : :inference,
-              capabilities: model_info.capabilities.map(&:to_s),
-              limits: { context_window: ctx }.compact,
-              metadata: { context_length: ctx }
+              canonical_model_alias: model_info.respond_to?(:name) ? model_info.name : nil,
+              model_family: model_info.respond_to?(:family) ? model_info.family : nil,
+              usage_type: usage_type,
+              capabilities: policy[:capabilities],
+              capability_sources: policy[:sources],
+              limits: { context_window: ctx, max_output_tokens: max_out }.compact,
+              health: health,
+              metadata: offering_metadata_for(model_info).merge(capability_sources: policy[:sources])
             )
           end
 
+          def extract_real_capabilities(model_info)
+            return {} unless model_info.respond_to?(:metadata)
+
+            meta = model_info.metadata
+            meta_caps = meta.is_a?(Hash) ? meta[:capabilities] : nil
+            meta_caps.is_a?(Hash) ? meta_caps : {}
+          end
+
+          def provider_envelope_capabilities
+            { completion: true, streaming: true }
+          end
+
+          def offering_metadata_for(model_info)
+            {
+              raw_model: model_info.id,
+              parameter_count: model_info.respond_to?(:parameter_count) ? model_info.parameter_count : nil,
+              parameter_size: model_info.respond_to?(:parameter_size) ? model_info.parameter_size : nil,
+              quantization: model_info.respond_to?(:quantization) ? model_info.quantization : nil,
+              size_bytes: model_info.respond_to?(:size_bytes) ? model_info.size_bytes : nil
+            }.compact
+          end
+
           # ── Canonical bridge: legacy provider API → Canonical::Request ──
 
           # rubocop:disable Metrics/ParameterLists, Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity -- bridge method can be complex
@@ -281,7 +359,7 @@ module Legion
               role: :assistant,
               content: content,
               model_id: raw_data['model'],
-              tool_calls: nil,
+              tool_calls: legacy_chunk_tool_calls(canonical),
               thinking: thinking,
               input_tokens: usage.respond_to?(:input_tokens) ? usage.input_tokens : nil,
               output_tokens: usage.respond_to?(:output_tokens) ? usage.output_tokens : nil,
@@ -289,6 +367,24 @@ module Legion
             )
           end
 
+          # Map a canonical tool_call_delta onto the legacy chunk tool_calls hash.
+          # Fragment semantics matter: an entry with a non-nil id starts a new tool
+          # call in the StreamAccumulator; a nil id appends the raw arguments
+          # fragment to the most recently started call.
+          def legacy_chunk_tool_calls(canonical)
+            return nil unless canonical.type == :tool_call_delta && canonical.tool_call
+
+            tc = canonical.tool_call
+            key = (tc.id || tc.name || :fragment).to_s.to_sym
+            {
+              key => Legion::Extensions::Llm::ToolCall.new(
+                id: tc.id,
+                name: tc.name,
+                arguments: tc.arguments
+              )
+            }
+          end
+
           # ── Tool choice helpers ──
 
           def format_tool_choice_from_prefs(tool_prefs)
@@ -344,7 +440,7 @@ module Legion
           def vllm_thinking_setting
             instance_thinking_enabled? || global_thinking_enabled?
           rescue StandardError => e
-            handle_exception(e, level: :debug, handled: true, operation: 'vllm.thinking_setting')
+            handle_exception(e, level: :warn, handled: true, operation: 'vllm.thinking_setting')
             false
           end
 

data/lib/legion/extensions/llm/vllm/runners/fleet_worker.rb

@@ -37,7 +37,7 @@ module Legion
 
               payload[key] || payload[key.to_s]
             rescue StandardError => e
-              handle_exception(e, level: :debug, handled: true, operation: 'vllm.fleet_worker.payload_field',
+              handle_exception(e, level: :warn, handled: true, operation: 'vllm.fleet_worker.payload_field',
                                   field: key)
               nil
             end

data/lib/legion/extensions/llm/vllm/translator.rb

@@ -70,6 +70,7 @@ module Legion
             payload[:tools] = format_tools(request.tools) unless request.tools.to_h.empty?
             payload[:tool_choice] = format_tool_choice(request.tool_choice) if request.tool_choice
             payload.merge!(map_params_to_wire(request.params)) if request.params
+            payload[:stream_options] = { include_usage: true } if request.stream && stream_token_usage?
             apply_thinking_config(payload, request)
             if formatted_response_format?(request.params)
               payload[:response_format] =
@@ -164,24 +165,8 @@ module Legion
               )
             end
 
-            tool_calls = delta['tool_calls']
-            unless Array(tool_calls).empty?
-              first_call = tool_calls.first
-              function = first_call.fetch('function', {})
-
-              tc = Canonical::ToolCall.build(
-                id: (first_call['id'] || function['name'] || 'synthesized').to_s,
-                name: function['name'].to_s,
-                arguments: parse_tool_arguments(function['arguments']),
-                source: :client
-              )
-
-              return Canonical::Chunk.tool_call_delta(
-                tool_call: tc,
-                request_id: request_id,
-                block_index: first_call['index']
-              )
-            end
+            tool_calls = Array(delta['tool_calls'])
+            return build_tool_call_delta_chunk(tool_calls.first, request_id) unless tool_calls.empty?
 
             # Thinking delta from reasoning_content
             reasoning_content = delta['reasoning_content'] || delta['reasoning']
@@ -224,10 +209,23 @@ module Legion
 
           attr_reader :config
 
+          # OpenAI `stream_options.include_usage` asks the server to emit a final
+          # usage-only chunk (choices:[]) so streaming responses carry token counts.
+          # vLLM supports it (capability streaming_token_usage); defaults on, but a
+          # non-conforming OpenAI-compatible backend that rejects the field can opt
+          # out per-instance via config[:stream_token_usage] = false.
+          def stream_token_usage?
+            override = config.respond_to?(:[]) ? config[:stream_token_usage] : nil
+            return override != false unless override.nil?
+
+            capabilities[:streaming_token_usage] == true
+          end
+
           # ── Message formatting ──
 
           def format_messages(request)
-            messages = format_request_messages(request.messages)
+            non_system = request.messages&.reject { |m| m.role.to_s == 'system' } || []
+            messages = format_request_messages(non_system)
 
             if request.system.to_s.strip.empty?
               messages
@@ -345,7 +343,8 @@ module Legion
           def format_message_tool_calls(tool_calls)
             return [] if tool_calls.empty?
 
-            tool_calls.map { |tc| format_tool_call_for_history(tc) }
+            tc_array = tool_calls.is_a?(Hash) ? tool_calls.values : Array(tool_calls)
+            tc_array.map { |tc| format_tool_call_for_history(tc) }
           end
 
           def format_tool_call_for_history(tool_call_entry)
@@ -387,10 +386,9 @@ module Legion
 
               name = tool_hash[:name] || tool_hash['name']
               description = (tool_hash[:description] || tool_hash['description'] || '').to_s
-              parameters = tool_hash[:parameters] || tool_hash[:input_schema] ||
-                           { type: 'object', properties: {} }
-              parameters = parameters.to_h if parameters.respond_to?(:to_h) && !parameters.is_a?(Hash)
-              parameters = { type: 'object', properties: {} } unless parameters.is_a?(Hash)
+              raw_params = tool_hash[:parameters] || tool_hash[:input_schema]
+              raw_params = raw_params.to_h if raw_params.respond_to?(:to_h) && !raw_params.is_a?(Hash)
+              parameters = Legion::Extensions::Llm::Canonical::ToolDefinition.normalize_parameters(raw_params)
 
               {
                 type: 'function',
@@ -633,26 +631,48 @@ module Legion
             )
           end
 
+          # Build a tool_call_delta chunk preserving OpenAI streaming fragment
+          # semantics: the opening fragment carries id + name; continuation
+          # fragments carry id: nil and a raw partial-JSON arguments string.
+          # The StreamAccumulator keys off a nil id to append fragments to the
+          # current tool call, so the id must NOT be synthesized here.
+          def build_tool_call_delta_chunk(first_call, request_id)
+            function = first_call.fetch('function', {})
+
+            tc = Canonical::ToolCall.new(
+              id: first_call['id'], exchange_id: nil,
+              name: function['name'], arguments: function['arguments'].to_s,
+              source: :client, status: nil, duration_ms: nil, result: nil,
+              error: nil, started_at: nil, finished_at: nil, category: nil,
+              data_handling_classification: nil, policy_decision: nil
+            )
+
+            Canonical::Chunk.tool_call_delta(
+              tool_call: tc,
+              request_id: request_id,
+              block_index: first_call['index']
+            )
+          end
+
           def empty_delta?(delta)
             (delta['content'].nil? || delta['content'].to_s.empty?) &&
               (delta['tool_calls'].nil? || Array(delta['tool_calls']).empty?) &&
               (delta['reasoning_content'].nil? || delta['reasoning_content'].to_s.empty?)
           end
 
+          # Per-chunk think-tag extraction is structurally impossible while streaming:
+          # tags arrive split across SSE chunks, and ThinkingExtractor strips per-chunk
+          # whitespace, corrupting reassembled text. Emit the raw delta unmodified —
+          # the StreamAccumulator extracts think tags statefully across deltas.
+          # (Previously called ThinkingExtractor.extract_from_content, which is
+          # private_class_method in lex-llm >= 0.5.0 and raised NoMethodError on
+          # every streamed text delta, silently killing all vLLM streaming.)
           def parse_text_delta_with_thinking(content, request_id, data)
-            extraction = Responses::ThinkingExtractor.extract_from_content(content)
-            clean_text = extraction[0]
-            thinking_text = extraction[1]
-
-            if thinking_text && !thinking_text.empty?
-              Canonical::Chunk.thinking_delta(delta: thinking_text, request_id: request_id)
-            else
-              Canonical::Chunk.text_delta(
-                delta: clean_text || content,
-                request_id: request_id,
-                index: data['index']
-              )
-            end
+            Canonical::Chunk.text_delta(
+              delta: content,
+              request_id: request_id,
+              index: data['index']
+            )
           end
 
           # Parse a canonical-form chunk (from conformance kit fixtures).

data/lib/legion/extensions/llm/vllm/version.rb

@@ -4,7 +4,7 @@ module Legion
   module Extensions
     module Llm
       module Vllm
-        VERSION = '0.3.0'
+        VERSION = '0.3.11'
       end
     end
   end

data/lib/legion/extensions/llm/vllm.rb

@@ -16,7 +16,7 @@ module Legion
         extend Legion::Extensions::Llm::AutoRegistration
 
         PROVIDER_FAMILY = :vllm
-        DEFAULT_INSTANCE_TIER = { tier: :direct, capabilities: %i[completion streaming vision tools] }.freeze
+        DEFAULT_INSTANCE_TIER = { tier: :direct, capabilities: {}, provider_capabilities: { streaming: true } }.freeze
 
         def self.default_settings
           ::Legion::Extensions::Llm.provider_settings(
@@ -32,10 +32,7 @@ module Legion
               fleet: {
                 enabled: false,
                 respond_to_requests: false,
-                capabilities: %i[chat stream_chat embed],
-                lanes: [],
-                concurrency: 1,
-                queue_suffix: nil
+                capabilities: %i[chat stream_chat embed]
               }
             }
           )
@@ -74,10 +71,19 @@ module Legion
         def self.normalize_instance_config(config)
           normalized = config.to_h.transform_keys(&:to_sym)
           resolve_api_base_aliases(normalized)
+          resolve_credentials(normalized)
           normalized[:tier] ||= infer_tier_from_endpoint(normalized[:vllm_api_base])
           normalized
         end
 
+        def self.resolve_credentials(normalized)
+          creds = normalized.delete(:credentials)
+          return unless creds.is_a?(Hash)
+
+          creds = creds.transform_keys(&:to_sym)
+          normalized[:vllm_api_key] ||= creds[:api_key]
+        end
+
         def self.resolve_api_base_aliases(normalized)
           normalized[:vllm_api_base] ||= normalized.delete(:base_url)
           normalized[:vllm_api_base] ||= normalized.delete(:api_base)
@@ -93,12 +99,15 @@ module Legion
           return :direct if url.nil? || url.to_s.empty?
 
           require 'uri'
+          require_relative 'vllm/actors/discovery_refresh'
           host = URI.parse(url.to_s).host.to_s.downcase
           %w[localhost 127.0.0.1 ::1].include?(host) ? :local : :direct
         rescue URI::InvalidURIError => e
-          handle_exception(e, level: :debug, handled: true, operation: 'vllm.infer_tier_from_endpoint')
+          handle_exception(e, level: :warn, handled: true, operation: 'vllm.infer_tier_from_endpoint')
           :direct
         end
+
+        Legion::Extensions::Llm::Configuration.register_provider_options(Provider.configuration_options)
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lex-llm-vllm
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.11
 platform: ruby
 authors:
 - LegionIO
@@ -71,14 +71,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.5.0
+        version: 0.6.0
 description: vLLM provider integration for the LegionIO LLM routing framework.
 email:
 - matthewdiverson@gmail.com